]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_MeshCell.cxx
Salome HOME
Merge branch 'master' into gni/adaptation
[modules/smesh.git] / src / SMDS / SMDS_MeshCell.cxx
1 // Copyright (C) 2010-2020  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_MeshCell.hxx"
21
22 #include "SMDS_Mesh.hxx"
23 #include "SMDS_VtkCellIterator.hxx"
24
25 #include <utilities.h>
26
27 #include <vtkCell.h>
28
29 #include <cstdarg>
30
31 #include <boost/make_shared.hpp>
32
33 namespace
34 {
35   /*!
36    * \brief Cell type features
37    */
38   struct CellProps
39   {
40     SMDSAbs_EntityType   myEntity;
41     SMDSAbs_ElementType  myType;
42     SMDSAbs_GeometryType myGeom;
43     bool                 myIsPoly;
44     bool                 myIsQuadratic;
45     int                  myNbCornerNodes;
46     int                  myNbNodes;
47     int                  myNbEdges;
48     int                  myNbFaces;
49
50     CellProps() :
51       myEntity( SMDSEntity_Last ), myType( SMDSAbs_All ), myGeom( SMDSGeom_NONE ),
52       myIsPoly( 0 ), myNbCornerNodes( 0 ),
53       myNbNodes( 0 ), myNbEdges( 0 ), myNbFaces ( 0 )
54     {
55     }
56     void Set( SMDSAbs_EntityType   Entity,
57               SMDSAbs_ElementType  Type,
58               SMDSAbs_GeometryType Geom,
59               bool                 IsPoly,
60               int                  NbCornerNodes,
61               int                  NbNodes,
62               int                  NbEdges,
63               int                  NbFaces)
64     {
65       myEntity        = Entity;
66       myType          = Type;
67       myGeom          = Geom;
68       myIsPoly        = IsPoly;
69       myIsQuadratic   = ( NbNodes > NbCornerNodes );
70       myNbCornerNodes = NbCornerNodes;
71       myNbNodes       = NbNodes;
72       myNbEdges       = NbEdges;
73       myNbFaces       = NbFaces;
74     }
75   };
76
77   static std::vector< CellProps > theCellProps;
78
79   //! initialize theCellProps
80   void initCellProps()
81   {
82     theCellProps.resize( VTK_NUMBER_OF_CELL_TYPES );
83     CellProps* p = & theCellProps[0];
84     p[ VTK_VERTEX ].
85       Set( SMDSEntity_0D, SMDSAbs_0DElement, SMDSGeom_POINT,
86            /*isPoly=*/0,/*nbCN=*/1,/*nbN=*/1,/*nbE=*/0,/*nbF=*/0 );
87     p[ VTK_LINE ].
88       Set( SMDSEntity_Edge, SMDSAbs_Edge, SMDSGeom_EDGE,
89            /*isPoly=*/0,/*nbCN=*/2,/*nbN=*/2,/*nbE=*/1,/*nbF=*/0 );
90     p[ VTK_QUADRATIC_EDGE ].
91       Set( SMDSEntity_Quad_Edge, SMDSAbs_Edge, SMDSGeom_EDGE,
92            /*isPoly=*/0,/*nbCN=*/2,/*nbN=*/3,/*nbE=*/1,/*nbF=*/0 );
93     p[ VTK_TRIANGLE ].
94       Set( SMDSEntity_Triangle, SMDSAbs_Face, SMDSGeom_TRIANGLE,
95            /*isPoly=*/0,/*nbCN=*/3,/*nbN=*/3,/*nbE=*/3,/*nbF=*/1 );
96     p[ VTK_QUADRATIC_TRIANGLE ].
97       Set( SMDSEntity_Quad_Triangle, SMDSAbs_Face, SMDSGeom_TRIANGLE,
98            /*isPoly=*/0,/*nbCN=*/3,/*nbN=*/6,/*nbE=*/3,/*nbF=*/1 );
99     p[ VTK_BIQUADRATIC_TRIANGLE ].
100       Set( SMDSEntity_BiQuad_Triangle, SMDSAbs_Face, SMDSGeom_TRIANGLE,
101            /*isPoly=*/0,/*nbCN=*/3,/*nbN=*/7,/*nbE=*/3,/*nbF=*/1 );
102     p[ VTK_QUAD].
103       Set( SMDSEntity_Quadrangle, SMDSAbs_Face, SMDSGeom_QUADRANGLE,
104            /*isPoly=*/0,/*nbCN=*/4,/*nbN=*/4,/*nbE=*/4,/*nbF=*/1 );
105     p[ VTK_QUADRATIC_QUAD].
106       Set( SMDSEntity_Quad_Quadrangle, SMDSAbs_Face, SMDSGeom_QUADRANGLE,
107            /*isPoly=*/0,/*nbCN=*/4,/*nbN=*/8,/*nbE=*/4,/*nbF=*/1 );
108     p[ VTK_BIQUADRATIC_QUAD].
109       Set( SMDSEntity_BiQuad_Quadrangle, SMDSAbs_Face, SMDSGeom_QUADRANGLE,
110            /*isPoly=*/0,/*nbCN=*/4,/*nbN=*/9,/*nbE=*/4,/*nbF=*/1 );
111     p[ VTK_POLYGON ].
112       Set( SMDSEntity_Polygon, SMDSAbs_Face, SMDSGeom_POLYGON,
113            /*isPoly=*/1,/*nbCN=*/-1,/*nbN=*/-1,/*nbE=*/-1,/*nbF=*/1 );
114     p[ VTK_QUADRATIC_POLYGON ].
115       Set( SMDSEntity_Quad_Polygon, SMDSAbs_Face, SMDSGeom_POLYGON,
116            /*isPoly=*/1,/*nbCN=*/-2,/*nbN=*/-1,/*nbE=*/-1,/*nbF=*/1 );
117     p[ VTK_TETRA ].
118       Set( SMDSEntity_Tetra, SMDSAbs_Volume, SMDSGeom_TETRA,
119            /*isPoly=*/0,/*nbCN=*/4,/*nbN=*/4,/*nbE=*/6,/*nbF=*/4 );
120     p[ VTK_QUADRATIC_TETRA ].
121       Set( SMDSEntity_Quad_Tetra, SMDSAbs_Volume, SMDSGeom_TETRA,
122            /*isPoly=*/0,/*nbCN=*/4,/*nbN=*/10,/*nbE=*/6,/*nbF=*/4 );
123     p[ VTK_PYRAMID ].
124       Set( SMDSEntity_Pyramid, SMDSAbs_Volume, SMDSGeom_PYRAMID,
125            /*isPoly=*/0,/*nbCN=*/5,/*nbN=*/5,/*nbE=*/8,/*nbF=*/5 );
126     p[ VTK_QUADRATIC_PYRAMID].
127       Set( SMDSEntity_Quad_Pyramid, SMDSAbs_Volume, SMDSGeom_PYRAMID,
128            /*isPoly=*/0,/*nbCN=*/5,/*nbN=*/13,/*nbE=*/8,/*nbF=*/5 );
129     p[ VTK_HEXAHEDRON ].
130       Set( SMDSEntity_Hexa, SMDSAbs_Volume, SMDSGeom_HEXA,
131            /*isPoly=*/0,/*nbCN=*/8,/*nbN=*/8,/*nbE=*/12,/*nbF=*/6 );
132     p[ VTK_QUADRATIC_HEXAHEDRON ].
133       Set( SMDSEntity_Quad_Hexa, SMDSAbs_Volume, SMDSGeom_HEXA,
134            /*isPoly=*/0,/*nbCN=*/8,/*nbN=*/20,/*nbE=*/12,/*nbF=*/6 );
135     p[ VTK_TRIQUADRATIC_HEXAHEDRON ].
136       Set( SMDSEntity_TriQuad_Hexa, SMDSAbs_Volume, SMDSGeom_HEXA,
137            /*isPoly=*/0,/*nbCN=*/8,/*nbN=*/27,/*nbE=*/12,/*nbF=*/6 );
138     p[ VTK_WEDGE ].
139       Set( SMDSEntity_Penta, SMDSAbs_Volume, SMDSGeom_PENTA,
140            /*isPoly=*/0,/*nbCN=*/6,/*nbN=*/6,/*nbE=*/9,/*nbF=*/5 );
141     p[ VTK_QUADRATIC_WEDGE ].
142       Set( SMDSEntity_Quad_Penta, SMDSAbs_Volume, SMDSGeom_PENTA,
143            /*isPoly=*/0,/*nbCN=*/6,/*nbN=*/15,/*nbE=*/9,/*nbF=*/5 );
144     p[ VTK_BIQUADRATIC_QUADRATIC_WEDGE ].
145       Set( SMDSEntity_BiQuad_Penta, SMDSAbs_Volume, SMDSGeom_PENTA,
146            /*isPoly=*/0,/*nbCN=*/6,/*nbN=*/18,/*nbE=*/9,/*nbF=*/5 );
147     p[ VTK_HEXAGONAL_PRISM].
148       Set( SMDSEntity_Hexagonal_Prism, SMDSAbs_Volume, SMDSGeom_HEXAGONAL_PRISM,
149            /*isPoly=*/0,/*nbCN=*/12,/*nbN=*/12,/*nbE=*/18,/*nbF=*/8 );
150     p[ VTK_POLYHEDRON ].
151       Set( SMDSEntity_Polyhedra, SMDSAbs_Volume, SMDSGeom_POLYHEDRA,
152            /*isPoly=*/1,/*nbCN=*/-1,/*nbN=*/-1,/*nbE=*/-1,/*nbF=*/-1 );
153     p[ VTK_POLY_VERTEX].
154       Set( SMDSEntity_Ball, SMDSAbs_Ball, SMDSGeom_BALL,
155            /*isPoly=*/0,/*nbCN=*/1,/*nbN=*/1,/*nbE=*/0,/*nbF=*/0 );
156   }
157
158   //! return vector a CellProps
159   const CellProps& getCellProps( VTKCellType vtkType )
160   {
161     return theCellProps[ vtkType ];
162   } // getCellProps()
163
164   //! return vector a CellProps
165   const CellProps& getCellProps( SMDSAbs_EntityType entity )
166   {
167     return getCellProps( SMDS_MeshCell::toVtkType( entity ));
168   }
169
170
171   static std::vector< VTKCellType > theVtkTypes; //!< VTK types by SMDS ones
172
173   void initVtkTypes()
174   {
175     theVtkTypes.resize( SMDSEntity_Last+1, VTK_EMPTY_CELL );
176     theVtkTypes[ SMDSEntity_Node ]              = VTK_VERTEX;
177     theVtkTypes[ SMDSEntity_0D ]                = VTK_VERTEX;
178     theVtkTypes[ SMDSEntity_Edge ]              = VTK_LINE;
179     theVtkTypes[ SMDSEntity_Quad_Edge ]         = VTK_QUADRATIC_EDGE;
180     theVtkTypes[ SMDSEntity_Triangle ]          = VTK_TRIANGLE;
181     theVtkTypes[ SMDSEntity_Quad_Triangle ]     = VTK_QUADRATIC_TRIANGLE;
182     theVtkTypes[ SMDSEntity_BiQuad_Triangle ]   = VTK_BIQUADRATIC_TRIANGLE;
183     theVtkTypes[ SMDSEntity_Quadrangle ]        = VTK_QUAD;
184     theVtkTypes[ SMDSEntity_Quad_Quadrangle ]   = VTK_QUADRATIC_QUAD;
185     theVtkTypes[ SMDSEntity_BiQuad_Quadrangle ] = VTK_BIQUADRATIC_QUAD;
186     theVtkTypes[ SMDSEntity_Polygon ]           = VTK_POLYGON;
187     theVtkTypes[ SMDSEntity_Quad_Polygon ]      = VTK_QUADRATIC_POLYGON;
188     theVtkTypes[ SMDSEntity_Tetra ]             = VTK_TETRA;
189     theVtkTypes[ SMDSEntity_Quad_Tetra ]        = VTK_QUADRATIC_TETRA;
190     theVtkTypes[ SMDSEntity_Pyramid ]           = VTK_PYRAMID;
191     theVtkTypes[ SMDSEntity_Quad_Pyramid ]      = VTK_QUADRATIC_PYRAMID;
192     theVtkTypes[ SMDSEntity_Hexa ]              = VTK_HEXAHEDRON;
193     theVtkTypes[ SMDSEntity_Quad_Hexa ]         = VTK_QUADRATIC_HEXAHEDRON;
194     theVtkTypes[ SMDSEntity_TriQuad_Hexa ]      = VTK_TRIQUADRATIC_HEXAHEDRON;
195     theVtkTypes[ SMDSEntity_Penta ]             = VTK_WEDGE;
196     theVtkTypes[ SMDSEntity_Quad_Penta ]        = VTK_QUADRATIC_WEDGE;
197     theVtkTypes[ SMDSEntity_BiQuad_Penta ]      = VTK_BIQUADRATIC_QUADRATIC_WEDGE;
198     theVtkTypes[ SMDSEntity_Hexagonal_Prism ]   = VTK_HEXAGONAL_PRISM;
199     theVtkTypes[ SMDSEntity_Polyhedra ]         = VTK_POLYHEDRON;
200     //theVtkTypes[ SMDSEntity_Quad_Polyhedra ]    = ;
201     theVtkTypes[ SMDSEntity_Ball ]              = VTK_POLY_VERTEX;
202   }
203
204
205   //! indices to transform cell connectivity from SMDS to VTK
206   static std::vector< std::vector< int > > theToVtkInterlaces;
207
208   void initToVtkInterlaces()
209   {
210     theToVtkInterlaces.resize( SMDSEntity_Last+1 );
211     // {
212     //   const int ids[] = {0};
213     //   theToVtkInterlaces[SMDSEntity_0D].assign( &ids[0], &ids[0]+1 );
214     //   theToVtkInterlaces[SMDSEntity_Node].assign( &ids[0], &ids[0]+1 );
215     // }
216     // {
217     //   const int ids[] = {0,1};
218     //   theToVtkInterlaces[SMDSEntity_Edge].assign( &ids[0], &ids[0]+2 );
219     // }
220     // {
221     //   const int ids[] = {0,1,2};
222     //   theToVtkInterlaces[SMDSEntity_Quad_Edge].assign( &ids[0], &ids[0]+3 );
223     // }
224     // {
225     //   const int ids[] = {0,1,2};
226     //   theToVtkInterlaces[SMDSEntity_Triangle].assign( &ids[0], &ids[0]+3 );
227     // }
228     // {
229     //   const int ids[] = {0,1,2,3,4,5};
230     //   theToVtkInterlaces[SMDSEntity_Quad_Triangle].assign( &ids[0], &ids[0]+6 );
231     // }
232     // {
233     //   const int ids[] = {0,1,2,3};
234     //   theToVtkInterlaces[SMDSEntity_Quadrangle].assign( &ids[0], &ids[0]+4 );
235     // }
236     // {
237     //   const int ids[] = {0,1,2,3,4,5,6,7};
238     //   theToVtkInterlaces[SMDSEntity_Quad_Quadrangle].assign( &ids[0], &ids[0]+8 );
239     // }
240     // {
241     //   const int ids[] = {0,1,2,3,4,5,6,7,8};
242     //   theToVtkInterlaces[SMDSEntity_BiQuad_Quadrangle].assign( &ids[0], &ids[0]+9 );
243     // }
244     {
245       const int ids[] = {0,2,1,3};
246       theToVtkInterlaces[SMDSEntity_Tetra].assign( &ids[0], &ids[0]+4 );
247     }
248     {
249       const int ids[] = {0,2,1,3,6,5,4,7,9,8};
250       theToVtkInterlaces[SMDSEntity_Quad_Tetra].assign( &ids[0], &ids[0]+10 );
251     }
252     {
253       const int ids[] = {0,3,2,1,4};
254       theToVtkInterlaces[SMDSEntity_Pyramid].assign( &ids[0], &ids[0]+5 );
255     }
256     {
257       const int ids[] = {0,3,2,1,4,8,7,6,5,9,12,11,10};
258       theToVtkInterlaces[SMDSEntity_Quad_Pyramid].assign( &ids[0], &ids[0]+13 );
259     }
260     {
261       const int ids[] = {0,3,2,1,4,7,6,5};
262       theToVtkInterlaces[SMDSEntity_Hexa].assign( &ids[0], &ids[0]+8 );
263     }
264     {
265       const int ids[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17};
266       theToVtkInterlaces[SMDSEntity_Quad_Hexa].assign( &ids[0], &ids[0]+20 );
267     }
268     {
269       const int ids[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17, 21,23,24,22,20,25,26};
270       theToVtkInterlaces[SMDSEntity_TriQuad_Hexa].assign( &ids[0], &ids[0]+27 );
271     }
272     {
273       const int ids[] = {0,1,2,3,4,5};
274       theToVtkInterlaces[SMDSEntity_Penta].assign( &ids[0], &ids[0]+6 );
275     }
276     {
277       const int ids[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14}; // TODO: check
278       theToVtkInterlaces[SMDSEntity_Quad_Penta].assign( &ids[0], &ids[0]+15 );
279     }
280     {
281       const int ids[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17};// TODO: check
282       theToVtkInterlaces[SMDSEntity_BiQuad_Penta].assign( &ids[0], &ids[0]+18 );
283     }
284     {
285       const int ids[] = {0,5,4,3,2,1,6,11,10,9,8,7};
286       theToVtkInterlaces[SMDSEntity_Hexagonal_Prism].assign( &ids[0], &ids[0]+12 );
287     }
288   }
289
290
291   //! indices to reverse an SMDS cell
292   static std::vector< std::vector< int > > theReverseInterlaces;
293
294   void initReverseInterlaces()
295   {
296     theReverseInterlaces.resize( SMDSEntity_Last+1 );
297     {
298       const int ids[] = {0};
299       theReverseInterlaces[SMDSEntity_0D  ].assign( &ids[0], &ids[0]+1 );
300       theReverseInterlaces[SMDSEntity_Node].assign( &ids[0], &ids[0]+1 );
301       theReverseInterlaces[SMDSEntity_Ball].assign( &ids[0], &ids[0]+1 );
302     }
303     {
304       const int ids[] = {1,0};
305       theReverseInterlaces[SMDSEntity_Edge].assign( &ids[0], &ids[0]+2 );
306     }
307     {
308       const int ids[] = {1,0,2};
309       theReverseInterlaces[SMDSEntity_Quad_Edge].assign( &ids[0], &ids[0]+3 );
310     }
311     {
312       const int ids[] = {0,2,1};
313       theReverseInterlaces[SMDSEntity_Triangle].assign( &ids[0], &ids[0]+3 );
314     }
315     {
316       const int ids[] = {0,2,1,5,4,3};
317       theReverseInterlaces[SMDSEntity_Quad_Triangle].assign( &ids[0], &ids[0]+6 );
318     }
319     {
320       const int ids[] = {0,2,1,5,4,3,6};
321       theReverseInterlaces[SMDSEntity_BiQuad_Triangle].assign( &ids[0], &ids[0]+7 );
322     }
323     {
324       const int ids[] = {0,3,2,1};
325       theReverseInterlaces[SMDSEntity_Quadrangle].assign( &ids[0], &ids[0]+4 );
326     }
327     {
328       const int ids[] = {0,3,2,1,7,6,5,4};
329       theReverseInterlaces[SMDSEntity_Quad_Quadrangle].assign( &ids[0], &ids[0]+8 );
330     }
331     {
332       const int ids[] = {0,3,2,1,7,6,5,4,8};
333       theReverseInterlaces[SMDSEntity_BiQuad_Quadrangle].assign( &ids[0], &ids[0]+9 );
334     }
335     {
336       const int ids[] = {0,2,1,3};
337       theReverseInterlaces[SMDSEntity_Tetra].assign( &ids[0], &ids[0]+4 );
338     }
339     {
340       const int ids[] = {0,2,1,3,6,5,4,7,9,8};
341       theReverseInterlaces[SMDSEntity_Quad_Tetra].assign( &ids[0], &ids[0]+10 );
342     }
343     {
344       const int ids[] = {0,3,2,1,4};
345       theReverseInterlaces[SMDSEntity_Pyramid].assign( &ids[0], &ids[0]+5 );
346     }
347     {
348       const int ids[] = {0,3,2,1,4,8,7,6,5,9,12,11,10};
349       theReverseInterlaces[SMDSEntity_Quad_Pyramid].assign( &ids[0], &ids[0]+13 );
350     }
351     {
352       const int ids[] = {0,3,2,1,4,7,6,5};
353       theReverseInterlaces[SMDSEntity_Hexa].assign( &ids[0], &ids[0]+8 );
354     }
355     {
356       const int ids[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17};
357       theReverseInterlaces[SMDSEntity_Quad_Hexa].assign( &ids[0], &ids[0]+20 );
358     }
359     {
360       const int ids[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17, 20,24,23,22,21,25,26};
361       theReverseInterlaces[SMDSEntity_TriQuad_Hexa].assign( &ids[0], &ids[0]+27 );
362     }
363     {
364       const int ids[] = {0,2,1,3,5,4};
365       theReverseInterlaces[SMDSEntity_Penta].assign( &ids[0], &ids[0]+6 );
366     }
367     {
368       const int ids[] = {0,2,1,3,5,4, 8,7,6,11,10,9,12,14,13};
369       theReverseInterlaces[SMDSEntity_Quad_Penta].assign( &ids[0], &ids[0]+15 );
370     }
371     {
372       const int ids[] = {0,2,1,3,5,4, 8,7,6,11,10,9,12,14,13,15,16,17};
373       theReverseInterlaces[SMDSEntity_BiQuad_Penta].assign( &ids[0], &ids[0]+18 );
374     }
375     {
376       const int ids[] = {0,5,4,3,2,1,6,11,10,9,8,7};
377       theReverseInterlaces[SMDSEntity_Hexagonal_Prism].assign( &ids[0], &ids[0]+12 );
378     }
379   }
380
381
382   //! indices to set nodes of a quadratic 1D or 2D element in interlaced order
383   static std::vector< std::vector< int > > theQuadInterlace;
384
385   void initQuadInterlace()
386   {
387     theQuadInterlace.resize( SMDSEntity_Last+1 );
388     {
389       const int ids[] = {0,2,1};
390       theQuadInterlace[SMDSEntity_Quad_Edge].assign( &ids[0], &ids[0]+3 );
391     }
392     {
393       const int ids[] = {0,3,1,4,2,5,6};
394       theQuadInterlace[SMDSEntity_Quad_Triangle  ].assign( &ids[0], &ids[0]+6 );
395       theQuadInterlace[SMDSEntity_BiQuad_Triangle].assign( &ids[0], &ids[0]+7 );
396     }
397     {
398       const int ids[] = {0,4,1,5,2,6,3,7,8};
399       theQuadInterlace[SMDSEntity_Quad_Quadrangle  ].assign( &ids[0], &ids[0]+8 );
400       theQuadInterlace[SMDSEntity_BiQuad_Quadrangle].assign( &ids[0], &ids[0]+9 );
401     }
402   }
403
404
405   //! indices to transform cell connectivity from VTK to SMDS
406   static std::vector< std::vector<int> > theFromVtkInterlaces;
407
408   void initFromVtkInterlaces()
409   {
410     theFromVtkInterlaces.resize( SMDSEntity_Last+1 );
411     for ( int iSMDS = 0; iSMDS < SMDSEntity_Last; ++iSMDS )
412     {
413       const std::vector<int> & toVtk = SMDS_MeshCell::toVtkOrder( SMDSAbs_EntityType( iSMDS ));
414       std::vector<int> &      toSmds = theFromVtkInterlaces[ iSMDS ];
415       toSmds.resize( toVtk.size() );
416       for ( size_t i = 0; i < toVtk.size(); ++i )
417         toSmds[ toVtk[i] ] = i;
418     }
419   }
420
421 } // namespace
422
423 void SMDS_MeshCell::InitStaticMembers()
424 {
425   if ( theCellProps.empty() )
426   {
427     initCellProps();
428     initVtkTypes();
429     initToVtkInterlaces();
430     initReverseInterlaces();
431     initQuadInterlace();
432     initFromVtkInterlaces();
433   }
434 }
435
436 void SMDS_MeshCell::init( SMDSAbs_EntityType theEntity, int theNbNodes, ... )
437 {
438   ASSERT( getCellProps( theEntity ).myNbNodes == theNbNodes ||
439           getCellProps( theEntity ).myIsPoly);
440
441   va_list vl;
442   va_start( vl, theNbNodes );
443
444   vtkIdType vtkIds[ VTK_CELL_SIZE ];
445   typedef const SMDS_MeshNode* node_t;
446
447   const std::vector<int>& interlace = toVtkOrder( theEntity );
448   if ((int) interlace.size() == theNbNodes )
449   {
450     const SMDS_MeshNode* nodes[ VTK_CELL_SIZE ];
451     for ( int i = 0; i < theNbNodes; i++ )
452       nodes[i] = va_arg( vl, node_t );
453
454     for ( int i = 0; i < theNbNodes; i++ )
455       vtkIds[i] = nodes[ interlace[i] ]->GetVtkID();
456   }
457   else
458   {
459     for ( int i = 0; i < theNbNodes; i++ )
460       vtkIds[i] = va_arg( vl, node_t )->GetVtkID();
461   }
462   va_end( vl );
463
464   int vtkType = toVtkType( theEntity );
465   int   vtkID = getGrid()->InsertNextLinkedCell( vtkType, theNbNodes, vtkIds );
466   setVtkID( vtkID );
467 }
468
469 void SMDS_MeshCell::init( SMDSAbs_EntityType                       theEntity,
470                           const std::vector<const SMDS_MeshNode*>& nodes )
471 {
472   std::vector< vtkIdType > vtkIds( nodes.size() );
473   for ( size_t i = 0; i < nodes.size(); ++i )
474     vtkIds[i] = nodes[i]->GetVtkID();
475
476   int vtkType = toVtkType( theEntity );
477   int   vtkID = getGrid()->InsertNextLinkedCell( vtkType, nodes.size(), &vtkIds[0] );
478   setVtkID( vtkID );
479 }
480
481 void SMDS_MeshCell::init( SMDSAbs_EntityType            theEntity,
482                           const std::vector<vtkIdType>& vtkNodeIds )
483 {
484   int vtkType = toVtkType( theEntity );
485   int   vtkID = getGrid()->InsertNextLinkedCell( vtkType, vtkNodeIds.size(),
486                                                  const_cast< vtkIdType* > ( &vtkNodeIds[0] ));
487   setVtkID( vtkID );
488 }
489
490 bool SMDS_MeshCell::ChangeNodes(const SMDS_MeshNode* nodes[], const int theNbNodes)
491 {
492   vtkIdType npts = 0;
493   vtkIdType *pts(nullptr);
494   vtkIdType const *tmp(nullptr);
495   getGrid()->GetCellPoints( GetVtkID(), npts, tmp );
496   pts = const_cast<vtkIdType *>(tmp);
497   if ( theNbNodes != npts )
498   {
499     MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << theNbNodes);
500     return false;
501   }
502   const std::vector<int>& interlace = toVtkOrder((VTKCellType) GetVtkType() );
503   if ((int) interlace.size() != theNbNodes )
504     for ( int i = 0; i < theNbNodes; i++ )
505     {
506       pts[i] = nodes[i]->GetVtkID();
507     }
508   else
509     for ( int i = 0; i < theNbNodes; i++ )
510     {
511       pts[i] = nodes[ interlace[i] ]->GetVtkID();
512     }
513
514   return true;
515 }
516
517 ///////////////////////////////////////////////////////////////////////////////
518 ///Return The number of nodes owned by the current element
519 ///////////////////////////////////////////////////////////////////////////////
520 int SMDS_MeshCell::NbNodes() const
521 {
522   if ( GetVtkType() == VTK_POLYHEDRON )
523     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbNodes();
524   vtkIdType npts = getGrid()->GetCells()->GetCellSize( GetVtkID() );
525   return npts;
526 }
527
528 int SMDS_MeshCell::NbFaces() const
529 {
530   if ( GetVtkType() == VTK_POLYHEDRON )
531     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbFaces();
532   return getCellProps( GetVtkType() ).myNbFaces;
533 }
534
535 int SMDS_MeshCell::NbEdges() const
536 {
537   switch ( GetEntityType() )
538   {
539   case SMDSEntity_Polyhedra:
540     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbEdges();
541   case SMDSEntity_Polygon:
542     return NbNodes();
543   case SMDSEntity_Quad_Polygon:
544     return NbNodes() / 2;
545   default:;
546   }
547   return getCellProps( GetVtkType() ).myNbEdges;
548 }
549
550 int SMDS_MeshCell::NbCornerNodes() const
551 {
552   switch ( GetVtkType() )
553   {
554   case VTK_POLYHEDRON:
555     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbCornerNodes();
556   case VTK_POLYGON:
557     return NbNodes();
558   case VTK_QUADRATIC_POLYGON:
559     return NbNodes() / 2;
560   default:;
561   }
562   return getCellProps( GetVtkType() ).myNbCornerNodes;
563 }
564
565 ///////////////////////////////////////////////////////////////////////////////
566 /// Create an iterator which iterate on nodes owned by the element.
567 ///////////////////////////////////////////////////////////////////////////////
568 SMDS_ElemIteratorPtr SMDS_MeshCell::nodesIterator() const
569 {
570   if ( GetVtkType() == VTK_POLYHEDRON )
571     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::nodesIterator();
572
573   return boost::make_shared< SMDS_VtkCellIterator<> >( GetMesh(), GetVtkID(), GetEntityType());
574 }
575
576 ///////////////////////////////////////////////////////////////////////////////
577 /// Create an iterator which iterate on nodes owned by the element.
578 ///////////////////////////////////////////////////////////////////////////////
579 SMDS_NodeIteratorPtr SMDS_MeshCell::nodeIterator() const
580 {
581   if ( GetVtkType() == VTK_POLYHEDRON )
582     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::nodeIterator();
583
584   return SMDS_NodeIteratorPtr
585     (new SMDS_VtkCellIterator<SMDS_NodeIterator>( GetMesh(), GetVtkID(), GetEntityType()));
586 }
587
588 SMDS_NodeIteratorPtr SMDS_MeshCell::interlacedNodesIterator() const
589 {
590   bool canInterlace = ( GetType() == SMDSAbs_Face || GetType() == SMDSAbs_Edge );
591   return canInterlace ? nodesIteratorToUNV() : nodeIterator();
592 }
593
594 SMDS_NodeIteratorPtr SMDS_MeshCell::nodesIteratorToUNV() const
595 {
596   return SMDS_NodeIteratorPtr
597     (new SMDS_VtkCellIteratorToUNV<SMDS_NodeIterator>( GetMesh(), GetVtkID(), GetEntityType()));
598 }
599
600 SMDSAbs_ElementType SMDS_MeshCell::GetType() const
601 {
602   return getCellProps( GetVtkType() ).myType;
603 }
604
605 SMDSAbs_EntityType SMDS_MeshCell::GetEntityType() const
606 {
607   return toSmdsType( (VTKCellType) GetVtkType() );
608 }
609
610 SMDSAbs_GeometryType SMDS_MeshCell::GetGeomType() const
611 {
612   return getCellProps( GetVtkType() ).myGeom;
613 }
614
615 VTKCellType SMDS_MeshCell::GetVtkType() const
616 {
617   return (VTKCellType) getGrid()->GetCellType( GetVtkID() );
618 }
619
620 bool SMDS_MeshCell::IsPoly() const
621 {
622   return getCellProps( GetVtkType() ).myIsPoly;
623 }
624
625 bool SMDS_MeshCell::IsQuadratic() const
626 {
627   return getCellProps( GetVtkType() ).myIsQuadratic;
628 }
629
630 const SMDS_MeshNode* SMDS_MeshCell::GetNode(const int ind) const
631 {
632   if ( GetVtkType() == VTK_POLYHEDRON )
633     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::GetNode( ind );
634
635   vtkIdType npts;
636   vtkIdType const *pts;
637   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
638   const std::vector<int>& interlace = SMDS_MeshCell::fromVtkOrder( VTKCellType( GetVtkType() ));
639   return GetMesh()->FindNodeVtk( pts[ interlace.empty() ? ind : interlace[ ind ]]);
640 }
641
642 int SMDS_MeshCell::GetNodeIndex( const SMDS_MeshNode* node ) const
643 {
644   if ( !node || node->IsNull() )
645     return -1;
646
647   if ( GetVtkType() == VTK_POLYHEDRON )
648     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::GetNodeIndex( node );
649
650   vtkIdType npts;
651   vtkIdType const *pts;
652   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
653   for ( vtkIdType i = 0; i < npts; ++i )
654     if ( pts[i] == node->GetVtkID() )
655     {
656       const std::vector<int>& interlace = SMDS_MeshCell::toVtkOrder( VTKCellType( GetVtkType() ));
657       return interlace.empty() ? i : interlace[i];
658     }
659   return -1;
660 }
661
662 //================================================================================
663 /*!
664  * \brief Return VTKCellType corresponding to SMDSAbs_EntityType
665  */
666 //================================================================================
667
668 VTKCellType SMDS_MeshCell::toVtkType (SMDSAbs_EntityType smdsType)
669 {
670   return theVtkTypes[ smdsType ];
671 }
672
673 //================================================================================
674 /*!
675  * \brief Return indices to transform cell connectivity from SMDS to VTK
676  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
677  */
678 //================================================================================
679
680 const std::vector< int >& SMDS_MeshCell::toVtkOrder(SMDSAbs_EntityType smdsType)
681 {
682   return theToVtkInterlaces[ smdsType ];
683 }
684
685 //================================================================================
686 /*!
687  * \brief Return indices to reverse an SMDS cell of given type.
688  *        nbNodes is useful for polygons
689  * Usage: reverseIDs[i] = forwardIDs[ indices[ i ]]
690  */
691 //================================================================================
692
693 const std::vector<int>& SMDS_MeshCell::reverseSmdsOrder(SMDSAbs_EntityType smdsType,
694                                                         const size_t       nbNodes)
695 {
696   if ( smdsType == SMDSEntity_Polygon )
697   {
698     if ( theReverseInterlaces[ smdsType ].size() != nbNodes )
699     {
700       theReverseInterlaces[ smdsType ].resize( nbNodes );
701       for ( size_t i = 0; i < nbNodes; ++i )
702         theReverseInterlaces[ smdsType ][i] = nbNodes - i - 1;
703     }
704   }
705   else if ( smdsType == SMDSEntity_Quad_Polygon )
706   {
707     if ( theReverseInterlaces[ smdsType ].size() != nbNodes )
708     {
709       // e.g. for 8 nodes: [ 0, 3,2,1, 7,6,5,4 ]
710       theReverseInterlaces[ smdsType ].resize( nbNodes );
711       size_t pos = 0;
712       theReverseInterlaces[ smdsType ][pos++] = 0;
713       for ( int i = nbNodes / 2 - 1; i > 0 ; --i ) // 3,2,1
714         theReverseInterlaces[ smdsType ][pos++] = i;
715       for ( int i = nbNodes - 1, nb = nbNodes / 2; i >= nb; --i ) // 7,6,5,4
716         theReverseInterlaces[ smdsType ][pos++] = i;
717     }
718   }
719
720   return theReverseInterlaces[ smdsType ];
721 }
722
723 //================================================================================
724 /*!
725  * \brief Return indices to set nodes of a quadratic 1D or 2D element in interlaced order
726  * Usage: interlacedIDs[i] = smdsIDs[ indices[ i ]]
727  */
728 //================================================================================
729
730 const std::vector<int>& SMDS_MeshCell::interlacedSmdsOrder(SMDSAbs_EntityType smdsType,
731                                                            const size_t       nbNodes)
732 {
733   if ( smdsType == SMDSEntity_Quad_Polygon )
734   {
735     if ( theQuadInterlace[smdsType].size() != nbNodes )
736     {
737       theQuadInterlace[smdsType].resize( nbNodes );
738       for ( size_t i = 0; i < nbNodes / 2; ++i )
739       {
740         theQuadInterlace[smdsType][i*2+0] = i;
741         theQuadInterlace[smdsType][i*2+1] = i + nbNodes / 2;
742       }
743     }
744   }
745   return theQuadInterlace[smdsType];
746 }
747
748 //================================================================================
749 /*!
750  * \brief Return SMDSAbs_EntityType corresponding to VTKCellType
751  */
752 //================================================================================
753
754 SMDSAbs_EntityType SMDS_MeshCell::toSmdsType(VTKCellType vtkType)
755 {
756   return getCellProps( vtkType ).myEntity;
757 }
758
759 //================================================================================
760 /*!
761  * \brief Return SMDSAbs_ElementType by SMDSAbs_GeometryType
762  */
763 //================================================================================
764
765 SMDSAbs_ElementType SMDS_MeshCell::ElemType(SMDSAbs_GeometryType geomType)
766 {
767   switch ( geomType ) {
768   case SMDSGeom_POINT:     return SMDSAbs_0DElement;
769
770   case SMDSGeom_EDGE:      return SMDSAbs_Edge;
771
772   case SMDSGeom_TRIANGLE:
773   case SMDSGeom_QUADRANGLE:
774   case SMDSGeom_POLYGON:   return SMDSAbs_Face;
775
776   case SMDSGeom_TETRA:
777   case SMDSGeom_PYRAMID:
778   case SMDSGeom_HEXA:
779   case SMDSGeom_PENTA:
780   case SMDSGeom_HEXAGONAL_PRISM:
781   case SMDSGeom_POLYHEDRA: return SMDSAbs_Volume;
782
783   case SMDSGeom_BALL:      return SMDSAbs_Ball;
784
785   case SMDSGeom_NONE: ;
786   }
787   return SMDSAbs_All;
788 }
789
790 //================================================================================
791 /*!
792  * \brief Return SMDSAbs_ElementType by SMDSAbs_EntityType
793  */
794 //================================================================================
795
796 SMDSAbs_ElementType SMDS_MeshCell::ElemType(SMDSAbs_EntityType entityType)
797 {
798   return getCellProps( entityType ).myType;
799 }
800
801 SMDSAbs_GeometryType SMDS_MeshCell::GeomType( SMDSAbs_EntityType entityType )
802 {
803   return getCellProps( entityType ).myGeom;
804 }
805
806 bool SMDS_MeshCell::IsPoly( SMDSAbs_EntityType entityType )
807 {
808   return getCellProps( entityType ).myIsPoly;
809 }
810
811 bool SMDS_MeshCell::IsQuadratic( SMDSAbs_EntityType entityType )
812 {
813   return getCellProps( entityType ).myIsQuadratic;
814 }
815
816 int SMDS_MeshCell::NbCornerNodes( SMDSAbs_EntityType entityType )
817 {
818   return getCellProps( entityType ).myNbCornerNodes;
819 }
820
821 int SMDS_MeshCell::NbNodes( SMDSAbs_EntityType entityType )
822 {
823   return getCellProps( entityType ).myNbNodes;
824 }
825
826 int SMDS_MeshCell::NbEdges( SMDSAbs_EntityType entityType )
827 {
828   return getCellProps( entityType ).myNbEdges;
829 }
830
831 int SMDS_MeshCell::NbFaces( SMDSAbs_EntityType entityType )
832 {
833   return getCellProps( entityType ).myNbFaces;
834 }
835
836 //================================================================================
837 /*!
838  * \brief Return indices to transform cell connectivity from VTK to SMDS
839  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
840  */
841 //================================================================================
842
843 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(SMDSAbs_EntityType smdsType)
844 {
845   return theFromVtkInterlaces[ smdsType ];
846 }
847
848 //================================================================================
849 /*!
850  * \brief Return indices to transform cell connectivity from SMDS to VTK
851  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
852  */
853 //================================================================================
854
855 const std::vector<int>& SMDS_MeshCell::toVtkOrder(VTKCellType vtkType)
856 {
857   return toVtkOrder( toSmdsType( vtkType ));
858 }
859
860 //================================================================================
861 /*!
862  * \brief Return indices to transform cell connectivity from VTK to SMDS
863  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
864  */
865 //================================================================================
866
867 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(VTKCellType vtkType)
868 {
869   return fromVtkOrder( toSmdsType( vtkType ));
870 }