src/SMDS/SMDS_MeshCell.cxx

   1 // Copyright (C) 2010-2019  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 = 0;
 494   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
 495   if ( theNbNodes != npts )
 496   {
 497     MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << theNbNodes);
 498     return false;
 499   }
 500   const std::vector<int>& interlace = toVtkOrder((VTKCellType) GetVtkType() );
 501   if ((int) interlace.size() != theNbNodes )
 502     for ( int i = 0; i < theNbNodes; i++ )
 503     {
 504       pts[i] = nodes[i]->GetVtkID();
 505     }
 506   else
 507     for ( int i = 0; i < theNbNodes; i++ )
 508     {
 509       pts[i] = nodes[ interlace[i] ]->GetVtkID();
 510     }
 511
 512   return true;
 513 }
 514
 515 ///////////////////////////////////////////////////////////////////////////////
 516 ///Return The number of nodes owned by the current element
 517 ///////////////////////////////////////////////////////////////////////////////
 518 int SMDS_MeshCell::NbNodes() const
 519 {
 520   if ( GetVtkType() == VTK_POLYHEDRON )
 521     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbNodes();
 522   vtkIdType *pts, npts;
 523   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
 524   return npts;
 525 }
 526
 527 int SMDS_MeshCell::NbFaces() const
 528 {
 529   if ( GetVtkType() == VTK_POLYHEDRON )
 530     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbFaces();
 531   return getCellProps( GetVtkType() ).myNbFaces;
 532 }
 533
 534 int SMDS_MeshCell::NbEdges() const
 535 {
 536   switch ( GetEntityType() )
 537   {
 538   case SMDSEntity_Polyhedra:
 539     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbEdges();
 540   case SMDSEntity_Polygon:
 541     return NbNodes();
 542   case SMDSEntity_Quad_Polygon:
 543     return NbNodes() / 2;
 544   default:;
 545   }
 546   return getCellProps( GetVtkType() ).myNbEdges;
 547 }
 548
 549 int SMDS_MeshCell::NbCornerNodes() const
 550 {
 551   switch ( GetVtkType() )
 552   {
 553   case VTK_POLYHEDRON:
 554     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::NbCornerNodes();
 555   case VTK_POLYGON:
 556     return NbNodes();
 557   case VTK_QUADRATIC_POLYGON:
 558     return NbNodes() / 2;
 559   default:;
 560   }
 561   return getCellProps( GetVtkType() ).myNbCornerNodes;
 562 }
 563
 564 ///////////////////////////////////////////////////////////////////////////////
 565 /// Create an iterator which iterate on nodes owned by the element.
 566 ///////////////////////////////////////////////////////////////////////////////
 567 SMDS_ElemIteratorPtr SMDS_MeshCell::nodesIterator() const
 568 {
 569   if ( GetVtkType() == VTK_POLYHEDRON )
 570     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::nodesIterator();
 571
 572   return boost::make_shared< SMDS_VtkCellIterator<> >( GetMesh(), GetVtkID(), GetEntityType());
 573 }
 574
 575 ///////////////////////////////////////////////////////////////////////////////
 576 /// Create an iterator which iterate on nodes owned by the element.
 577 ///////////////////////////////////////////////////////////////////////////////
 578 SMDS_NodeIteratorPtr SMDS_MeshCell::nodeIterator() const
 579 {
 580   if ( GetVtkType() == VTK_POLYHEDRON )
 581     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::nodeIterator();
 582
 583   return SMDS_NodeIteratorPtr
 584     (new SMDS_VtkCellIterator<SMDS_NodeIterator>( GetMesh(), GetVtkID(), GetEntityType()));
 585 }
 586
 587 SMDS_NodeIteratorPtr SMDS_MeshCell::interlacedNodesIterator() const
 588 {
 589   bool canInterlace = ( GetType() == SMDSAbs_Face || GetType() == SMDSAbs_Edge );
 590   return canInterlace ? nodesIteratorToUNV() : nodeIterator();
 591 }
 592
 593 SMDS_NodeIteratorPtr SMDS_MeshCell::nodesIteratorToUNV() const
 594 {
 595   return SMDS_NodeIteratorPtr
 596     (new SMDS_VtkCellIteratorToUNV<SMDS_NodeIterator>( GetMesh(), GetVtkID(), GetEntityType()));
 597 }
 598
 599 SMDSAbs_ElementType SMDS_MeshCell::GetType() const
 600 {
 601   return getCellProps( GetVtkType() ).myType;
 602 }
 603
 604 SMDSAbs_EntityType SMDS_MeshCell::GetEntityType() const
 605 {
 606   return toSmdsType( (VTKCellType) GetVtkType() );
 607 }
 608
 609 SMDSAbs_GeometryType SMDS_MeshCell::GetGeomType() const
 610 {
 611   return getCellProps( GetVtkType() ).myGeom;
 612 }
 613
 614 VTKCellType SMDS_MeshCell::GetVtkType() const
 615 {
 616   return (VTKCellType) getGrid()->GetCellType( GetVtkID() );
 617 }
 618
 619 bool SMDS_MeshCell::IsPoly() const
 620 {
 621   return getCellProps( GetVtkType() ).myIsPoly;
 622 }
 623
 624 bool SMDS_MeshCell::IsQuadratic() const
 625 {
 626   return getCellProps( GetVtkType() ).myIsQuadratic;
 627 }
 628
 629 const SMDS_MeshNode* SMDS_MeshCell::GetNode(const int ind) const
 630 {
 631   if ( GetVtkType() == VTK_POLYHEDRON )
 632     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::GetNode( ind );
 633
 634   vtkIdType npts, *pts;
 635   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
 636   const std::vector<int>& interlace = SMDS_MeshCell::fromVtkOrder( VTKCellType( GetVtkType() ));
 637   return GetMesh()->FindNodeVtk( pts[ interlace.empty() ? ind : interlace[ ind ]]);
 638 }
 639
 640 int SMDS_MeshCell::GetNodeIndex( const SMDS_MeshNode* node ) const
 641 {
 642   if ( !node || node->IsNull() )
 643     return -1;
 644
 645   if ( GetVtkType() == VTK_POLYHEDRON )
 646     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::GetNodeIndex( node );
 647
 648   vtkIdType npts, *pts;
 649   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
 650   for ( vtkIdType i = 0; i < npts; ++i )
 651     if ( pts[i] == node->GetVtkID() )
 652     {
 653       const std::vector<int>& interlace = SMDS_MeshCell::toVtkOrder( VTKCellType( GetVtkType() ));
 654       return interlace.empty() ? i : interlace[i];
 655     }
 656   return -1;
 657 }
 658
 659 //================================================================================
 660 /*!
 661  * \brief Return VTKCellType corresponding to SMDSAbs_EntityType
 662  */
 663 //================================================================================
 664
 665 VTKCellType SMDS_MeshCell::toVtkType (SMDSAbs_EntityType smdsType)
 666 {
 667   return theVtkTypes[ smdsType ];
 668 }
 669
 670 //================================================================================
 671 /*!
 672  * \brief Return indices to transform cell connectivity from SMDS to VTK
 673  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
 674  */
 675 //================================================================================
 676
 677 const std::vector< int >& SMDS_MeshCell::toVtkOrder(SMDSAbs_EntityType smdsType)
 678 {
 679   return theToVtkInterlaces[ smdsType ];
 680 }
 681
 682 //================================================================================
 683 /*!
 684  * \brief Return indices to reverse an SMDS cell of given type.
 685  *        nbNodes is useful for polygons
 686  * Usage: reverseIDs[i] = forwardIDs[ indices[ i ]]
 687  */
 688 //================================================================================
 689
 690 const std::vector<int>& SMDS_MeshCell::reverseSmdsOrder(SMDSAbs_EntityType smdsType,
 691                                                         const size_t       nbNodes)
 692 {
 693   if ( smdsType == SMDSEntity_Polygon )
 694   {
 695     if ( theReverseInterlaces[ smdsType ].size() != nbNodes )
 696     {
 697       theReverseInterlaces[ smdsType ].resize( nbNodes );
 698       for ( size_t i = 0; i < nbNodes; ++i )
 699         theReverseInterlaces[ smdsType ][i] = nbNodes - i - 1;
 700     }
 701   }
 702   else if ( smdsType == SMDSEntity_Quad_Polygon )
 703   {
 704     if ( theReverseInterlaces[ smdsType ].size() != nbNodes )
 705     {
 706       // e.g. for 8 nodes: [ 0, 3,2,1, 7,6,5,4 ]
 707       theReverseInterlaces[ smdsType ].resize( nbNodes );
 708       size_t pos = 0;
 709       theReverseInterlaces[ smdsType ][pos++] = 0;
 710       for ( int i = nbNodes / 2 - 1; i > 0 ; --i ) // 3,2,1
 711         theReverseInterlaces[ smdsType ][pos++] = i;
 712       for ( int i = nbNodes - 1, nb = nbNodes / 2; i >= nb; --i ) // 7,6,5,4
 713         theReverseInterlaces[ smdsType ][pos++] = i;
 714     }
 715   }
 716
 717   return theReverseInterlaces[ smdsType ];
 718 }
 719
 720 //================================================================================
 721 /*!
 722  * \brief Return indices to set nodes of a quadratic 1D or 2D element in interlaced order
 723  * Usage: interlacedIDs[i] = smdsIDs[ indices[ i ]]
 724  */
 725 //================================================================================
 726
 727 const std::vector<int>& SMDS_MeshCell::interlacedSmdsOrder(SMDSAbs_EntityType smdsType,
 728                                                            const size_t       nbNodes)
 729 {
 730   if ( smdsType == SMDSEntity_Quad_Polygon )
 731   {
 732     if ( theQuadInterlace[smdsType].size() != nbNodes )
 733     {
 734       theQuadInterlace[smdsType].resize( nbNodes );
 735       for ( size_t i = 0; i < nbNodes / 2; ++i )
 736       {
 737         theQuadInterlace[smdsType][i*2+0] = i;
 738         theQuadInterlace[smdsType][i*2+1] = i + nbNodes / 2;
 739       }
 740     }
 741   }
 742   return theQuadInterlace[smdsType];
 743 }
 744
 745 //================================================================================
 746 /*!
 747  * \brief Return SMDSAbs_EntityType corresponding to VTKCellType
 748  */
 749 //================================================================================
 750
 751 SMDSAbs_EntityType SMDS_MeshCell::toSmdsType(VTKCellType vtkType)
 752 {
 753   return getCellProps( vtkType ).myEntity;
 754 }
 755
 756 //================================================================================
 757 /*!
 758  * \brief Return SMDSAbs_ElementType by SMDSAbs_GeometryType
 759  */
 760 //================================================================================
 761
 762 SMDSAbs_ElementType SMDS_MeshCell::ElemType(SMDSAbs_GeometryType geomType)
 763 {
 764   switch ( geomType ) {
 765   case SMDSGeom_POINT:     return SMDSAbs_0DElement;
 766
 767   case SMDSGeom_EDGE:      return SMDSAbs_Edge;
 768
 769   case SMDSGeom_TRIANGLE:
 770   case SMDSGeom_QUADRANGLE:
 771   case SMDSGeom_POLYGON:   return SMDSAbs_Face;
 772
 773   case SMDSGeom_TETRA:
 774   case SMDSGeom_PYRAMID:
 775   case SMDSGeom_HEXA:
 776   case SMDSGeom_PENTA:
 777   case SMDSGeom_HEXAGONAL_PRISM:
 778   case SMDSGeom_POLYHEDRA: return SMDSAbs_Volume;
 779
 780   case SMDSGeom_BALL:      return SMDSAbs_Ball;
 781
 782   case SMDSGeom_NONE: ;
 783   }
 784   return SMDSAbs_All;
 785 }
 786
 787 //================================================================================
 788 /*!
 789  * \brief Return SMDSAbs_ElementType by SMDSAbs_EntityType
 790  */
 791 //================================================================================
 792
 793 SMDSAbs_ElementType SMDS_MeshCell::ElemType(SMDSAbs_EntityType entityType)
 794 {
 795   return getCellProps( entityType ).myType;
 796 }
 797
 798 SMDSAbs_GeometryType SMDS_MeshCell::GeomType( SMDSAbs_EntityType entityType )
 799 {
 800   return getCellProps( entityType ).myGeom;
 801 }
 802
 803 bool SMDS_MeshCell::IsPoly( SMDSAbs_EntityType entityType )
 804 {
 805   return getCellProps( entityType ).myIsPoly;
 806 }
 807
 808 bool SMDS_MeshCell::IsQuadratic( SMDSAbs_EntityType entityType )
 809 {
 810   return getCellProps( entityType ).myIsQuadratic;
 811 }
 812
 813 int SMDS_MeshCell::NbCornerNodes( SMDSAbs_EntityType entityType )
 814 {
 815   return getCellProps( entityType ).myNbCornerNodes;
 816 }
 817
 818 int SMDS_MeshCell::NbNodes( SMDSAbs_EntityType entityType )
 819 {
 820   return getCellProps( entityType ).myNbNodes;
 821 }
 822
 823 int SMDS_MeshCell::NbEdges( SMDSAbs_EntityType entityType )
 824 {
 825   return getCellProps( entityType ).myNbEdges;
 826 }
 827
 828 int SMDS_MeshCell::NbFaces( SMDSAbs_EntityType entityType )
 829 {
 830   return getCellProps( entityType ).myNbFaces;
 831 }
 832
 833 //================================================================================
 834 /*!
 835  * \brief Return indices to transform cell connectivity from VTK to SMDS
 836  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
 837  */
 838 //================================================================================
 839
 840 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(SMDSAbs_EntityType smdsType)
 841 {
 842   return theFromVtkInterlaces[ smdsType ];
 843 }
 844
 845 //================================================================================
 846 /*!
 847  * \brief Return indices to transform cell connectivity from SMDS to VTK
 848  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
 849  */
 850 //================================================================================
 851
 852 const std::vector<int>& SMDS_MeshCell::toVtkOrder(VTKCellType vtkType)
 853 {
 854   return toVtkOrder( toSmdsType( vtkType ));
 855 }
 856
 857 //================================================================================
 858 /*!
 859  * \brief Return indices to transform cell connectivity from VTK to SMDS
 860  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
 861  */
 862 //================================================================================
 863
 864 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(VTKCellType vtkType)
 865 {
 866   return fromVtkOrder( toSmdsType( vtkType ));
 867 }