src/OBJECT/SMESH_Object.cxx

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