]> SALOME platform Git repositories - modules/smesh.git/blob - src/OBJECT/SMESH_Object.cxx
Salome HOME
INT PAL 0052858: VTK viewer is not updated at 'Controls - Reset' call
[modules/smesh.git] / 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 }