src/OBJECT/SMESH_Object.cxx

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  SMESH OBJECT : interactive object for SMESH visualization
  24 //  File   : SMESH_Grid.cxx
  25 //  Author : Nicolas REJNERI
  26 //  Module : SMESH
  27 //
  28 #include "SMESH_ObjectDef.h"
  29 #include "SMESH_ActorUtils.h"
  30
  31 #include "SMDS_BallElement.hxx"
  32 #include "SMDS_Mesh.hxx"
  33 #include "SMDS_MeshCell.hxx"
  34 #include "SMDS_PolyhedralVolumeOfNodes.hxx"
  35 #include "SMESH_Actor.h"
  36 #include "SMESH_ControlsDef.hxx"
  37
  38 #include <SalomeApp_Application.h>
  39 #include <VTKViewer_ExtractUnstructuredGrid.h>
  40 #include <VTKViewer_CellLocationsArray.h>
  41
  42 #include CORBA_SERVER_HEADER(SMESH_Gen)
  43 #include CORBA_SERVER_HEADER(SALOME_Exception)
  44
  45 #include <vtkCell.h>
  46 #include <vtkIdList.h>
  47 #include <vtkCellArray.h>
  48 #include <vtkUnsignedCharArray.h>
  49 #include <vtkCellData.h>
  50 #include <vtkUnstructuredGrid.h>
  51
  52 #include <memory>
  53 #include <sstream>
  54 #include <stdexcept>
  55 #include <set>
  56
  57 #include "utilities.h"
  58
  59 using namespace std;
  60
  61 #ifndef EXCEPTION
  62 #define EXCEPTION(TYPE, MSG) {\
  63   std::ostringstream aStream;\
  64   aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
  65   throw TYPE(aStream.str());\
  66 }
  67 #endif
  68
  69 #ifdef _DEBUG_
  70 static int MYDEBUG = 1;
  71 static int MYDEBUGWITHFILES = 0;//1;
  72 #else
  73 static int MYDEBUG = 0;
  74 static int MYDEBUGWITHFILES = 0;
  75 #endif
  76
  77
  78 /*
  79   Class       : SMESH_VisualObjDef
  80   Description : Base class for all mesh objects to be visuilised
  81 */
  82
  83 //=================================================================================
  84 // function : getCellType
  85 // purpose  : Get type of VTK cell
  86 //=================================================================================
  87 // static inline vtkIdType getCellType( const SMDSAbs_ElementType theType,
  88 //                                      const bool                thePoly,
  89 //                                      const int                 theNbNodes )
  90 // {
  91 //   switch( theType )
  92 //   {
  93 //     case SMDSAbs_0DElement:         return VTK_VERTEX;
  94
  95 //     case SMDSAbs_Ball:              return VTK_POLY_VERTEX;
  96
  97 //     case SMDSAbs_Edge:
  98 //       if( theNbNodes == 2 )         return VTK_LINE;
  99 //       else if ( theNbNodes == 3 )   return VTK_QUADRATIC_EDGE;
 100 //       else return VTK_EMPTY_CELL;
 101
 102 //     case SMDSAbs_Face  :
 103 //       if (thePoly && theNbNodes>2 ) return VTK_POLYGON;
 104 //       else if ( theNbNodes == 3 )   return VTK_TRIANGLE;
 105 //       else if ( theNbNodes == 4 )   return VTK_QUAD;
 106 //       else if ( theNbNodes == 6 )   return VTK_QUADRATIC_TRIANGLE;
 107 //       else if ( theNbNodes == 8 )   return VTK_QUADRATIC_QUAD;
 108 //       else if ( theNbNodes == 9 )   return VTK_BIQUADRATIC_QUAD;
 109 //       else if ( theNbNodes == 7 )   return VTK_BIQUADRATIC_TRIANGLE;
 110 //       else return VTK_EMPTY_CELL;
 111
 112 //     case SMDSAbs_Volume:
 113 //       if (thePoly && theNbNodes>3 ) return VTK_POLYHEDRON; //VTK_CONVEX_POINT_SET;
 114 //       else if ( theNbNodes == 4 )   return VTK_TETRA;
 115 //       else if ( theNbNodes == 5 )   return VTK_PYRAMID;
 116 //       else if ( theNbNodes == 6 )   return VTK_WEDGE;
 117 //       else if ( theNbNodes == 8 )   return VTK_HEXAHEDRON;
 118 //       else if ( theNbNodes == 12 )  return VTK_HEXAGONAL_PRISM;
 119 //       else if ( theNbNodes == 10 )  return VTK_QUADRATIC_TETRA;
 120 //       else if ( theNbNodes == 20 )  return VTK_QUADRATIC_HEXAHEDRON;
 121 //       else if ( theNbNodes == 27 )  return VTK_TRIQUADRATIC_HEXAHEDRON;
 122 //       else if ( theNbNodes == 15 )  return VTK_QUADRATIC_WEDGE;
 123 //       else if ( theNbNodes == 13 )  return VTK_QUADRATIC_PYRAMID; //VTK_CONVEX_POINT_SET;
 124 //       else return VTK_EMPTY_CELL;
 125
 126 //     default: return VTK_EMPTY_CELL;
 127 //   }
 128 // }
 129
 130 //=================================================================================
 131 // functions : SMESH_VisualObjDef
 132 // purpose   : Constructor
 133 //=================================================================================
 134 SMESH_VisualObjDef::SMESH_VisualObjDef()
 135 {
 136   MESSAGE("---------------------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
 137   myGrid = vtkUnstructuredGrid::New();
 138   myLocalGrid = false;
 139   ClearEntitiesFlags();
 140   SMESH::GetEntitiesFromObject(NULL);
 141 }
 142 SMESH_VisualObjDef::~SMESH_VisualObjDef()
 143 {
 144   MESSAGE("---------------------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
 145   //if ( MYDEBUG )
 146     MESSAGE( "~SMESH_MeshObj - myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
 147   myGrid->Delete();
 148 }
 149
 150 //=================================================================================
 151 // functions : GetNodeObjId, GetNodeVTKId, GetElemObjId, GetElemVTKId
 152 // purpose   : Methods for retrieving VTK IDs by SMDS IDs and  vice versa
 153 //=================================================================================
 154 vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
 155 {
 156   if (myLocalGrid)
 157   {
 158     TMapOfIds::const_iterator i = myVTK2SMDSNodes.find(theVTKID);
 159     return i == myVTK2SMDSNodes.end() ? -1 : i->second;
 160   }
 161   const SMDS_MeshNode* aNode = 0;
 162   if( this->GetMesh() )
 163     aNode = this->GetMesh()->FindNodeVtk( theVTKID );
 164
 165   return aNode ? aNode->GetID() : -1;
 166 }
 167
 168 vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
 169 {
 170   if (myLocalGrid)
 171   {
 172     TMapOfIds::const_iterator i = mySMDS2VTKNodes.find(theObjID);
 173     return i == mySMDS2VTKNodes.end() ? -1 : i->second;
 174   }
 175
 176   const SMDS_MeshNode* aNode = 0;
 177   if( this->GetMesh() ) {
 178     aNode = this->GetMesh()->FindNode(theObjID);
 179   }
 180   return aNode ? aNode->getVtkId() : -1;
 181 }
 182
 183 vtkIdType SMESH_VisualObjDef::GetElemObjId( int theVTKID )
 184 {
 185   if (myLocalGrid)
 186   {
 187     TMapOfIds::const_iterator i = myVTK2SMDSElems.find(theVTKID);
 188     return i == myVTK2SMDSElems.end() ? -1 : i->second;
 189   }
 190   return this->GetMesh()->fromVtkToSmds(theVTKID);
 191 }
 192
 193 vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
 194 {
 195   if (myLocalGrid)
 196   {
 197     TMapOfIds::const_iterator i = mySMDS2VTKElems.find(theObjID);
 198     return i == mySMDS2VTKElems.end() ? -1 : i->second;
 199   }
 200
 201   const SMDS_MeshElement* e = 0;
 202   if ( this->GetMesh() )
 203     e = this->GetMesh()->FindElement(theObjID);
 204
 205   return e ? e->getVtkId() : -1;
 206 }
 207
 208 //=================================================================================
 209 // function : SMESH_VisualObjDef::createPoints
 210 // purpose  : Create points from nodes
 211 //=================================================================================
 212 /*! fills a vtkPoints structure for a submesh.
 213  *  fills a std::list of SMDS_MeshElements*, then extract the points.
 214  *  fills also conversion id maps between SMDS and VTK.
 215  */
 216 void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
 217 {
 218   if ( thePoints == 0 )
 219     return;
 220
 221   TEntityList aNodes;
 222   vtkIdType nbNodes = GetEntities( SMDSAbs_Node, aNodes );
 223   thePoints->SetNumberOfPoints( nbNodes );
 224
 225   int nbPoints = 0;
 226
 227   TEntityList::const_iterator anIter;
 228   for ( anIter = aNodes.begin(); anIter != aNodes.end(); ++anIter )
 229   {
 230     const SMDS_MeshNode* aNode = ( const SMDS_MeshNode* )(*anIter);
 231     if ( aNode != 0 )
 232     {
 233       thePoints->SetPoint( nbPoints, aNode->X(), aNode->Y(), aNode->Z() );
 234       int anId = aNode->GetID();
 235       mySMDS2VTKNodes.insert( TMapOfIds::value_type( anId, nbPoints ) );
 236       myVTK2SMDSNodes.insert( TMapOfIds::value_type( nbPoints, anId ) );
 237       nbPoints++;
 238     }
 239   }
 240
 241   if ( nbPoints != nbNodes )
 242     thePoints->SetNumberOfPoints( nbPoints );
 243 }
 244
 245 //=================================================================================
 246 // function : buildPrs
 247 // purpose  : create VTK cells( fill unstructured grid )
 248 //=================================================================================
 249 void SMESH_VisualObjDef::buildPrs(bool buildGrid)
 250 {
 251   MESSAGE("----------------------------------------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
 252   if (buildGrid)
 253   {
 254         myLocalGrid = true;
 255         try
 256         {
 257                 mySMDS2VTKNodes.clear();
 258                 myVTK2SMDSNodes.clear();
 259                 mySMDS2VTKElems.clear();
 260                 myVTK2SMDSElems.clear();
 261
 262                 if ( IsNodePrs() )
 263                         buildNodePrs();
 264                 else
 265                         buildElemPrs();
 266         }
 267         catch(...)
 268         {
 269                 mySMDS2VTKNodes.clear();
 270                 myVTK2SMDSNodes.clear();
 271                 mySMDS2VTKElems.clear();
 272                 myVTK2SMDSElems.clear();
 273
 274                 myGrid->SetPoints( 0 );
 275                 myGrid->SetCells( 0, 0, 0, 0, 0 );
 276                 throw;
 277         }
 278   }
 279   else
 280   {
 281         myLocalGrid = false;
 282         if (!GetMesh()->isCompacted())
 283           {
 284             MESSAGE("*** buildPrs ==> compactMesh!");
 285             GetMesh()->compactMesh();
 286           }
 287         vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
 288         updateEntitiesFlags();
 289         myGrid->ShallowCopy(theGrid);
 290         //MESSAGE(myGrid->GetReferenceCount());
 291         //MESSAGE( "Update - myGrid->GetNumberOfCells() = "<<myGrid->GetNumberOfCells() );
 292         //MESSAGE( "Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints() );
 293         if( MYDEBUGWITHFILES ) {
 294           SMESH::WriteUnstructuredGrid( myGrid,"myPrs.vtu" );
 295         }
 296   }
 297 }
 298
 299 //=================================================================================
 300 // function : buildNodePrs
 301 // purpose  : create VTK cells for nodes
 302 //=================================================================================
 303
 304 void SMESH_VisualObjDef::buildNodePrs()
 305 {
 306   // PAL16631: without swap, bad_alloc is not thrown but hung up and crash instead,
 307   // so check remaining memory size for safety
 308   SMDS_Mesh::CheckMemory(); // PAL16631
 309   vtkPoints* aPoints = vtkPoints::New();
 310   createPoints( aPoints );
 311   SMDS_Mesh::CheckMemory();
 312   myGrid->SetPoints( aPoints );
 313   aPoints->Delete();
 314
 315   myGrid->SetCells( 0, 0, 0, 0, 0 );
 316 }
 317
 318 //=================================================================================
 319 // function : buildElemPrs
 320 // purpose  : Create VTK cells for elements
 321 //=================================================================================
 322
 323 namespace{
 324   typedef std::vector<const SMDS_MeshElement*> TConnect;
 325
 326   int GetConnect(const SMDS_ElemIteratorPtr& theNodesIter,
 327                  TConnect& theConnect)
 328   {
 329     theConnect.clear();
 330     for(; theNodesIter->more();)
 331       theConnect.push_back(theNodesIter->next());
 332     return theConnect.size();
 333   }
 334
 335   inline
 336   void SetId(vtkIdList *theIdList,
 337              const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes,
 338              const TConnect& theConnect,
 339              int thePosition,
 340              int theId)
 341   {
 342     theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second);
 343   }
 344
 345 }
 346
 347
 348 void SMESH_VisualObjDef::buildElemPrs()
 349 {
 350   // Create points
 351
 352   vtkPoints* aPoints = vtkPoints::New();
 353   createPoints( aPoints );
 354   myGrid->SetPoints( aPoints );
 355   aPoints->Delete();
 356
 357   if ( MYDEBUG )
 358     MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
 359
 360   // Calculate cells size
 361
 362   const int nbTypes = 5;
 363   static SMDSAbs_ElementType aTypes[ nbTypes ] =
 364     { SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDSAbs_Ball, SMDSAbs_0DElement };
 365
 366   // get entity data
 367   map<SMDSAbs_ElementType,int> nbEnts;
 368   map<SMDSAbs_ElementType,TEntityList> anEnts;
 369
 370   vtkIdType aNbCells = 0;
 371
 372   for ( int i = 0; i < nbTypes; i++ )
 373   {
 374     nbEnts[ aTypes[ i ] ] = GetEntities( aTypes[ i ], anEnts[ aTypes[ i ] ] );
 375     aNbCells += nbEnts[ aTypes [ i ]];
 376   }
 377   // PAL16631: without swap, bad_alloc is not thrown but hung up and crash instead,
 378   // so check remaining memory size for safety
 379   SMDS_Mesh::CheckMemory(); // PAL16631
 380
 381   vtkIdType aCellsSize =  2 * nbEnts[ SMDSAbs_0DElement ] + 3 * nbEnts[ SMDSAbs_Edge ];
 382   aCellsSize += 2 * nbEnts[ SMDSAbs_Ball ];
 383
 384   for ( int i = 1; i <= 2; i++ ) // iterate through faces and volumes
 385   {
 386     if ( nbEnts[ aTypes[ i ] ] )
 387     {
 388       const TEntityList& aList = anEnts[ aTypes[ i ] ];
 389       TEntityList::const_iterator anIter;
 390       for ( anIter = aList.begin(); anIter != aList.end(); ++anIter ) {
 391         if((*anIter)->GetEntityType() != SMDSEntity_Polyhedra &&
 392            (*anIter)->GetEntityType() != SMDSEntity_Quad_Polyhedra) {
 393           aCellsSize += (*anIter)->NbNodes() + 1;
 394         }
 395         // Special case for the VTK_POLYHEDRON:
 396         // itsinput cellArray is of special format.
 397         //  [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]
 398         else {
 399           if( const SMDS_VtkVolume* ph = dynamic_cast<const SMDS_VtkVolume*>(*anIter) ) {
 400             int nbFaces = ph->NbFaces();
 401             aCellsSize += (1 + ph->NbFaces());
 402             for( int i = 1; i <= nbFaces; i++ ) {
 403               aCellsSize += ph->NbFaceNodes(i);
 404             }
 405           }
 406         }
 407       }
 408     }
 409   }
 410   if ( MYDEBUG )
 411     MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
 412
 413   // Create cells
 414
 415   vtkCellArray* aConnectivity = vtkCellArray::New();
 416   aConnectivity->Allocate( aCellsSize, 0 );
 417
 418   SMDS_Mesh::CheckMemory(); // PAL16631
 419
 420   vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 421   aCellTypesArray->SetNumberOfComponents( 1 );
 422   aCellTypesArray->Allocate( aNbCells * aCellTypesArray->GetNumberOfComponents() );
 423
 424   SMDS_Mesh::CheckMemory(); // PAL16631
 425
 426   vtkIdList *anIdList = vtkIdList::New();
 427   vtkIdType iElem = 0;
 428
 429   TConnect aConnect;
 430   aConnect.reserve(VTK_CELL_SIZE);
 431
 432   SMDS_Mesh::CheckMemory(); // PAL16631
 433   bool hasBalls = nbEnts[ SMDSAbs_Ball ] > 0;
 434   vtkDataArray* aScalars = 0;
 435   if(hasBalls) {
 436     aScalars = vtkDataArray::CreateDataArray(VTK_DOUBLE);
 437     aScalars->SetNumberOfComponents(1);
 438     aScalars->SetNumberOfTuples(aNbCells);
 439   }
 440   for ( int i = 0; i < nbTypes; i++ ) // iterate through all types of elements
 441   {
 442     if ( nbEnts[ aTypes[ i ] ] > 0 ) {
 443
 444       const SMDSAbs_ElementType& aType = aTypes[ i ];
 445       const TEntityList& aList = anEnts[ aType ];
 446       TEntityList::const_iterator anIter;
 447       for ( anIter = aList.begin(); anIter != aList.end(); ++anIter )
 448       {
 449         const SMDS_MeshElement* anElem = *anIter;
 450
 451         vtkIdType aNbNodes = anElem->NbNodes();
 452         anIdList->SetNumberOfIds( aNbNodes );
 453         const vtkIdType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
 454
 455         int anId = anElem->GetID();
 456
 457         mySMDS2VTKElems.insert( TMapOfIds::value_type( anId, iElem ) );
 458         myVTK2SMDSElems.insert( TMapOfIds::value_type( iElem, anId ) );
 459
 460         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 461         {
 462           // Convertions connectivities from SMDS to VTK
 463
 464           if (aType == SMDSAbs_Volume && anElem->IsPoly() && aNbNodes > 3) { // POLYEDRE
 465             anIdList->Reset();
 466             if ( const SMDS_VtkVolume* ph = dynamic_cast<const SMDS_VtkVolume*>(anElem) ) {
 467               int nbFaces = ph->NbFaces();
 468               anIdList->InsertNextId(nbFaces);
 469               for( int i = 1; i <= nbFaces; i++ ) {
 470                 anIdList->InsertNextId(ph->NbFaceNodes(i));
 471                 for(int j = 1; j <= ph->NbFaceNodes(i); j++) {
 472                   const SMDS_MeshNode* n = ph->GetFaceNode(i,j);
 473                   if(n) {
 474                     anIdList->InsertNextId(mySMDS2VTKNodes[n->GetID()]);
 475                   }
 476                 }
 477               }
 478             }
 479           }
 480           else {
 481             const std::vector<int>& aConnectivities =
 482               SMDS_MeshCell::toVtkOrder( VTKCellType( vtkElemType ));
 483             if (aConnectivities.size() > 0) {
 484               aConnect.clear();
 485               GetConnect(aNodesIter,aConnect);
 486               for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
 487                 SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]);
 488             }
 489             else {
 490               for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){
 491                 const SMDS_MeshElement* aNode = aNodesIter->next();
 492                 anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
 493               }
 494             }
 495           }
 496         }
 497         vtkIdType aCurId = aConnectivity->InsertNextCell( anIdList );
 498         aCellTypesArray->InsertNextValue( vtkElemType );
 499
 500         //Store diameters of the balls
 501         if(aScalars) {
 502           double aDiam = 0;
 503           if(aType == SMDSAbs_Ball) {
 504             if (const SMDS_BallElement* ball = dynamic_cast<const SMDS_BallElement*>(anElem) ) {
 505               aDiam = ball->GetDiameter();
 506             }
 507           }
 508           aScalars->SetTuple(aCurId,&aDiam);
 509         }
 510
 511         iElem++;
 512       }
 513     }
 514     SMDS_Mesh::CheckMemory(); // PAL16631
 515   }
 516
 517   // Insert cells in grid
 518
 519   VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 520   aCellLocationsArray->SetNumberOfComponents( 1 );
 521   aCellLocationsArray->SetNumberOfTuples( aNbCells );
 522
 523   SMDS_Mesh::CheckMemory(); // PAL16631
 524
 525   aConnectivity->InitTraversal();
 526   for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
 527     aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
 528
 529   myGrid->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
 530   myGrid->GetCellData()->SetScalars(aScalars);
 531
 532   aCellLocationsArray->Delete();
 533   aCellTypesArray->Delete();
 534   aConnectivity->Delete();
 535   anIdList->Delete();
 536
 537   SMDS_Mesh::CheckMemory(); // PAL16631
 538 }
 539
 540 //=================================================================================
 541 // function : GetEdgeNodes
 542 // purpose  : Retrieve ids of nodes from edge of elements ( edge is numbered from 1 )
 543 //=================================================================================
 544 bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
 545                                        const int theEdgeNum,
 546                                        int&      theNodeId1,
 547                                        int&      theNodeId2 ) const
 548 {
 549   const SMDS_Mesh* aMesh = GetMesh();
 550   if ( aMesh == 0 )
 551     return false;
 552
 553   const SMDS_MeshElement* anElem = aMesh->FindElement( theElemId );
 554   if ( anElem == 0 )
 555     return false;
 556
 557   int nbNodes = anElem->NbCornerNodes();
 558
 559   if ( theEdgeNum < 0 || theEdgeNum > 3 || (nbNodes != 3 && nbNodes != 4) || theEdgeNum > nbNodes )
 560     return false;
 561
 562   vector<int> anIds( nbNodes );
 563   SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
 564   int i = 0;
 565   while( anIter->more() && i < nbNodes )
 566     anIds[ i++ ] = anIter->next()->GetID();
 567
 568   if ( theEdgeNum < nbNodes - 1 )
 569   {
 570     theNodeId1 = anIds[ theEdgeNum ];
 571     theNodeId2 = anIds[ theEdgeNum + 1 ];
 572   }
 573   else
 574   {
 575     theNodeId1 = anIds[ nbNodes - 1 ];
 576     theNodeId2 = anIds[ 0 ];
 577   }
 578
 579   return true;
 580 }
 581
 582 vtkUnstructuredGrid* SMESH_VisualObjDef::GetUnstructuredGrid()
 583 {
 584   if ( !myLocalGrid && !GetMesh()->isCompacted() )
 585   {
 586     GetMesh()->compactMesh();
 587         updateEntitiesFlags();
 588     vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
 589     myGrid->ShallowCopy(theGrid);
 590   }
 591   return myGrid;
 592 }
 593
 594
 595 //=================================================================================
 596 // function : IsValid
 597 // purpose  : Return true if there are some entities
 598 //=================================================================================
 599 bool SMESH_VisualObjDef::IsValid() const
 600 {
 601         //MESSAGE("SMESH_VisualObjDef::IsValid");
 602   return ( GetNbEntities(SMDSAbs_0DElement) > 0 ||
 603            GetNbEntities(SMDSAbs_Ball     ) > 0 ||
 604            GetNbEntities(SMDSAbs_Edge     ) > 0 ||
 605            GetNbEntities(SMDSAbs_Face     ) > 0 ||
 606            GetNbEntities(SMDSAbs_Volume   ) > 0 ||
 607            GetNbEntities(SMDSAbs_Node     ) > 0 );
 608 }
 609
 610 //=================================================================================
 611 // function : updateEntitiesFlags
 612 // purpose  : Update entities flags
 613 //=================================================================================
 614 void SMESH_VisualObjDef::updateEntitiesFlags() {
 615
 616         unsigned int tmp = myEntitiesState;
 617         ClearEntitiesFlags();
 618
 619         map<SMDSAbs_ElementType,int> entities = SMESH::GetEntitiesFromObject(this);
 620
 621
 622         if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||  myEntitiesCache[SMDSAbs_0DElement] >= entities[SMDSAbs_0DElement] )
 623                 myEntitiesState &= ~SMESH_Actor::e0DElements;
 624
 625         if( myEntitiesCache[SMDSAbs_Ball] != 0 ||  myEntitiesCache[SMDSAbs_Ball] >= entities[SMDSAbs_Ball] )
 626                 myEntitiesState &= ~SMESH_Actor::eBallElem;
 627
 628         if( myEntitiesCache[SMDSAbs_Edge] != 0 || myEntitiesCache[SMDSAbs_Edge] >= entities[SMDSAbs_Edge] )
 629                 myEntitiesState &= ~SMESH_Actor::eEdges;
 630
 631         if( myEntitiesCache[SMDSAbs_Face] != 0 || myEntitiesCache[SMDSAbs_Face] >= entities[SMDSAbs_Face] )
 632                 myEntitiesState &= ~SMESH_Actor::eFaces;
 633
 634         if( myEntitiesCache[SMDSAbs_Volume] != 0 || myEntitiesCache[SMDSAbs_Volume] >= entities[SMDSAbs_Volume] )
 635                 myEntitiesState &= ~SMESH_Actor::eVolumes;
 636
 637         if( tmp != myEntitiesState ) {
 638                 myEntitiesFlag = true;
 639         }
 640
 641         myEntitiesCache = entities;
 642 }
 643
 644 //=================================================================================
 645 // function : ClearEntitiesFlags
 646 // purpose  : Clear the entities flags
 647 //=================================================================================
 648 void SMESH_VisualObjDef::ClearEntitiesFlags() {
 649         myEntitiesState = SMESH_Actor::eAllEntity;
 650         myEntitiesFlag = false;
 651 }
 652
 653 //=================================================================================
 654 // function : GetEntitiesFlag
 655 // purpose  : Return the entities flag
 656 //=================================================================================
 657 bool SMESH_VisualObjDef::GetEntitiesFlag() {
 658         return myEntitiesFlag;
 659 }
 660
 661 //=================================================================================
 662 // function : GetEntitiesState
 663 // purpose  : Return the entities state
 664 //=================================================================================
 665 unsigned int SMESH_VisualObjDef::GetEntitiesState() {
 666         return myEntitiesState;
 667 }
 668
 669 /*
 670   Class       : SMESH_MeshObj
 671   Description : Class for visualisation of mesh
 672 */
 673
 674 //=================================================================================
 675 // function : SMESH_MeshObj
 676 // purpose  : Constructor
 677 //=================================================================================
 678 SMESH_MeshObj::SMESH_MeshObj(SMESH::SMESH_Mesh_ptr theMesh):
 679   myClient(SalomeApp_Application::orb(),theMesh)
 680 {
 681         myEmptyGrid = 0;
 682   if ( MYDEBUG )
 683     MESSAGE("SMESH_MeshObj - this = "<<this<<"; theMesh->_is_nil() = "<<theMesh->_is_nil());
 684 }
 685
 686 //=================================================================================
 687 // function : ~SMESH_MeshObj
 688 // purpose  : Destructor
 689 //=================================================================================
 690 SMESH_MeshObj::~SMESH_MeshObj()
 691 {
 692   if ( MYDEBUG )
 693     MESSAGE("SMESH_MeshObj - this = "<<this<<"\n");
 694   if ( myEmptyGrid )
 695     myEmptyGrid->Delete();
 696 }
 697
 698 //=================================================================================
 699 // function : Update
 700 // purpose  : Update mesh and fill grid with new values if necessary
 701 //=================================================================================
 702 bool SMESH_MeshObj::Update( int theIsClear )
 703 {
 704   // Update SMDS_Mesh on client part
 705   MESSAGE("SMESH_MeshObj::Update " << this);
 706   if ( myClient.Update(theIsClear) || GetUnstructuredGrid()->GetNumberOfPoints()==0) {
 707     MESSAGE("buildPrs");
 708     buildPrs();  // Fill unstructured grid
 709     return true;
 710   }
 711   return false;
 712 }
 713
 714 bool SMESH_MeshObj::NulData()
 715 {
 716         MESSAGE ("SMESH_MeshObj::NulData() ==================================================================================");
 717         if (!myEmptyGrid)
 718         {
 719           myEmptyGrid = SMDS_UnstructuredGrid::New();
 720           myEmptyGrid->Initialize();
 721           myEmptyGrid->Allocate();
 722           vtkPoints* points = vtkPoints::New();
 723           points->SetNumberOfPoints(0);
 724           myEmptyGrid->SetPoints( points );
 725           points->Delete();
 726           myEmptyGrid->BuildLinks();
 727         }
 728         myGrid->ShallowCopy(myEmptyGrid);
 729         return true;
 730 }
 731 //=================================================================================
 732 // function : GetElemDimension
 733 // purpose  : Get dimension of element
 734 //=================================================================================
 735 int SMESH_MeshObj::GetElemDimension( const int theObjId )
 736 {
 737   const SMDS_MeshElement* anElem = myClient->FindElement( theObjId );
 738   if ( anElem == 0 )
 739     return 0;
 740
 741   int aType = anElem->GetType();
 742   switch ( aType )
 743   {
 744     case SMDSAbs_0DElement : return 0;
 745     case SMDSAbs_Ball : return 0;
 746     case SMDSAbs_Edge  : return 1;
 747     case SMDSAbs_Face  : return 2;
 748     case SMDSAbs_Volume: return 3;
 749     default            : return 0;
 750   }
 751 }
 752
 753 //=================================================================================
 754 // function : GetEntities
 755 // purpose  : Get entities of specified type. Return number of entities
 756 //=================================================================================
 757 int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 758 {
 759   switch ( theType )
 760   {
 761     case SMDSAbs_Node:
 762     {
 763       return myClient->NbNodes();
 764     }
 765     break;
 766     case SMDSAbs_0DElement:
 767     {
 768       return myClient->Nb0DElements();
 769     }
 770     case SMDSAbs_Ball:
 771     {
 772       return myClient->NbBalls();
 773     }
 774     break;
 775     case SMDSAbs_Edge:
 776     {
 777       return myClient->NbEdges();
 778     }
 779     break;
 780     case SMDSAbs_Face:
 781     {
 782       return myClient->NbFaces();
 783     }
 784     break;
 785     case SMDSAbs_Volume:
 786     {
 787       return myClient->NbVolumes();
 788     }
 789     break;
 790     default:
 791       return 0;
 792     break;
 793   }
 794 }
 795
 796 int SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
 797 {
 798   theObjs.clear();
 799
 800   switch ( theType )
 801   {
 802     case SMDSAbs_Node:
 803     {
 804       SMDS_NodeIteratorPtr anIter = myClient->nodesIterator();
 805       while ( anIter->more() ) theObjs.push_back( anIter->next() );
 806     }
 807     break;
 808     case SMDSAbs_0DElement:
 809     {
 810       SMDS_ElemIteratorPtr anIter = myClient->elementsIterator(SMDSAbs_0DElement);
 811       while ( anIter->more() ) theObjs.push_back( anIter->next() );
 812     }
 813     break;
 814     case SMDSAbs_Ball:
 815     {
 816       SMDS_ElemIteratorPtr anIter = myClient->elementGeomIterator(SMDSGeom_BALL);
 817       while ( anIter->more() ) theObjs.push_back( anIter->next() );
 818     }
 819     break;
 820     case SMDSAbs_Edge:
 821     {
 822       SMDS_EdgeIteratorPtr anIter = myClient->edgesIterator();
 823       while ( anIter->more() ) theObjs.push_back( anIter->next() );
 824     }
 825     break;
 826     case SMDSAbs_Face:
 827     {
 828       SMDS_FaceIteratorPtr anIter = myClient->facesIterator();
 829       while ( anIter->more() ) theObjs.push_back( anIter->next() );
 830     }
 831     break;
 832     case SMDSAbs_Volume:
 833     {
 834       SMDS_VolumeIteratorPtr anIter = myClient->volumesIterator();
 835       while ( anIter->more() ) theObjs.push_back( anIter->next() );
 836     }
 837     break;
 838     default:
 839     break;
 840   }
 841
 842   return theObjs.size();
 843 }
 844
 845 //=================================================================================
 846 // function : UpdateFunctor
 847 // purpose  : Update functor in accordance with current mesh
 848 //=================================================================================
 849 void SMESH_MeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor )
 850 {
 851   theFunctor->SetMesh( GetMesh() );
 852 }
 853
 854 //=================================================================================
 855 // function : IsNodePrs
 856 // purpose  : Return true if node presentation is used
 857 //=================================================================================
 858 bool SMESH_MeshObj::IsNodePrs() const
 859 {
 860   return myClient->Nb0DElements() + myClient->NbEdges() + myClient->NbFaces() + myClient->NbVolumes() + myClient->NbBalls() == 0 ;
 861 }
 862
 863
 864 /*
 865   Class       : SMESH_SubMeshObj
 866   Description : Base class for visualisation of submeshes and groups
 867 */
 868
 869 //=================================================================================
 870 // function : SMESH_SubMeshObj
 871 // purpose  : Constructor
 872 //=================================================================================
 873 SMESH_SubMeshObj::SMESH_SubMeshObj( SMESH_MeshObj* theMeshObj )
 874 {
 875   if ( MYDEBUG ) MESSAGE( "SMESH_SubMeshObj - theMeshObj = " << theMeshObj );
 876
 877   myMeshObj = theMeshObj;
 878 }
 879
 880 SMESH_SubMeshObj::~SMESH_SubMeshObj()
 881 {
 882 }
 883
 884 //=================================================================================
 885 // function : GetElemDimension
 886 // purpose  : Get dimension of element
 887 //=================================================================================
 888 int SMESH_SubMeshObj::GetElemDimension( const int theObjId )
 889 {
 890   return myMeshObj == 0 ? 0 : myMeshObj->GetElemDimension( theObjId );
 891 }
 892
 893 //=================================================================================
 894 // function : UpdateFunctor
 895 // purpose  : Update functor in accordance with current mesh
 896 //=================================================================================
 897
 898 void SMESH_SubMeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor )
 899 {
 900   theFunctor->SetMesh( myMeshObj->GetMesh() );
 901 }
 902
 903 //=================================================================================
 904 // function : Update
 905 // purpose  : Update mesh object and fill grid with new values
 906 //=================================================================================
 907 bool SMESH_SubMeshObj::Update( int theIsClear )
 908 {
 909   MESSAGE("SMESH_SubMeshObj::Update " << this)
 910   bool changed = myMeshObj->Update( theIsClear );
 911   buildPrs(true);
 912   return changed;
 913 }
 914
 915
 916 /*
 917   Class       : SMESH_GroupObj
 918   Description : Class for visualisation of groups
 919 */
 920
 921 //=================================================================================
 922 // function : SMESH_GroupObj
 923 // purpose  : Constructor
 924 //=================================================================================
 925 SMESH_GroupObj::SMESH_GroupObj( SMESH::SMESH_GroupBase_ptr theGroup,
 926                                 SMESH_MeshObj*             theMeshObj )
 927 : SMESH_SubMeshObj( theMeshObj ),
 928   myGroupServer( SMESH::SMESH_GroupBase::_duplicate(theGroup) )
 929 {
 930   if ( MYDEBUG ) MESSAGE("SMESH_GroupObj - theGroup->_is_nil() = "<<theGroup->_is_nil());
 931   myGroupServer->Register();
 932 }
 933
 934 SMESH_GroupObj::~SMESH_GroupObj()
 935 {
 936   if ( MYDEBUG ) MESSAGE("~SMESH_GroupObj");
 937   myGroupServer->UnRegister();
 938 }
 939
 940 //=================================================================================
 941 // function : IsNodePrs
 942 // purpose  : Return true if node presentation is used
 943 //=================================================================================
 944 bool SMESH_GroupObj::IsNodePrs() const
 945 {
 946   return myGroupServer->GetType() == SMESH::NODE;
 947 }
 948
 949 //=================================================================================
 950 // function : GetElementType
 951 // purpose  : Return type of elements of group
 952 //=================================================================================
 953 SMDSAbs_ElementType SMESH_GroupObj::GetElementType() const
 954 {
 955   return SMDSAbs_ElementType(myGroupServer->GetType());
 956 }
 957
 958 //=================================================================================
 959 // function : getNodesFromElems
 960 // purpose  : Retrieve nodes from elements
 961 //=================================================================================
 962 static int getNodesFromElems( SMESH::long_array_var&              theElemIds,
 963                               const SMDS_Mesh*                    theMesh,
 964                               std::list<const SMDS_MeshElement*>& theResList )
 965 {
 966   set<const SMDS_MeshElement*> aNodeSet;
 967
 968   for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
 969   {
 970     const SMDS_MeshElement* anElem = theMesh->FindElement( theElemIds[ i ] );
 971     if ( anElem != 0 )
 972     {
 973       SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
 974       while ( anIter->more() )
 975       {
 976         const SMDS_MeshElement* aNode = anIter->next();
 977         if ( aNode != 0 )
 978           aNodeSet.insert( aNode );
 979       }
 980     }
 981   }
 982
 983   set<const SMDS_MeshElement*>::const_iterator anIter;
 984   for ( anIter = aNodeSet.begin(); anIter != aNodeSet.end(); ++anIter )
 985     theResList.push_back( *anIter );
 986
 987   return theResList.size();
 988 }
 989
 990 //=================================================================================
 991 // function : getPointers
 992 // purpose  : Get std::list<const SMDS_MeshElement*> from list of IDs
 993 //=================================================================================
 994 static int getPointers( const SMDSAbs_ElementType            theRequestType,
 995                         SMESH::long_array_var&              theElemIds,
 996                         const SMDS_Mesh*                    theMesh,
 997                         std::list<const SMDS_MeshElement*>& theResList )
 998 {
 999   for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
1000   {
1001     const SMDS_MeshElement* anElem = theRequestType == SMDSAbs_Node
1002       ? theMesh->FindNode( theElemIds[ i ] ) : theMesh->FindElement( theElemIds[ i ] );
1003
1004     if ( anElem != 0 )
1005       theResList.push_back( anElem );
1006   }
1007
1008   return theResList.size();
1009 }
1010
1011
1012 //=================================================================================
1013 // function : GetEntities
1014 // purpose  : Get entities of specified type. Return number of entities
1015 //=================================================================================
1016 int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
1017 {
1018   if(SMDSAbs_ElementType(myGroupServer->GetType()) == theType) {
1019     return myGroupServer->Size();
1020   }
1021   if ( theType == SMDSAbs_Node ) {
1022     return myGroupServer->GetNumberOfNodes();
1023   }
1024   return 0;
1025 }
1026
1027 int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
1028 {
1029   theResList.clear();
1030   SMDS_Mesh* aMesh = myMeshObj->GetMesh();
1031
1032   if ( aMesh == 0 )
1033     return 0;
1034
1035   SMDSAbs_ElementType aGrpType = SMDSAbs_ElementType(myGroupServer->GetType());
1036   if ( aGrpType != theType && theType != SMDSAbs_Node )
1037     return 0;
1038
1039   SMESH::long_array_var anIds = myGroupServer->GetListOfID();
1040   if ( anIds->length() == 0 )
1041     return 0;
1042
1043   if ( aGrpType == theType )
1044     return getPointers( theType, anIds, aMesh, theResList );
1045   else if ( theType == SMDSAbs_Node )
1046     return getNodesFromElems( anIds, aMesh, theResList );
1047   else
1048     return 0;
1049 }
1050
1051
1052
1053 /*
1054   Class       : SMESH_subMeshObj
1055   Description : Class for visualisation of submeshes
1056 */
1057
1058 //=================================================================================
1059 // function : SMESH_subMeshObj
1060 // purpose  : Constructor
1061 //=================================================================================
1062 SMESH_subMeshObj::SMESH_subMeshObj( SMESH::SMESH_subMesh_ptr theSubMesh,
1063                                     SMESH_MeshObj*           theMeshObj )
1064 : SMESH_SubMeshObj( theMeshObj ),
1065   mySubMeshServer( SMESH::SMESH_subMesh::_duplicate( theSubMesh ) )
1066 {
1067   if ( MYDEBUG ) MESSAGE( "SMESH_subMeshObj - theSubMesh->_is_nil() = " << theSubMesh->_is_nil() );
1068
1069   mySubMeshServer->Register();
1070 }
1071
1072 SMESH_subMeshObj::~SMESH_subMeshObj()
1073 {
1074   if ( MYDEBUG ) MESSAGE( "~SMESH_subMeshObj" );
1075   mySubMeshServer->UnRegister();
1076 }
1077
1078 //=================================================================================
1079 // function : GetEntities
1080 // purpose  : Get entities of specified type. Return number of entities
1081 //=================================================================================
1082 int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
1083 {
1084   switch ( theType )
1085   {
1086     case SMDSAbs_Node:
1087     {
1088       return mySubMeshServer->GetNumberOfNodes( /*all=*/true );
1089     }
1090     break;
1091     case SMDSAbs_Ball:
1092     case SMDSAbs_0DElement:
1093     case SMDSAbs_Edge:
1094     case SMDSAbs_Face:
1095     case SMDSAbs_Volume:
1096     {
1097       SMESH::long_array_var anIds =
1098         mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
1099       return anIds->length();
1100     }
1101     default:
1102       return 0;
1103     break;
1104   }
1105 }
1106
1107 int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
1108 {
1109   theResList.clear();
1110
1111   SMDS_Mesh* aMesh = myMeshObj->GetMesh();
1112   if ( aMesh == 0 )
1113     return 0;
1114
1115   bool isNodal = IsNodePrs();
1116
1117   if ( isNodal )
1118   {
1119     if ( theType == SMDSAbs_Node )
1120     {
1121       SMESH::long_array_var anIds = mySubMeshServer->GetNodesId();
1122       return getPointers( SMDSAbs_Node, anIds, aMesh, theResList );
1123     }
1124   }
1125   else
1126   {
1127     if ( theType == SMDSAbs_Node )
1128     {
1129       SMESH::long_array_var anIds = mySubMeshServer->GetElementsId();
1130       return getNodesFromElems( anIds, aMesh, theResList );
1131     }
1132     else
1133     {
1134       SMESH::long_array_var anIds =
1135         mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
1136       return getPointers( theType, anIds, aMesh, theResList );
1137     }
1138   }
1139
1140   return 0;
1141 }
1142
1143 //=================================================================================
1144 // function : IsNodePrs
1145 // purpose  : Return true if node presentation is used
1146 //=================================================================================
1147 bool SMESH_subMeshObj::IsNodePrs() const
1148 {
1149   return mySubMeshServer->GetNumberOfElements() == 0;
1150 }