]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_VtkVolume.cxx
Salome HOME
Merge remote branch 'origin/V7_dev' into V7_dev
[modules/smesh.git] / src / SMDS / SMDS_VtkVolume.cxx
1 // Copyright (C) 2010-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "SMDS_VtkVolume.hxx"
21 #include "SMDS_MeshNode.hxx"
22 #include "SMDS_Mesh.hxx"
23 #include "SMDS_VtkCellIterator.hxx"
24
25 #include "utilities.h"
26
27 #include <vector>
28
29 SMDS_VtkVolume::SMDS_VtkVolume()
30 {
31 }
32
33 SMDS_VtkVolume::SMDS_VtkVolume(const std::vector<vtkIdType>& nodeIds, SMDS_Mesh* mesh)
34 {
35   init(nodeIds, mesh);
36 }
37 /*!
38  * typed used are vtk types (@see vtkCellType.h)
39  * see GetEntityType() for conversion in SMDS type (@see SMDSAbs_ElementType.hxx)
40  */
41 void SMDS_VtkVolume::init(const std::vector<vtkIdType>& nodeIds, SMDS_Mesh* mesh)
42 {
43   SMDS_MeshVolume::init();
44   vtkUnstructuredGrid* grid = mesh->getGrid();
45   myMeshId = mesh->getMeshId();
46   vtkIdType aType = VTK_TETRA;
47   switch (nodeIds.size()) // cases are in order of usage frequency
48   {
49     case 4:
50       aType = VTK_TETRA;
51       break;
52     case 8:
53       aType = VTK_HEXAHEDRON;
54       break;
55     case 5:
56       aType = VTK_PYRAMID;
57       break;
58     case 6:
59       aType = VTK_WEDGE;
60       break;
61     case 10:
62       aType = VTK_QUADRATIC_TETRA;
63       break;
64     case 20:
65       aType = VTK_QUADRATIC_HEXAHEDRON;
66       break;
67     case 13:
68       aType = VTK_QUADRATIC_PYRAMID;
69       break;
70     case 15:
71       aType = VTK_QUADRATIC_WEDGE;
72       break;
73     case 12:
74       aType = VTK_HEXAGONAL_PRISM;
75       break;
76     case 27:
77       aType = VTK_TRIQUADRATIC_HEXAHEDRON;
78       break;
79     default:
80       aType = VTK_HEXAHEDRON;
81       break;
82   }
83   myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), (vtkIdType *) &nodeIds[0]);
84   mesh->setMyModified();
85   //MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID);
86 }
87
88 //#ifdef VTK_HAVE_POLYHEDRON
89 void SMDS_VtkVolume::initPoly(const std::vector<vtkIdType>& nodeIds,
90                               const std::vector<int>&       nbNodesPerFace,
91                               SMDS_Mesh*                    mesh)
92 {
93   SMDS_MeshVolume::init();
94   //MESSAGE("SMDS_VtkVolume::initPoly");
95   SMDS_UnstructuredGrid* grid = mesh->getGrid();
96   //double center[3];
97   //this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), &center[0]);
98   std::vector<vtkIdType> ptIds;
99   vtkIdType nbFaces = nbNodesPerFace.size();
100   int k = 0;
101   for (int i = 0; i < nbFaces; i++)
102     {
103       int nf = nbNodesPerFace[i];
104       ptIds.push_back(nf);
105       // EAP: a right approach is:
106       // - either the user should care of order of nodes or
107       // - the user should use a service method arranging nodes if he
108       //   don't want or can't to do it by him-self
109       // The method below works OK only with planar faces and convex polyhedrones
110       //
111       // double a[3];
112       // double b[3];
113       // double c[3];
114       // grid->GetPoints()->GetPoint(nodeIds[k], a);
115       // grid->GetPoints()->GetPoint(nodeIds[k + 1], b);
116       // grid->GetPoints()->GetPoint(nodeIds[k + 2], c);
117       // bool isFaceForward = this->isForward(a, b, c, center);
118       //MESSAGE("isFaceForward " << i << " " << isFaceForward);
119       const vtkIdType *facePts = &nodeIds[k];
120       //if (isFaceForward)
121         for (int n = 0; n < nf; n++)
122           ptIds.push_back(facePts[n]);
123       // else
124       //   for (int n = nf - 1; n >= 0; n--)
125       //     ptIds.push_back(facePts[n]);
126       k += nf;
127     }
128   myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
129   mesh->setMyModified();
130 }
131 //#endif
132
133 bool SMDS_VtkVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
134 {
135   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
136   vtkIdType npts = 0;
137   vtkIdType* pts = 0;
138   grid->GetCellPoints(myVtkID, npts, pts);
139   if (nbNodes != npts)
140     {
141       MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes);
142       return false;
143     }
144   for (int i = 0; i < nbNodes; i++)
145     {
146       pts[i] = nodes[i]->getVtkId();
147     }
148   SMDS_Mesh::_meshList[myMeshId]->setMyModified();
149   return true;
150 }
151
152 /*!
153  * Reorder in VTK order a list of nodes given in SMDS order.
154  * To be used before ChangeNodes: lists are given or computed in SMDS order.
155  */
156 bool SMDS_VtkVolume::vtkOrder(const SMDS_MeshNode* nodes[], const int nbNodes)
157 {
158   if (nbNodes != this->NbNodes())
159     {
160       MESSAGE("vtkOrder, wrong number of nodes " << nbNodes << " instead of "<< this->NbNodes());
161       return false;
162     }
163   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
164   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
165   const std::vector<int>& interlace = SMDS_MeshCell::toVtkOrder( VTKCellType( aVtkType ));
166   if ( !interlace.empty() )
167   {
168     ASSERT( (int)interlace.size() == nbNodes );
169     std::vector<const SMDS_MeshNode*> initNodes( nodes, nodes+nbNodes );
170     for ( size_t i = 0; i < interlace.size(); ++i )
171       nodes[i] = initNodes[ interlace[i] ];
172   }
173   return true;
174 }
175
176 SMDS_VtkVolume::~SMDS_VtkVolume()
177 {
178 }
179
180 void SMDS_VtkVolume::Print(ostream & OS) const
181 {
182   OS << "volume <" << GetID() << "> : ";
183 }
184
185 int SMDS_VtkVolume::NbFaces() const
186 {
187   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
188   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
189   int nbFaces = 4;
190   switch (aVtkType)
191   {
192     case VTK_TETRA:
193     case VTK_QUADRATIC_TETRA:
194       nbFaces = 4;
195       break;
196     case VTK_PYRAMID:
197     case VTK_WEDGE:
198     case VTK_QUADRATIC_PYRAMID:
199     case VTK_QUADRATIC_WEDGE:
200       nbFaces = 5;
201       break;
202     case VTK_HEXAHEDRON:
203     case VTK_QUADRATIC_HEXAHEDRON:
204     case VTK_TRIQUADRATIC_HEXAHEDRON:
205       nbFaces = 6;
206       break;
207     case VTK_POLYHEDRON:
208       {
209         vtkIdType nFaces = 0;
210         vtkIdType* ptIds = 0;
211         grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
212         nbFaces = nFaces;
213         break;
214       }
215     case VTK_HEXAGONAL_PRISM:
216       nbFaces = 8;
217       break;
218     default:
219       MESSAGE("invalid volume type")
220       ;
221       nbFaces = 0;
222       break;
223   }
224   return nbFaces;
225 }
226
227 int SMDS_VtkVolume::NbNodes() const
228 {
229   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
230   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
231   int nbPoints = 0;
232   if (aVtkType != VTK_POLYHEDRON)
233     {
234       nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints();
235     }
236   else
237     {
238       vtkIdType nFaces = 0;
239       vtkIdType* ptIds = 0;
240       grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
241       int id = 0;
242       for (int i = 0; i < nFaces; i++)
243         {
244           int nodesInFace = ptIds[id];
245           nbPoints += nodesInFace;
246           id += (nodesInFace + 1);
247         }
248     }
249   return nbPoints;
250 }
251
252 int SMDS_VtkVolume::NbEdges() const
253 {
254   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
255   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
256   int nbEdges = 6;
257   switch (aVtkType)
258   {
259     case VTK_TETRA:
260     case VTK_QUADRATIC_TETRA:
261       nbEdges = 6;
262       break;
263     case VTK_PYRAMID:
264     case VTK_QUADRATIC_PYRAMID:
265       nbEdges = 8;
266       break;
267     case VTK_WEDGE:
268     case VTK_QUADRATIC_WEDGE:
269       nbEdges = 9;
270       break;
271     case VTK_HEXAHEDRON:
272     case VTK_QUADRATIC_HEXAHEDRON:
273     case VTK_TRIQUADRATIC_HEXAHEDRON:
274       nbEdges = 12;
275       break;
276     case VTK_POLYHEDRON:
277       {
278         vtkIdType nFaces = 0;
279         vtkIdType* ptIds = 0;
280         grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
281         nbEdges = 0;
282         int id = 0;
283         for (int i = 0; i < nFaces; i++)
284           {
285             int edgesInFace = ptIds[id];
286             id += (edgesInFace + 1);
287             nbEdges += edgesInFace;
288           }
289         nbEdges = nbEdges / 2;
290         break;
291       }
292     case VTK_HEXAGONAL_PRISM:
293       nbEdges = 18;
294       break;
295     default:
296       MESSAGE("invalid volume type")
297       ;
298       nbEdges = 0;
299       break;
300   }
301   return nbEdges;
302 }
303
304 /*! polyhedron only,
305  *  1 <= face_ind <= NbFaces()
306  */
307 int SMDS_VtkVolume::NbFaceNodes(const int face_ind) const
308 {
309   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
310   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
311   int nbNodes = 0;
312   if (aVtkType == VTK_POLYHEDRON)
313     {
314       vtkIdType nFaces = 0;
315       vtkIdType* ptIds = 0;
316       grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
317       int id = 0;
318       for (int i = 0; i < nFaces; i++)
319         {
320           int nodesInFace = ptIds[id];
321           id += (nodesInFace + 1);
322           if (i == face_ind - 1)
323             {
324               nbNodes = nodesInFace;
325               break;
326             }
327         }
328     }
329   return nbNodes;
330 }
331
332 /*! polyhedron only,
333  *  1 <= face_ind <= NbFaces()
334  *  1 <= node_ind <= NbFaceNodes()
335  */
336 const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int node_ind) const
337 {
338   SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
339   vtkUnstructuredGrid* grid = mesh->getGrid();
340   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
341   const SMDS_MeshNode* node = 0;
342   if (aVtkType == VTK_POLYHEDRON)
343     {
344       vtkIdType nFaces = 0;
345       vtkIdType* ptIds = 0;
346       grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
347       int id = 0;
348       for (int i = 0; i < nFaces; i++)
349         {
350           int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
351           if (i == face_ind - 1) // first face is number 1
352             {
353               if ((node_ind > 0) && (node_ind <= nodesInFace))
354                 node = mesh->FindNodeVtk(ptIds[id + node_ind]); // ptIds[id+1] : first node
355               break;
356             }
357           id += (nodesInFace + 1);
358         }
359     }
360   return node;
361 }
362
363 /*! polyhedron only,
364  *  return number of nodes for each face
365  */
366 std::vector<int> SMDS_VtkVolume::GetQuantities() const
367 {
368   std::vector<int> quantities;
369   SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
370   vtkUnstructuredGrid* grid = mesh->getGrid();
371   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
372   if (aVtkType == VTK_POLYHEDRON)
373     {
374       vtkIdType nFaces = 0;
375       vtkIdType* ptIds = 0;
376       grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
377       int id = 0;
378       for (int i = 0; i < nFaces; i++)
379         {
380           int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
381           quantities.push_back(nodesInFace);
382           id += (nodesInFace + 1);
383         }
384     }
385   return quantities;
386 }
387
388 SMDS_ElemIteratorPtr SMDS_VtkVolume::elementsIterator(SMDSAbs_ElementType type) const
389 {
390   switch (type)
391   {
392     case SMDSAbs_Node:
393       {
394         SMDSAbs_EntityType aType = this->GetEntityType();
395         if (aType == SMDSEntity_Polyhedra)
396           return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorPolyH(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
397         else
398           return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
399       }
400     default:
401       MESSAGE("ERROR : Iterator not implemented");
402       return SMDS_ElemIteratorPtr((SMDS_ElemIterator*) NULL);
403   }
404 }
405
406 SMDS_NodeIteratorPtr SMDS_VtkVolume::nodesIteratorToUNV() const
407 {
408   return SMDS_NodeIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
409 }
410
411 SMDS_NodeIteratorPtr SMDS_VtkVolume::interlacedNodesIterator() const
412 {
413   return SMDS_NodeIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
414 }
415
416 SMDSAbs_ElementType SMDS_VtkVolume::GetType() const
417 {
418   return SMDSAbs_Volume;
419 }
420
421 /*!
422  * \brief Return node by its index
423  * \param ind - node index
424  * \retval const SMDS_MeshNode* - the node
425  */
426 const SMDS_MeshNode* SMDS_VtkVolume::GetNode(const int ind) const
427 {
428   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
429   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
430   if ( aVtkType == VTK_POLYHEDRON)
431   {
432     vtkIdType nFaces = 0;
433     vtkIdType* ptIds = 0;
434     grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
435     int id = 0, nbPoints = 0;
436     for (int i = 0; i < nFaces; i++)
437     {
438       int nodesInFace = ptIds[id];
439       if ( ind < nbPoints + nodesInFace )
440         return SMDS_Mesh::_meshList[myMeshId]->FindNodeVtk( ptIds[ ind + i ]);
441       nbPoints += nodesInFace;
442       id += (nodesInFace + 1);
443     }
444     return 0;
445   }
446   vtkIdType npts, *pts;
447   grid->GetCellPoints( this->myVtkID, npts, pts );
448   const std::vector<int>& interlace = SMDS_MeshCell::fromVtkOrder( VTKCellType( aVtkType ));
449   return SMDS_Mesh::_meshList[myMeshId]->FindNodeVtk( pts[ interlace.empty() ? ind : interlace[ind]] );
450 }
451 /*!
452  * \brief Check if a node belongs to the element
453  * \param node - the node to check
454  * \retval int - node index within the element, -1 if not found
455  */
456 int SMDS_VtkVolume::GetNodeIndex( const SMDS_MeshNode* node ) const
457 {
458   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
459   const  vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
460   if ( aVtkType == VTK_POLYHEDRON)
461   {
462     vtkIdType nFaces = 0;
463     vtkIdType* ptIds = 0;
464     grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
465     int id = 0;
466     for (int iF = 0; iF < nFaces; iF++)
467     {
468       int nodesInFace = ptIds[id];
469       for ( vtkIdType i = 0; i < nodesInFace; ++i )
470         if ( ptIds[id+i+1] == node->getVtkId() )
471           return id+i-iF;
472       id += (nodesInFace + 1);
473     }
474     return -1;
475   }
476   vtkIdType npts, *pts;
477   grid->GetCellPoints( this->myVtkID, npts, pts );
478   for ( vtkIdType i = 0; i < npts; ++i )
479     if ( pts[i] == node->getVtkId() )
480     {
481       const std::vector<int>& interlace = SMDS_MeshCell::toVtkOrder( VTKCellType( aVtkType ));
482       return interlace.empty() ? i : interlace[i];
483     }
484   return -1;
485 }
486
487 bool SMDS_VtkVolume::IsQuadratic() const
488 {
489   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
490   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
491   // TODO quadratic polyhedrons ?
492   switch (aVtkType)
493   {
494     case VTK_QUADRATIC_TETRA:
495     case VTK_QUADRATIC_PYRAMID:
496     case VTK_QUADRATIC_WEDGE:
497     case VTK_QUADRATIC_HEXAHEDRON:
498     case VTK_TRIQUADRATIC_HEXAHEDRON:
499       return true;
500       break;
501     default:
502       return false;
503   }
504 }
505
506 bool SMDS_VtkVolume::IsPoly() const
507 {
508   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
509   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
510   return (aVtkType == VTK_POLYHEDRON);
511 }
512
513 bool SMDS_VtkVolume::IsMediumNode(const SMDS_MeshNode* node) const
514 {
515   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
516   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
517   int rankFirstMedium = 0;
518   switch (aVtkType)
519   {
520     case VTK_QUADRATIC_TETRA:
521       rankFirstMedium = 4; // medium nodes are of rank 4 to 9
522       break;
523     case VTK_QUADRATIC_PYRAMID:
524       rankFirstMedium = 5; // medium nodes are of rank 5 to 12
525       break;
526     case VTK_QUADRATIC_WEDGE:
527       rankFirstMedium = 6; // medium nodes are of rank 6 to 14
528       break;
529     case VTK_QUADRATIC_HEXAHEDRON:
530     case VTK_TRIQUADRATIC_HEXAHEDRON:
531       rankFirstMedium = 8; // medium nodes are of rank 8 to 19
532       break;
533     default:
534       return false;
535   }
536   vtkIdType npts = 0;
537   vtkIdType* pts = 0;
538   grid->GetCellPoints(myVtkID, npts, pts);
539   vtkIdType nodeId = node->getVtkId();
540   for (int rank = 0; rank < npts; rank++)
541     {
542       if (pts[rank] == nodeId)
543         {
544           if (rank < rankFirstMedium)
545             return false;
546           else
547             return true;
548         }
549     }
550   //throw SALOME_Exception(LOCALIZED("node does not belong to this element"));
551   MESSAGE("======================================================");
552   MESSAGE("= IsMediumNode: node does not belong to this element =");
553   MESSAGE("======================================================");
554   return false;
555 }
556
557 int SMDS_VtkVolume::NbCornerNodes() const
558 {
559   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
560   vtkIdType aVtkType = grid->GetCellType(myVtkID);
561   switch (aVtkType)
562   {
563   case VTK_QUADRATIC_TETRA:         return 4;
564   case VTK_QUADRATIC_PYRAMID:       return 5;
565   case VTK_QUADRATIC_WEDGE:         return 6;
566   case VTK_QUADRATIC_HEXAHEDRON:
567   case VTK_TRIQUADRATIC_HEXAHEDRON: return 8;
568   default:;
569   }
570   return NbNodes();
571 }
572
573 SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const
574 {
575   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
576   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
577
578   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
579   switch (aVtkType)
580   {
581     case VTK_TETRA:
582       aType = SMDSEntity_Tetra;
583       break;
584     case VTK_PYRAMID:
585       aType = SMDSEntity_Pyramid;
586       break;
587     case VTK_WEDGE:
588       aType = SMDSEntity_Penta;
589       break;
590     case VTK_HEXAHEDRON:
591       aType = SMDSEntity_Hexa;
592       break;
593     case VTK_QUADRATIC_TETRA:
594       aType = SMDSEntity_Quad_Tetra;
595       break;
596     case VTK_QUADRATIC_PYRAMID:
597       aType = SMDSEntity_Quad_Pyramid;
598       break;
599     case VTK_QUADRATIC_WEDGE:
600       aType = SMDSEntity_Quad_Penta;
601       break;
602     case VTK_QUADRATIC_HEXAHEDRON:
603       aType = SMDSEntity_Quad_Hexa;
604       break;
605     case VTK_TRIQUADRATIC_HEXAHEDRON:
606       aType = SMDSEntity_TriQuad_Hexa;
607       break;
608     case VTK_HEXAGONAL_PRISM:
609       aType = SMDSEntity_Hexagonal_Prism;
610       break;
611 //#ifdef VTK_HAVE_POLYHEDRON
612     case VTK_POLYHEDRON:
613       aType = SMDSEntity_Polyhedra;
614       break;
615 //#endif
616     default:
617       aType = SMDSEntity_Polyhedra;
618       break;
619   }
620   return aType;
621 }
622
623 SMDSAbs_GeometryType SMDS_VtkVolume::GetGeomType() const
624 {
625   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
626   vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
627
628   SMDSAbs_GeometryType aType = SMDSGeom_NONE;
629   switch (aVtkType)
630   {
631     case VTK_TETRA:
632     case VTK_QUADRATIC_TETRA:
633       aType = SMDSGeom_TETRA;
634       break;
635     case VTK_PYRAMID:
636     case VTK_QUADRATIC_PYRAMID:
637       aType = SMDSGeom_PYRAMID;
638       break;
639     case VTK_WEDGE:
640     case VTK_QUADRATIC_WEDGE:
641       aType = SMDSGeom_PENTA;
642       break;
643     case VTK_HEXAHEDRON:
644     case VTK_QUADRATIC_HEXAHEDRON:
645     case VTK_TRIQUADRATIC_HEXAHEDRON:
646       aType = SMDSGeom_HEXA;
647       break;
648     case VTK_HEXAGONAL_PRISM:
649       aType = SMDSGeom_HEXAGONAL_PRISM;
650       break;
651 //#ifdef VTK_HAVE_POLYHEDRON
652     case VTK_POLYHEDRON:
653       aType = SMDSGeom_POLYHEDRA;
654       break;
655 //#endif
656     default:
657       aType = SMDSGeom_POLYHEDRA;
658       break;
659   }
660   return aType;
661 }
662
663 vtkIdType SMDS_VtkVolume::GetVtkType() const
664 {
665   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
666   vtkIdType aType = grid->GetCellType(myVtkID);
667   return aType;
668 }
669
670 void SMDS_VtkVolume::gravityCenter(SMDS_UnstructuredGrid* grid,
671                                    const vtkIdType *      nodeIds,
672                                    int                    nbNodes,
673                                    double*                result)
674 {
675   for (int j = 0; j < 3; j++)
676     result[j] = 0;
677   if (nbNodes <= 0)
678     return;
679   for (int i = 0; i < nbNodes; i++)
680     {
681       double *coords = grid->GetPoint(nodeIds[i]);
682       for (int j = 0; j < 3; j++)
683         result[j] += coords[j];
684     }
685   for (int j = 0; j < 3; j++)
686     result[j] = result[j] / nbNodes;
687   //MESSAGE("center " << result[0] << " " << result[1] << " "  << result[2]);
688   return;
689 }
690
691 bool SMDS_VtkVolume::isForward(double* a, double* b, double* c, double* d)
692 {
693   double u[3], v[3], w[3];
694   for (int j = 0; j < 3; j++)
695     {
696       //MESSAGE("a,b,c,d " << a[j] << " " << b[j] << " " << c[j] << " " << d[j]);
697       u[j] = b[j] - a[j];
698       v[j] = c[j] - a[j];
699       w[j] = d[j] - a[j];
700       //MESSAGE("u,v,w " << u[j] << " " << v[j] << " " << w[j]);
701     }
702   double prodmixte = (u[1]*v[2] - u[2]*v[1]) * w[0]
703                    + (u[2]*v[0] - u[0]*v[2]) * w[1]
704                    + (u[0]*v[1] - u[1]*v[0]) * w[2];
705   return (prodmixte < 0);
706 }
707
708 /*! For polyhedron only
709  *  @return actual number of nodes (not the sum of nodes of all faces)
710  */
711 int SMDS_VtkVolume::NbUniqueNodes() const
712 {
713   vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
714   return grid->GetCell(myVtkID)->GetNumberOfPoints();
715 }
716
717 /*! For polyhedron use only
718  *  @return iterator on actual nodes (not through the faces)
719  */
720 SMDS_ElemIteratorPtr SMDS_VtkVolume::uniqueNodesIterator() const
721 {
722   //MESSAGE("uniqueNodesIterator");
723   return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
724 }