]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_MeshCell.cxx
Salome HOME
Fix
[modules/smesh.git] / src / SMDS / SMDS_MeshCell.cxx
1 // Copyright (C) 2010-2013  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.
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 #include "utilities.h"
22
23 int SMDS_MeshCell::nbCells = 0;
24
25 SMDS_MeshCell::SMDS_MeshCell() :
26   SMDS_MeshElement(-1)
27 {
28   nbCells++;
29   myVtkID = -1;
30 }
31
32 SMDS_MeshCell::~SMDS_MeshCell()
33 {
34   nbCells--;
35 }
36 //================================================================================
37 /*!
38  * \brief Return VTKCellType corresponding to SMDSAbs_EntityType
39  */
40 //================================================================================
41
42 VTKCellType SMDS_MeshCell::toVtkType (SMDSAbs_EntityType smdsType)
43 {
44   static std::vector< VTKCellType > vtkTypes;
45   if ( vtkTypes.empty() )
46   {
47     vtkTypes.resize( SMDSEntity_Last+1, VTK_EMPTY_CELL );
48     vtkTypes[ SMDSEntity_Node ]              = VTK_VERTEX;
49     vtkTypes[ SMDSEntity_0D ]                = VTK_VERTEX;
50     vtkTypes[ SMDSEntity_Edge ]              = VTK_LINE;
51     vtkTypes[ SMDSEntity_Quad_Edge ]         = VTK_QUADRATIC_EDGE;
52     vtkTypes[ SMDSEntity_Triangle ]          = VTK_TRIANGLE;
53     vtkTypes[ SMDSEntity_Quad_Triangle ]     = VTK_QUADRATIC_TRIANGLE;
54     vtkTypes[ SMDSEntity_BiQuad_Triangle ]   = VTK_BIQUADRATIC_TRIANGLE;
55     vtkTypes[ SMDSEntity_Quadrangle ]        = VTK_QUAD;
56     vtkTypes[ SMDSEntity_Quad_Quadrangle ]   = VTK_QUADRATIC_QUAD;
57     vtkTypes[ SMDSEntity_BiQuad_Quadrangle ] = VTK_BIQUADRATIC_QUAD;
58     vtkTypes[ SMDSEntity_Polygon ]           = VTK_POLYGON;
59     //vtkTypes[ SMDSEntity_Quad_Polygon ]      = ;
60     vtkTypes[ SMDSEntity_Tetra ]             = VTK_TETRA;
61     vtkTypes[ SMDSEntity_Quad_Tetra ]        = VTK_QUADRATIC_TETRA;
62     vtkTypes[ SMDSEntity_Pyramid ]           = VTK_PYRAMID;
63     vtkTypes[ SMDSEntity_Quad_Pyramid ]      = VTK_QUADRATIC_PYRAMID;
64     vtkTypes[ SMDSEntity_Hexa ]              = VTK_HEXAHEDRON;
65     vtkTypes[ SMDSEntity_Quad_Hexa ]         = VTK_QUADRATIC_HEXAHEDRON;
66     vtkTypes[ SMDSEntity_TriQuad_Hexa ]      = VTK_TRIQUADRATIC_HEXAHEDRON;
67     vtkTypes[ SMDSEntity_Penta ]             = VTK_WEDGE;
68     vtkTypes[ SMDSEntity_Quad_Penta ]        = VTK_QUADRATIC_WEDGE;
69     vtkTypes[ SMDSEntity_Hexagonal_Prism ]   = VTK_HEXAGONAL_PRISM;
70     vtkTypes[ SMDSEntity_Polyhedra ]         = VTK_POLYHEDRON;
71     //vtkTypes[ SMDSEntity_Quad_Polyhedra ]    = ;
72     vtkTypes[ SMDSEntity_Ball ]              = VTK_POLY_VERTEX;
73   }
74   return vtkTypes[ smdsType ];
75 }
76
77 //================================================================================
78 /*!
79  * \brief Return indices to transform cell connectivity from SMDS to VTK
80  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
81  */
82 //================================================================================
83
84 const std::vector< int >& SMDS_MeshCell::toVtkOrder(SMDSAbs_EntityType smdsType)
85 {
86   static std::vector< std::vector< int > > toVtkInterlaces;
87   if ( toVtkInterlaces.empty() )
88   {
89     toVtkInterlaces.resize( SMDSEntity_Last+1 );
90     // {
91     //   const int ids[] = {0};
92     //   toVtkInterlaces[SMDSEntity_0D].assign( &ids[0], &ids[0]+1 );
93     //   toVtkInterlaces[SMDSEntity_Node].assign( &ids[0], &ids[0]+1 );
94     // }
95     // {
96     //   const int ids[] = {0,1};
97     //   toVtkInterlaces[SMDSEntity_Edge].assign( &ids[0], &ids[0]+2 );
98     // }
99     // {
100     //   const int ids[] = {0,1,2};
101     //   toVtkInterlaces[SMDSEntity_Quad_Edge].assign( &ids[0], &ids[0]+3 );
102     // }
103     // {
104     //   const int ids[] = {0,1,2};
105     //   toVtkInterlaces[SMDSEntity_Triangle].assign( &ids[0], &ids[0]+3 );
106     // }
107     // {
108     //   const int ids[] = {0,1,2,3,4,5};
109     //   toVtkInterlaces[SMDSEntity_Quad_Triangle].assign( &ids[0], &ids[0]+6 );
110     // }
111     // {
112     //   const int ids[] = {0,1,2,3};
113     //   toVtkInterlaces[SMDSEntity_Quadrangle].assign( &ids[0], &ids[0]+4 );
114     // }
115     // {
116     //   const int ids[] = {0,1,2,3,4,5,6,7};
117     //   toVtkInterlaces[SMDSEntity_Quad_Quadrangle].assign( &ids[0], &ids[0]+8 );
118     // }
119     // {
120     //   const int ids[] = {0,1,2,3,4,5,6,7,8};
121     //   toVtkInterlaces[SMDSEntity_BiQuad_Quadrangle].assign( &ids[0], &ids[0]+9 );
122     // }
123     {
124       const int ids[] = {0,2,1,3};
125       toVtkInterlaces[SMDSEntity_Tetra].assign( &ids[0], &ids[0]+4 );
126     }
127     {
128       const int ids[] = {0,2,1,3,6,5,4,7,9,8};
129       toVtkInterlaces[SMDSEntity_Quad_Tetra].assign( &ids[0], &ids[0]+10 );
130     }
131     {
132       const int ids[] = {0,3,2,1,4};
133       toVtkInterlaces[SMDSEntity_Pyramid].assign( &ids[0], &ids[0]+5 );
134     }
135     {
136       const int ids[] = {0,3,2,1,4,8,7,6,5,9,12,11,10};
137       toVtkInterlaces[SMDSEntity_Quad_Pyramid].assign( &ids[0], &ids[0]+13 );
138     }
139     {
140       const int ids[] = {0,3,2,1,4,7,6,5};
141       toVtkInterlaces[SMDSEntity_Hexa].assign( &ids[0], &ids[0]+8 );
142     }
143     {
144       const int ids[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17};
145       toVtkInterlaces[SMDSEntity_Quad_Hexa].assign( &ids[0], &ids[0]+20 );
146     }
147     {
148       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};
149       toVtkInterlaces[SMDSEntity_TriQuad_Hexa].assign( &ids[0], &ids[0]+27 );
150     }
151     {
152       const int ids[] = {0,1,2,3,4,5};
153       toVtkInterlaces[SMDSEntity_Penta].assign( &ids[0], &ids[0]+6 );
154     }
155     {
156       const int ids[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
157       toVtkInterlaces[SMDSEntity_Quad_Penta].assign( &ids[0], &ids[0]+15 );
158     }
159     {
160       const int ids[] = {0,5,4,3,2,1,6,11,10,9,8,7};
161       toVtkInterlaces[SMDSEntity_Hexagonal_Prism].assign( &ids[0], &ids[0]+12 );
162     }
163   }
164   return toVtkInterlaces[smdsType];
165 }
166
167 //================================================================================
168 /*!
169  * \brief Return indices to reverse an SMDS cell of given type
170  * Usage: reverseIDs[i] = forwardIDs[ indices[ i ]]
171  */
172 //================================================================================
173
174 const std::vector<int>& SMDS_MeshCell::reverseSmdsOrder(SMDSAbs_EntityType smdsType)
175 {
176   static std::vector< std::vector< int > > reverseInterlaces;
177   if ( reverseInterlaces.empty() )
178   {
179     reverseInterlaces.resize( SMDSEntity_Last+1 );
180     {
181       const int ids[] = {0};
182       reverseInterlaces[SMDSEntity_0D].assign( &ids[0], &ids[0]+1 );
183       reverseInterlaces[SMDSEntity_Node].assign( &ids[0], &ids[0]+1 );
184       reverseInterlaces[SMDSEntity_Ball].assign( &ids[0], &ids[0]+1 );
185     }
186     {
187       const int ids[] = {1,0};
188       reverseInterlaces[SMDSEntity_Edge].assign( &ids[0], &ids[0]+2 );
189     }
190     {
191       const int ids[] = {1,0,2};
192       reverseInterlaces[SMDSEntity_Quad_Edge].assign( &ids[0], &ids[0]+3 );
193     }
194     {
195       const int ids[] = {0,2,1};
196       reverseInterlaces[SMDSEntity_Triangle].assign( &ids[0], &ids[0]+3 );
197     }
198     {
199       const int ids[] = {0,2,1,5,4,3};
200       reverseInterlaces[SMDSEntity_Quad_Triangle].assign( &ids[0], &ids[0]+6 );
201     }
202     {
203       const int ids[] = {0,2,1,5,4,3,6};
204       reverseInterlaces[SMDSEntity_BiQuad_Triangle].assign( &ids[0], &ids[0]+7 );
205     }
206     {
207       const int ids[] = {0,3,2,1};
208       reverseInterlaces[SMDSEntity_Quadrangle].assign( &ids[0], &ids[0]+4 );
209     }
210     {
211       const int ids[] = {0,3,2,1,7,6,5,4};
212       reverseInterlaces[SMDSEntity_Quad_Quadrangle].assign( &ids[0], &ids[0]+8 );
213     }
214     {
215       const int ids[] = {0,3,2,1,7,6,5,4,8};
216       reverseInterlaces[SMDSEntity_BiQuad_Quadrangle].assign( &ids[0], &ids[0]+9 );
217     }
218     {
219       const int ids[] = {0,2,1,3};
220       reverseInterlaces[SMDSEntity_Tetra].assign( &ids[0], &ids[0]+4 );
221     }
222     {
223       const int ids[] = {0,2,1,3,6,5,4,7,9,8};
224       reverseInterlaces[SMDSEntity_Quad_Tetra].assign( &ids[0], &ids[0]+10 );
225     }
226     {
227       const int ids[] = {0,3,2,1,4};
228       reverseInterlaces[SMDSEntity_Pyramid].assign( &ids[0], &ids[0]+5 );
229     }
230     {
231       const int ids[] = {0,3,2,1,4,8,7,6,5,9,12,11,10};
232       reverseInterlaces[SMDSEntity_Quad_Pyramid].assign( &ids[0], &ids[0]+13 );
233     }
234     {
235       const int ids[] = {0,3,2,1,4,7,6,5};
236       reverseInterlaces[SMDSEntity_Hexa].assign( &ids[0], &ids[0]+8 );
237     }
238     {
239       const int ids[] = {0,3,2,1,4,7,6,5,11,10,9,8,15,14,13,12,16,19,18,17};
240       reverseInterlaces[SMDSEntity_Quad_Hexa].assign( &ids[0], &ids[0]+20 );
241     }
242     {
243       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};
244       reverseInterlaces[SMDSEntity_TriQuad_Hexa].assign( &ids[0], &ids[0]+27 );
245     }
246     {
247       const int ids[] = {0,2,1,3,5,4};
248       reverseInterlaces[SMDSEntity_Penta].assign( &ids[0], &ids[0]+6 );
249     }
250     {
251       const int ids[] = {0,2,1,3,5,4, 8,7,6,11,10,9,12,14,13};
252       reverseInterlaces[SMDSEntity_Quad_Penta].assign( &ids[0], &ids[0]+15 );
253     }
254     {
255       const int ids[] = {0,5,4,3,2,1,6,11,10,9,8,7};
256       reverseInterlaces[SMDSEntity_Hexagonal_Prism].assign( &ids[0], &ids[0]+12 );
257     }
258   }
259   return reverseInterlaces[smdsType];
260 }
261
262 //================================================================================
263 /*!
264  * \brief Return indices to set nodes of a quadratic 1D or 2D element in interlaced order
265  * Usage: interlacedIDs[i] = smdsIDs[ indices[ i ]]
266  */
267 //================================================================================
268
269 const std::vector<int>& SMDS_MeshCell::interlacedSmdsOrder(SMDSAbs_EntityType smdsType)
270 {
271   static std::vector< std::vector< int > > interlace;
272   if ( interlace.empty() )
273   {
274     interlace.resize( SMDSEntity_Last+1 );
275     {
276       const int ids[] = {0,2,1};
277       interlace[SMDSEntity_Quad_Edge].assign( &ids[0], &ids[0]+3 );
278     }
279     {
280       const int ids[] = {0,3,1,4,2,5,6};
281       interlace[SMDSEntity_Quad_Triangle].assign( &ids[0], &ids[0]+6 );
282       interlace[SMDSEntity_BiQuad_Triangle].assign( &ids[0], &ids[0]+7 );
283     }
284     {
285       const int ids[] = {0,4,1,5,2,6,3,7,8};
286       interlace[SMDSEntity_Quad_Quadrangle].assign( &ids[0], &ids[0]+8 );
287       interlace[SMDSEntity_BiQuad_Quadrangle].assign( &ids[0], &ids[0]+9 );
288     }
289   }
290   return interlace[smdsType];
291 }
292
293 //================================================================================
294 /*!
295  * \brief Return SMDSAbs_EntityType corresponding to VTKCellType
296  */
297 //================================================================================
298
299 SMDSAbs_EntityType SMDS_MeshCell::toSmdsType(VTKCellType vtkType)
300 {
301   static std::vector< SMDSAbs_EntityType > smdsTypes;
302   if ( smdsTypes.empty() )
303   {
304     smdsTypes.resize( VTK_NUMBER_OF_CELL_TYPES, SMDSEntity_Last );
305     for ( int iSMDS = 0; iSMDS < SMDSEntity_Last; ++iSMDS )
306       smdsTypes[ toVtkType( SMDSAbs_EntityType( iSMDS ))] = SMDSAbs_EntityType( iSMDS );
307   }
308   return smdsTypes[ vtkType ];
309 }
310
311 //================================================================================
312 /*!
313  * \brief Return SMDSAbs_ElementType by SMDSAbs_GeometryType
314  */
315 //================================================================================
316
317 SMDSAbs_ElementType SMDS_MeshCell::toSmdsType(SMDSAbs_GeometryType geomType)
318 {
319   switch ( geomType ) {
320   case SMDSGeom_POINT:     return SMDSAbs_0DElement;
321
322   case SMDSGeom_EDGE:      return SMDSAbs_Edge; 
323
324   case SMDSGeom_TRIANGLE:
325   case SMDSGeom_QUADRANGLE:
326   case SMDSGeom_POLYGON:   return SMDSAbs_Face;
327
328   case SMDSGeom_TETRA:
329   case SMDSGeom_PYRAMID:
330   case SMDSGeom_HEXA:
331   case SMDSGeom_PENTA:
332   case SMDSGeom_HEXAGONAL_PRISM:
333   case SMDSGeom_POLYHEDRA: return SMDSAbs_Volume;
334
335   case SMDSGeom_BALL:      return SMDSAbs_Ball;
336
337   case SMDSGeom_NONE: ;
338   }
339   return SMDSAbs_All;
340 }
341
342 //================================================================================
343 /*!
344  * \brief Return SMDSAbs_ElementType by SMDSAbs_EntityType
345  */
346 //================================================================================
347
348 SMDSAbs_ElementType SMDS_MeshCell::toSmdsType(SMDSAbs_EntityType entityType)
349 {
350   switch ( entityType ) {
351   case SMDSEntity_Node:           return SMDSAbs_Node;
352
353   case SMDSEntity_0D:             return SMDSAbs_0DElement;
354
355   case SMDSEntity_Edge:
356   case SMDSEntity_Quad_Edge:      return SMDSAbs_Edge;
357
358   case SMDSEntity_Triangle:
359   case SMDSEntity_Quad_Triangle:
360   case SMDSEntity_BiQuad_Triangle:
361   case SMDSEntity_Quadrangle:
362   case SMDSEntity_Quad_Quadrangle:
363   case SMDSEntity_BiQuad_Quadrangle:
364   case SMDSEntity_Polygon:
365   case SMDSEntity_Quad_Polygon:   return SMDSAbs_Face;
366
367   case SMDSEntity_Tetra:
368   case SMDSEntity_Quad_Tetra:
369   case SMDSEntity_Pyramid:
370   case SMDSEntity_Quad_Pyramid:
371   case SMDSEntity_Hexa:
372   case SMDSEntity_Quad_Hexa:
373   case SMDSEntity_TriQuad_Hexa:
374   case SMDSEntity_Penta:
375   case SMDSEntity_Quad_Penta:
376   case SMDSEntity_Hexagonal_Prism:
377   case SMDSEntity_Polyhedra:
378   case SMDSEntity_Quad_Polyhedra: return SMDSAbs_Volume;
379
380   case SMDSEntity_Ball:           return SMDSAbs_Ball;
381
382   case SMDSEntity_Last:;
383   }
384   return SMDSAbs_All;
385 }
386
387
388 //================================================================================
389 /*!
390  * \brief Return indices to transform cell connectivity from VTK to SMDS
391  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
392  */
393 //================================================================================
394
395 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(SMDSAbs_EntityType smdsType)
396 {
397   static std::vector< std::vector<int> > fromVtkInterlaces;
398   if ( fromVtkInterlaces.empty() )
399   {
400     fromVtkInterlaces.resize( SMDSEntity_Last+1 );
401     for ( int iSMDS = 0; iSMDS < SMDSEntity_Last; ++iSMDS )
402     {
403       const std::vector<int> & toVtk = toVtkOrder( SMDSAbs_EntityType( iSMDS ));
404       std::vector<int> &      toSmds = fromVtkInterlaces[ iSMDS ];
405       toSmds.resize( toVtk.size() );
406       for ( size_t i = 0; i < toVtk.size(); ++i )
407         toSmds[ toVtk[i] ] = i;
408     }
409   }
410   return fromVtkInterlaces[ smdsType ];
411 }
412
413 //================================================================================
414 /*!
415  * \brief Return indices to transform cell connectivity from SMDS to VTK
416  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
417  */
418 //================================================================================
419
420 const std::vector<int>& SMDS_MeshCell::toVtkOrder(VTKCellType vtkType)
421 {
422   return toVtkOrder( toSmdsType( vtkType ));
423 }
424
425 //================================================================================
426 /*!
427  * \brief Return indices to transform cell connectivity from VTK to SMDS
428  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
429  */
430 //================================================================================
431
432 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(VTKCellType vtkType)
433 {
434   return fromVtkOrder( toSmdsType( vtkType ));
435 }