src/OBJECT/SMESH_Object.cxx

   1 // Copyright (C) 2007-2016  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 "SMESHDS_Mesh.hxx"
  36 #include "SMESHDS_Script.hxx"
  37 #include "SMESH_Actor.h"
  38 #include "SMESH_ControlsDef.hxx"
  39
  40 #include <SalomeApp_Application.h>
  41 #include <VTKViewer_ExtractUnstructuredGrid.h>
  42 #include <VTKViewer_CellLocationsArray.h>
  43
  44 #include CORBA_SERVER_HEADER(SMESH_Gen)
  45 #include CORBA_SERVER_HEADER(SALOME_Exception)
  46
  47 #include <vtkCell.h>
  48 #include <vtkIdList.h>
  49 #include <vtkCellArray.h>
  50 #include <vtkUnsignedCharArray.h>
  51 #include <vtkCellData.h>
  52 #include <vtkUnstructuredGrid.h>
  53
  54 #include <memory>
  55 #include <sstream>
  56 #include <stdexcept>
  57 #include <set>
  58
  59 #include <utilities.h>
  60
  61 using namespace std;
  62
  63 #ifndef EXCEPTION
  64 #define EXCEPTION(TYPE, MSG) {\
  65   std::ostringstream aStream;\
  66   aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
  67   throw TYPE(aStream.str());\
  68 }
  69 #endif
  70
  71 #ifdef _DEBUG_
  72 static int MYDEBUG = 0;
  73 static int MYDEBUGWITHFILES = 0;//1;
  74 #else
  75 static int MYDEBUG = 0;
  76 static int MYDEBUGWITHFILES = 0;
  77 #endif
  78
  79
  80 /*
  81   Class       : SMESH_VisualObjDef
  82   Description : Base class for all mesh objects to be visuilised
  83 */
  84
  85 //=================================================================================
  86 // function : getCellType
  87 // purpose  : Get type of VTK cell
  88 //=================================================================================
  89 // static inline vtkIdType getCellType( const SMDSAbs_ElementType theType,
  90 //                                      const bool                thePoly,
  91 //                                      const int                 theNbNodes )
  92 // {
  93 //   switch( theType )
  94 //   {
  95 //     case SMDSAbs_0DElement:         return VTK_VERTEX;
  96
  97 //     case SMDSAbs_Ball:              return VTK_POLY_VERTEX;
  98
  99 //     case SMDSAbs_Edge:
 100 //       if( theNbNodes == 2 )         return VTK_LINE;
 101 //       else if ( theNbNodes == 3 )   return VTK_QUADRATIC_EDGE;
 102 //       else return VTK_EMPTY_CELL;
 103
 104 //     case SMDSAbs_Face  :
 105 //       if (thePoly && theNbNodes>2 ) return VTK_POLYGON;
 106 //       else if ( theNbNodes == 3 )   return VTK_TRIANGLE;
 107 //       else if ( theNbNodes == 4 )   return VTK_QUAD;
 108 //       else if ( theNbNodes == 6 )   return VTK_QUADRATIC_TRIANGLE;
 109 //       else if ( theNbNodes == 8 )   return VTK_QUADRATIC_QUAD;
 110 //       else if ( theNbNodes == 9 )   return VTK_BIQUADRATIC_QUAD;
 111 //       else if ( theNbNodes == 7 )   return VTK_BIQUADRATIC_TRIANGLE;
 112 //       else return VTK_EMPTY_CELL;
 113
 114 //     case SMDSAbs_Volume:
 115 //       if (thePoly && theNbNodes>3 ) return VTK_POLYHEDRON; //VTK_CONVEX_POINT_SET;
 116 //       else if ( theNbNodes == 4 )   return VTK_TETRA;
 117 //       else if ( theNbNodes == 5 )   return VTK_PYRAMID;
 118 //       else if ( theNbNodes == 6 )   return VTK_WEDGE;
 119 //       else if ( theNbNodes == 8 )   return VTK_HEXAHEDRON;
 120 //       else if ( theNbNodes == 12 )  return VTK_HEXAGONAL_PRISM;
 121 //       else if ( theNbNodes == 10 )  return VTK_QUADRATIC_TETRA;
 122 //       else if ( theNbNodes == 20 )  return VTK_QUADRATIC_HEXAHEDRON;
 123 //       else if ( theNbNodes == 27 )  return VTK_TRIQUADRATIC_HEXAHEDRON;
 124 //       else if ( theNbNodes == 15 )  return VTK_QUADRATIC_WEDGE;
 125 //       else if ( theNbNodes == 13 )  return VTK_QUADRATIC_PYRAMID; //VTK_CONVEX_POINT_SET;
 126 //       else return VTK_EMPTY_CELL;
 127
 128 //     default: return VTK_EMPTY_CELL;
 129 //   }
 130 // }
 131
 132 //=================================================================================
 133 // functions : SMESH_VisualObjDef
 134 // purpose   : Constructor
 135 //=================================================================================
 136 SMESH_VisualObjDef::SMESH_VisualObjDef()
 137 {
 138   if ( MYDEBUG ) MESSAGE("-------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
 139   myGrid = vtkUnstructuredGrid::New();
 140   myLocalGrid = false;
 141   ClearEntitiesFlags();
 142   SMESH::GetEntitiesFromObject(NULL);
 143 }
 144 SMESH_VisualObjDef::~SMESH_VisualObjDef()
 145 {
 146   if ( MYDEBUG ) MESSAGE("--------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
 147   if ( MYDEBUG ) MESSAGE( "myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
 148   myGrid->Delete();
 149 }
 150
 151 //=================================================================================
 152 // functions : GetNodeObjId, GetNodeVTKId, GetElemObjId, GetElemVTKId
 153 // purpose   : Methods for retrieving VTK IDs by SMDS IDs and  vice versa
 154 //=================================================================================
 155 vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
 156 {
 157   if (myLocalGrid)
 158   {
 159     TMapOfIds::const_iterator i = myVTK2SMDSNodes.find(theVTKID);
 160     return i == myVTK2SMDSNodes.end() ? -1 : i->second;
 161   }
 162   const SMDS_MeshNode* aNode = 0;
 163   if( this->GetMesh() )
 164     aNode = this->GetMesh()->FindNodeVtk( theVTKID );
 165
 166   return aNode ? aNode->GetID() : -1;
 167 }
 168
 169 vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
 170 {
 171   if (myLocalGrid)
 172   {
 173     TMapOfIds::const_iterator i = mySMDS2VTKNodes.find(theObjID);
 174     return i == mySMDS2VTKNodes.end() ? -1 : i->second;
 175   }
 176
 177   const SMDS_MeshNode* aNode = 0;
 178   if( this->GetMesh() ) {
 179     aNode = this->GetMesh()->FindNode(theObjID);
 180   }
 181   return aNode ? aNode->getVtkId() : -1;
 182 }
 183
 184 vtkIdType SMESH_VisualObjDef::GetElemObjId( int theVTKID )
 185 {
 186   if (myLocalGrid)
 187   {
 188     TMapOfIds::const_iterator i = myVTK2SMDSElems.find(theVTKID);
 189     return i == myVTK2SMDSElems.end() ? -1 : i->second;
 190   }
 191   return this->GetMesh()->fromVtkToSmds(theVTKID);
 192 }
 193
 194 vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
 195 {
 196   if (myLocalGrid)
 197   {
 198     TMapOfIds::const_iterator i = mySMDS2VTKElems.find(theObjID);
 199     return i == mySMDS2VTKElems.end() ? -1 : i->second;
 200   }
 201
 202   const SMDS_MeshElement* e = 0;
 203   if ( this->GetMesh() )
 204     e = this->GetMesh()->FindElement(theObjID);
 205
 206   return e ? e->getVtkId() : -1;
 207 }
 208
 209 //=================================================================================
 210 // function : SMESH_VisualObjDef::createPoints
 211 // purpose  : Create points from nodes
 212 //=================================================================================
 213 /*! fills a vtkPoints structure for a submesh.
 214  *  fills a std::list of SMDS_MeshElements*, then extract the points.
 215  *  fills also conversion id maps between SMDS and VTK.
 216  */
 217 void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
 218 {
 219   if ( thePoints == 0 )
 220     return;
 221
 222   TEntityList aNodes;
 223   vtkIdType nbNodes = GetEntities( SMDSAbs_Node, aNodes );
 224   thePoints->SetNumberOfPoints( nbNodes );
 225
 226   int nbPoints = 0;
 227
 228   TEntityList::const_iterator anIter;
 229   for ( anIter = aNodes.begin(); anIter != aNodes.end(); ++anIter )
 230   {
 231     const SMDS_MeshNode* aNode = ( const SMDS_MeshNode* )(*anIter);
 232     if ( aNode != 0 )
 233     {
 234       thePoints->SetPoint( nbPoints, aNode->X(), aNode->Y(), aNode->Z() );
 235       int anId = aNode->GetID();
 236       mySMDS2VTKNodes.insert( mySMDS2VTKNodes.end(), std::make_pair( anId, nbPoints ));
 237       myVTK2SMDSNodes.insert( myVTK2SMDSNodes.end(), std::make_pair( nbPoints, anId ));
 238       nbPoints++;
 239     }
 240   }
 241
 242   if ( nbPoints != nbNodes )
 243     thePoints->SetNumberOfPoints( nbPoints );
 244 }
 245
 246 //=================================================================================
 247 // function : buildPrs
 248 // purpose  : create VTK cells( fill unstructured grid )
 249 //=================================================================================
 250 void SMESH_VisualObjDef::buildPrs(bool buildGrid)
 251 {
 252   if ( MYDEBUG ) MESSAGE("---------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
 253   if (buildGrid)
 254   {
 255     myLocalGrid = true;
 256     try
 257     {
 258       mySMDS2VTKNodes.clear();
 259       myVTK2SMDSNodes.clear();
 260       mySMDS2VTKElems.clear();
 261       myVTK2SMDSElems.clear();
 262
 263       if ( IsNodePrs() )
 264         buildNodePrs();
 265       else
 266         buildElemPrs();
 267     }
 268     catch(...)
 269     {
 270       mySMDS2VTKNodes.clear();
 271       myVTK2SMDSNodes.clear();
 272       mySMDS2VTKElems.clear();
 273       myVTK2SMDSElems.clear();
 274
 275       myGrid->SetPoints( 0 );
 276       myGrid->SetCells( 0, 0, 0, 0, 0 );
 277       throw;
 278     }
 279   }
 280   else
 281   {
 282     myLocalGrid = false;
 283     if (!GetMesh()->isCompacted())
 284     {
 285       NulData(); // detach from the SMDS grid to allow immediate memory de-allocation in compactMesh()
 286       if ( MYDEBUG ) MESSAGE("*** buildPrs ==> compactMesh!");
 287       GetMesh()->compactMesh();
 288       if ( SMESHDS_Mesh* m = dynamic_cast<SMESHDS_Mesh*>( GetMesh() )) // IPAL53915
 289         m->GetScript()->SetModified(false); // drop IsModified set in compactMesh()
 290     }
 291     vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
 292     updateEntitiesFlags();
 293     myGrid->ShallowCopy(theGrid);
 294     //MESSAGE(myGrid->GetReferenceCount());
 295     //MESSAGE( "Update - myGrid->GetNumberOfCells() = "<<myGrid->GetNumberOfCells() );
 296     //MESSAGE( "Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints() );
 297     if( MYDEBUGWITHFILES ) {
 298       SMESH::WriteUnstructuredGrid( myGrid,"myPrs.vtu" );
 299     }
 300   }
 301 }
 302
 303 //=================================================================================
 304 // function : buildNodePrs
 305 // purpose  : create VTK cells for nodes
 306 //=================================================================================
 307
 308 void SMESH_VisualObjDef::buildNodePrs()
 309 {
 310   // PAL16631: without swap, bad_alloc is not thrown but hung up and crash instead,
 311   // so check remaining memory size for safety
 312   SMDS_Mesh::CheckMemory(); // PAL16631
 313   vtkPoints* aPoints = vtkPoints::New();
 314   createPoints( aPoints );
 315   SMDS_Mesh::CheckMemory();
 316   myGrid->SetPoints( aPoints );
 317   aPoints->Delete();
 318
 319   myGrid->SetCells( 0, 0, 0, 0, 0 );
 320 }
 321
 322 //=================================================================================
 323 // function : buildElemPrs
 324 // purpose  : Create VTK cells for elements
 325 //=================================================================================
 326
 327 namespace{
 328   typedef std::vector<const SMDS_MeshElement*> TConnect;
 329
 330   int GetConnect(const SMDS_ElemIteratorPtr& theNodesIter,
 331                  TConnect& theConnect)
 332   {
 333     theConnect.clear();
 334     for(; theNodesIter->more();)
 335       theConnect.push_back(theNodesIter->next());
 336     return theConnect.size();
 337   }
 338
 339   inline
 340   void SetId(vtkIdList *theIdList,
 341              const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes,
 342              const TConnect& theConnect,
 343              int thePosition,
 344              int theId)
 345   {
 346     theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second);
 347   }
 348
 349 }
 350
 351
 352 void SMESH_VisualObjDef::buildElemPrs()
 353 {
 354   // Create points
 355
 356   vtkPoints* aPoints = vtkPoints::New();
 357   createPoints( aPoints );
 358   myGrid->SetPoints( aPoints );
 359   aPoints->Delete();
 360
 361   if ( MYDEBUG )
 362     MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
 363
 364   // Calculate cells size
 365
 366   const int nbTypes = 5;
 367   static SMDSAbs_ElementType aTypes[ nbTypes ] =
 368     { SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDSAbs_Ball, SMDSAbs_0DElement };
 369
 370   // get entity data
 371   map<SMDSAbs_ElementType,int> nbEnts;
 372   map<SMDSAbs_ElementType,TEntityList> anEnts;
 373
 374   vtkIdType aNbCells = 0;
 375
 376   for ( int i = 0; i < nbTypes; i++ )
 377   {
 378     nbEnts[ aTypes[ i ] ] = GetEntities( aTypes[ i ], anEnts[ aTypes[ i ] ] );
 379     aNbCells += nbEnts[ aTypes [ i ]];
 380   }
 381   // PAL16631: without swap, bad_alloc is not thrown but hung up and crash instead,
 382   // so check remaining memory size for safety
 383   SMDS_Mesh::CheckMemory(); // PAL16631
 384
 385   vtkIdType aCellsSize =  2 * nbEnts[ SMDSAbs_0DElement ] + 3 * nbEnts[ SMDSAbs_Edge ];
 386   aCellsSize += 2 * nbEnts[ SMDSAbs_Ball ];
 387
 388   for ( int i = 1; i <= 2; i++ ) // iterate through faces and volumes
 389   {
 390     if ( nbEnts[ aTypes[ i ] ] )
 391     {
 392       const TEntityList& aList = anEnts[ aTypes[ i ] ];
 393       TEntityList::const_iterator anIter;
 394       for ( anIter = aList.begin(); anIter != aList.end(); ++anIter ) {
 395         if((*anIter)->GetEntityType() != SMDSEntity_Polyhedra &&
 396            (*anIter)->GetEntityType() != SMDSEntity_Quad_Polyhedra) {
 397           aCellsSize += (*anIter)->NbNodes() + 1;
 398         }
 399         // Special case for the VTK_POLYHEDRON:
 400         // itsinput cellArray is of special format.
 401         //  [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]
 402         else {
 403           if( const SMDS_VtkVolume* ph = dynamic_cast<const SMDS_VtkVolume*>(*anIter) ) {
 404             int nbFaces = ph->NbFaces();
 405             aCellsSize += (1 + ph->NbFaces());
 406             for( int i = 1; i <= nbFaces; i++ ) {
 407               aCellsSize += ph->NbFaceNodes(i);
 408             }
 409           }
 410         }
 411       }
 412     }
 413   }
 414   if ( MYDEBUG )
 415     MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
 416
 417   // Create cells
 418
 419   vtkCellArray* aConnectivity = vtkCellArray::New();
 420   aConnectivity->Allocate( aCellsSize, 0 );
 421
 422   SMDS_Mesh::CheckMemory(); // PAL16631
 423
 424   vtkUnsignedCharArray* aCellTypesArray = vtkUnsignedCharArray::New();
 425   aCellTypesArray->SetNumberOfComponents( 1 );
 426   aCellTypesArray->Allocate( aNbCells * aCellTypesArray->GetNumberOfComponents() );
 427
 428   SMDS_Mesh::CheckMemory(); // PAL16631
 429
 430   vtkIdList *anIdList = vtkIdList::New();
 431   vtkIdType iElem = 0;
 432
 433   TConnect aConnect;
 434   aConnect.reserve(VTK_CELL_SIZE);
 435
 436   SMDS_Mesh::CheckMemory(); // PAL16631
 437   bool hasBalls = nbEnts[ SMDSAbs_Ball ] > 0;
 438   vtkDataArray* aScalars = 0;
 439   if(hasBalls) {
 440     aScalars = vtkDataArray::CreateDataArray(VTK_DOUBLE);
 441     aScalars->SetNumberOfComponents(1);
 442     aScalars->SetNumberOfTuples(aNbCells);
 443   }
 444   for ( int i = 0; i < nbTypes; i++ ) // iterate through all types of elements
 445   {
 446     if ( nbEnts[ aTypes[ i ] ] > 0 ) {
 447
 448       const SMDSAbs_ElementType& aType = aTypes[ i ];
 449       const TEntityList& aList = anEnts[ aType ];
 450       TEntityList::const_iterator anIter;
 451       for ( anIter = aList.begin(); anIter != aList.end(); ++anIter )
 452       {
 453         const SMDS_MeshElement* anElem = *anIter;
 454
 455         vtkIdType aNbNodes = anElem->NbNodes();
 456         anIdList->SetNumberOfIds( aNbNodes );
 457         const vtkIdType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
 458
 459         int anId = anElem->GetID();
 460
 461         mySMDS2VTKElems.insert( mySMDS2VTKElems.end(), std::make_pair( anId, iElem ));
 462         myVTK2SMDSElems.insert( myVTK2SMDSElems.end(), std::make_pair( iElem, anId ));
 463
 464         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
 465         {
 466           // Convertions connectivities from SMDS to VTK
 467
 468           if (aType == SMDSAbs_Volume && anElem->IsPoly() && aNbNodes > 3) { // POLYEDRE
 469             anIdList->Reset();
 470             if ( const SMDS_VtkVolume* ph = dynamic_cast<const SMDS_VtkVolume*>(anElem) ) {
 471               int nbFaces = ph->NbFaces();
 472               anIdList->InsertNextId(nbFaces);
 473               for( int i = 1; i <= nbFaces; i++ ) {
 474                 anIdList->InsertNextId(ph->NbFaceNodes(i));
 475                 for(int j = 1; j <= ph->NbFaceNodes(i); j++) {
 476                   const SMDS_MeshNode* n = ph->GetFaceNode(i,j);
 477                   if(n) {
 478                     anIdList->InsertNextId(mySMDS2VTKNodes[n->GetID()]);
 479                   }
 480                 }
 481               }
 482             }
 483           }
 484           else {
 485             const std::vector<int>& aConnectivities =
 486               SMDS_MeshCell::toVtkOrder( VTKCellType( vtkElemType ));
 487             if (aConnectivities.size() > 0) {
 488               aConnect.clear();
 489               GetConnect(aNodesIter,aConnect);
 490               for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
 491                 SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]);
 492             }
 493             else {
 494               for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){
 495                 const SMDS_MeshElement* aNode = aNodesIter->next();
 496                 anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
 497               }
 498             }
 499           }
 500         }
 501         vtkIdType aCurId = aConnectivity->InsertNextCell( anIdList );
 502         aCellTypesArray->InsertNextValue( vtkElemType );
 503
 504         //Store diameters of the balls
 505         if(aScalars) {
 506           double aDiam = 0;
 507           if(aType == SMDSAbs_Ball) {
 508             if (const SMDS_BallElement* ball = dynamic_cast<const SMDS_BallElement*>(anElem) ) {
 509               aDiam = ball->GetDiameter();
 510             }
 511           }
 512           aScalars->SetTuple(aCurId,&aDiam);
 513         }
 514
 515         iElem++;
 516       }
 517     }
 518     SMDS_Mesh::CheckMemory(); // PAL16631
 519   }
 520
 521   // Insert cells in grid
 522
 523   VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
 524   aCellLocationsArray->SetNumberOfComponents( 1 );
 525   aCellLocationsArray->SetNumberOfTuples( aNbCells );
 526
 527   SMDS_Mesh::CheckMemory(); // PAL16631
 528
 529   aConnectivity->InitTraversal();
 530   for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
 531     aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
 532
 533   myGrid->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
 534   myGrid->GetCellData()->SetScalars(aScalars);
 535
 536   aCellLocationsArray->Delete();
 537   aCellTypesArray->Delete();
 538   aConnectivity->Delete();
 539   anIdList->Delete();
 540
 541   SMDS_Mesh::CheckMemory(); // PAL16631
 542 }
 543
 544 //=================================================================================
 545 // function : GetEdgeNodes
 546 // purpose  : Retrieve ids of nodes from edge of elements ( edge is numbered from 0 )
 547 //=================================================================================
 548 bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
 549                                        const int theEdgeNum,
 550                                        int&      theNodeId1,
 551                                        int&      theNodeId2 ) const
 552 {
 553   const SMDS_Mesh* aMesh = GetMesh();
 554   if ( aMesh == 0 )
 555     return false;
 556
 557   const SMDS_MeshElement* anElem = aMesh->FindElement( theElemId );
 558   if ( anElem == 0 )
 559     return false;
 560
 561   int nbNodes = anElem->NbCornerNodes();
 562
 563   if (( theEdgeNum < 0 || theEdgeNum > 3 ) ||
 564       ( nbNodes != 3 && nbNodes != 4 ) ||
 565       ( theEdgeNum >= nbNodes ))
 566     return false;
 567
 568   theNodeId1 = anElem->GetNode(  theEdgeNum                 )->GetID();
 569   theNodeId2 = anElem->GetNode(( theEdgeNum + 1 ) % nbNodes )->GetID();
 570
 571   return true;
 572 }
 573
 574 vtkUnstructuredGrid* SMESH_VisualObjDef::GetUnstructuredGrid()
 575 {
 576   if ( !myLocalGrid && !GetMesh()->isCompacted() )
 577   {
 578     NulData(); // detach from the SMDS grid to allow immediate memory de-allocation in compactMesh()
 579     GetMesh()->compactMesh();
 580     updateEntitiesFlags();
 581     vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
 582     myGrid->ShallowCopy(theGrid);
 583   }
 584   return myGrid;
 585 }
 586
 587
 588 //=================================================================================
 589 // function : IsValid
 590 // purpose  : Return true if there are some entities
 591 //=================================================================================
 592 bool SMESH_VisualObjDef::IsValid() const
 593 {
 594   return ( GetNbEntities(SMDSAbs_0DElement) > 0 ||
 595            GetNbEntities(SMDSAbs_Ball     ) > 0 ||
 596            GetNbEntities(SMDSAbs_Edge     ) > 0 ||
 597            GetNbEntities(SMDSAbs_Face     ) > 0 ||
 598            GetNbEntities(SMDSAbs_Volume   ) > 0 ||
 599            GetNbEntities(SMDSAbs_Node     ) > 0 );
 600 }
 601
 602 //=================================================================================
 603 // function : updateEntitiesFlags
 604 // purpose  : Update entities flags
 605 //=================================================================================
 606 void SMESH_VisualObjDef::updateEntitiesFlags()
 607 {
 608   unsigned int tmp = myEntitiesState;
 609   ClearEntitiesFlags();
 610
 611   map<SMDSAbs_ElementType,int> entities = SMESH::GetEntitiesFromObject(this);
 612
 613
 614   if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||
 615       myEntitiesCache[SMDSAbs_0DElement] >= entities[SMDSAbs_0DElement] )
 616     myEntitiesState &= ~SMESH_Actor::e0DElements;
 617
 618   if( myEntitiesCache[SMDSAbs_Ball] != 0 ||
 619       myEntitiesCache[SMDSAbs_Ball] >= entities[SMDSAbs_Ball] )
 620     myEntitiesState &= ~SMESH_Actor::eBallElem;
 621
 622   if( myEntitiesCache[SMDSAbs_Edge] != 0 ||
 623       myEntitiesCache[SMDSAbs_Edge] >= entities[SMDSAbs_Edge] )
 624     myEntitiesState &= ~SMESH_Actor::eEdges;
 625
 626   if( myEntitiesCache[SMDSAbs_Face] != 0 ||
 627       myEntitiesCache[SMDSAbs_Face] >= entities[SMDSAbs_Face] )
 628     myEntitiesState &= ~SMESH_Actor::eFaces;
 629
 630   if( myEntitiesCache[SMDSAbs_Volume] != 0 ||
 631       myEntitiesCache[SMDSAbs_Volume] >= entities[SMDSAbs_Volume] )
 632     myEntitiesState &= ~SMESH_Actor::eVolumes;
 633
 634   if( tmp != myEntitiesState ) {
 635     myEntitiesFlag = true;
 636   }
 637
 638   myEntitiesCache = entities;
 639 }
 640
 641 //=================================================================================
 642 // function : ClearEntitiesFlags
 643 // purpose  : Clear the entities flags
 644 //=================================================================================
 645 void SMESH_VisualObjDef::ClearEntitiesFlags()
 646 {
 647   myEntitiesState = SMESH_Actor::eAllEntity;
 648   myEntitiesFlag = false;
 649 }
 650
 651 //=================================================================================
 652 // function : GetEntitiesFlag
 653 // purpose  : Return the entities flag
 654 //=================================================================================
 655 bool SMESH_VisualObjDef::GetEntitiesFlag()
 656 {
 657   return myEntitiesFlag;
 658 }
 659
 660 //=================================================================================
 661 // function : GetEntitiesState
 662 // purpose  : Return the entities state
 663 //=================================================================================
 664 unsigned int SMESH_VisualObjDef::GetEntitiesState()
 665 {
 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   if ( MYDEBUG ) MESSAGE("SMESH_MeshObj::Update " << this);
 706   if ( myClient.Update(theIsClear) || GetUnstructuredGrid()->GetNumberOfPoints()==0) {
 707     if ( MYDEBUG ) MESSAGE("buildPrs");
 708     buildPrs();  // Fill unstructured grid
 709     return true;
 710   }
 711   return false;
 712 }
 713
 714 bool SMESH_MeshObj::NulData()
 715 {
 716   if ( MYDEBUG ) 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   if ( MYDEBUG ) 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 }