src/SMDS/SMDS_MeshCell.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_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 ( GetVtkType() == VTK_POLYHEDRON )
 643     return static_cast< const SMDS_MeshVolume* >( this )->SMDS_MeshVolume::GetNodeIndex( node );
 644
 645   vtkIdType npts, *pts;
 646   getGrid()->GetCellPoints( GetVtkID(), npts, pts );
 647   for ( vtkIdType i = 0; i < npts; ++i )
 648     if ( pts[i] == node->GetVtkID() )
 649     {
 650       const std::vector<int>& interlace = SMDS_MeshCell::toVtkOrder( VTKCellType( GetVtkType() ));
 651       return interlace.empty() ? i : interlace[i];
 652     }
 653   return -1;
 654 }
 655
 656 //================================================================================
 657 /*!
 658  * \brief Return VTKCellType corresponding to SMDSAbs_EntityType
 659  */
 660 //================================================================================
 661
 662 VTKCellType SMDS_MeshCell::toVtkType (SMDSAbs_EntityType smdsType)
 663 {
 664   return theVtkTypes[ smdsType ];
 665 }
 666
 667 //================================================================================
 668 /*!
 669  * \brief Return indices to transform cell connectivity from SMDS to VTK
 670  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
 671  */
 672 //================================================================================
 673
 674 const std::vector< int >& SMDS_MeshCell::toVtkOrder(SMDSAbs_EntityType smdsType)
 675 {
 676   return theToVtkInterlaces[ smdsType ];
 677 }
 678
 679 //================================================================================
 680 /*!
 681  * \brief Return indices to reverse an SMDS cell of given type.
 682  *        nbNodes is useful for polygons
 683  * Usage: reverseIDs[i] = forwardIDs[ indices[ i ]]
 684  */
 685 //================================================================================
 686
 687 const std::vector<int>& SMDS_MeshCell::reverseSmdsOrder(SMDSAbs_EntityType smdsType,
 688                                                         const size_t       nbNodes)
 689 {
 690   if ( smdsType == SMDSEntity_Polygon )
 691   {
 692     if ( theReverseInterlaces[ smdsType ].size() != nbNodes )
 693     {
 694       theReverseInterlaces[ smdsType ].resize( nbNodes );
 695       for ( size_t i = 0; i < nbNodes; ++i )
 696         theReverseInterlaces[ smdsType ][i] = nbNodes - i - 1;
 697     }
 698   }
 699   else if ( smdsType == SMDSEntity_Quad_Polygon )
 700   {
 701     if ( theReverseInterlaces[ smdsType ].size() != nbNodes )
 702     {
 703       // e.g. for 8 nodes: [ 0, 3,2,1, 7,6,5,4 ]
 704       theReverseInterlaces[ smdsType ].resize( nbNodes );
 705       size_t pos = 0;
 706       theReverseInterlaces[ smdsType ][pos++] = 0;
 707       for ( int i = nbNodes / 2 - 1; i > 0 ; --i ) // 3,2,1
 708         theReverseInterlaces[ smdsType ][pos++] = i;
 709       for ( int i = nbNodes - 1, nb = nbNodes / 2; i >= nb; --i ) // 7,6,5,4
 710         theReverseInterlaces[ smdsType ][pos++] = i;
 711     }
 712   }
 713
 714   return theReverseInterlaces[ smdsType ];
 715 }
 716
 717 //================================================================================
 718 /*!
 719  * \brief Return indices to set nodes of a quadratic 1D or 2D element in interlaced order
 720  * Usage: interlacedIDs[i] = smdsIDs[ indices[ i ]]
 721  */
 722 //================================================================================
 723
 724 const std::vector<int>& SMDS_MeshCell::interlacedSmdsOrder(SMDSAbs_EntityType smdsType,
 725                                                            const size_t       nbNodes)
 726 {
 727   if ( smdsType == SMDSEntity_Quad_Polygon )
 728   {
 729     if ( theQuadInterlace[smdsType].size() != nbNodes )
 730     {
 731       theQuadInterlace[smdsType].resize( nbNodes );
 732       for ( size_t i = 0; i < nbNodes / 2; ++i )
 733       {
 734         theQuadInterlace[smdsType][i*2+0] = i;
 735         theQuadInterlace[smdsType][i*2+1] = i + nbNodes / 2;
 736       }
 737     }
 738   }
 739   return theQuadInterlace[smdsType];
 740 }
 741
 742 //================================================================================
 743 /*!
 744  * \brief Return SMDSAbs_EntityType corresponding to VTKCellType
 745  */
 746 //================================================================================
 747
 748 SMDSAbs_EntityType SMDS_MeshCell::toSmdsType(VTKCellType vtkType)
 749 {
 750   return getCellProps( vtkType ).myEntity;
 751 }
 752
 753 //================================================================================
 754 /*!
 755  * \brief Return SMDSAbs_ElementType by SMDSAbs_GeometryType
 756  */
 757 //================================================================================
 758
 759 SMDSAbs_ElementType SMDS_MeshCell::ElemType(SMDSAbs_GeometryType geomType)
 760 {
 761   switch ( geomType ) {
 762   case SMDSGeom_POINT:     return SMDSAbs_0DElement;
 763
 764   case SMDSGeom_EDGE:      return SMDSAbs_Edge;
 765
 766   case SMDSGeom_TRIANGLE:
 767   case SMDSGeom_QUADRANGLE:
 768   case SMDSGeom_POLYGON:   return SMDSAbs_Face;
 769
 770   case SMDSGeom_TETRA:
 771   case SMDSGeom_PYRAMID:
 772   case SMDSGeom_HEXA:
 773   case SMDSGeom_PENTA:
 774   case SMDSGeom_HEXAGONAL_PRISM:
 775   case SMDSGeom_POLYHEDRA: return SMDSAbs_Volume;
 776
 777   case SMDSGeom_BALL:      return SMDSAbs_Ball;
 778
 779   case SMDSGeom_NONE: ;
 780   }
 781   return SMDSAbs_All;
 782 }
 783
 784 //================================================================================
 785 /*!
 786  * \brief Return SMDSAbs_ElementType by SMDSAbs_EntityType
 787  */
 788 //================================================================================
 789
 790 SMDSAbs_ElementType SMDS_MeshCell::ElemType(SMDSAbs_EntityType entityType)
 791 {
 792   return getCellProps( entityType ).myType;
 793 }
 794
 795 SMDSAbs_GeometryType SMDS_MeshCell::GeomType( SMDSAbs_EntityType entityType )
 796 {
 797   return getCellProps( entityType ).myGeom;
 798 }
 799
 800 bool SMDS_MeshCell::IsPoly( SMDSAbs_EntityType entityType )
 801 {
 802   return getCellProps( entityType ).myIsPoly;
 803 }
 804
 805 bool SMDS_MeshCell::IsQuadratic( SMDSAbs_EntityType entityType )
 806 {
 807   return getCellProps( entityType ).myIsQuadratic;
 808 }
 809
 810 int SMDS_MeshCell::NbCornerNodes( SMDSAbs_EntityType entityType )
 811 {
 812   return getCellProps( entityType ).myNbCornerNodes;
 813 }
 814
 815 int SMDS_MeshCell::NbNodes( SMDSAbs_EntityType entityType )
 816 {
 817   return getCellProps( entityType ).myNbNodes;
 818 }
 819
 820 int SMDS_MeshCell::NbEdges( SMDSAbs_EntityType entityType )
 821 {
 822   return getCellProps( entityType ).myNbEdges;
 823 }
 824
 825 int SMDS_MeshCell::NbFaces( SMDSAbs_EntityType entityType )
 826 {
 827   return getCellProps( entityType ).myNbFaces;
 828 }
 829
 830 //================================================================================
 831 /*!
 832  * \brief Return indices to transform cell connectivity from VTK to SMDS
 833  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
 834  */
 835 //================================================================================
 836
 837 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(SMDSAbs_EntityType smdsType)
 838 {
 839   return theFromVtkInterlaces[ smdsType ];
 840 }
 841
 842 //================================================================================
 843 /*!
 844  * \brief Return indices to transform cell connectivity from SMDS to VTK
 845  * Usage: vtkIDs[i] = smdsIDs[ indices[ i ]]
 846  */
 847 //================================================================================
 848
 849 const std::vector<int>& SMDS_MeshCell::toVtkOrder(VTKCellType vtkType)
 850 {
 851   return toVtkOrder( toSmdsType( vtkType ));
 852 }
 853
 854 //================================================================================
 855 /*!
 856  * \brief Return indices to transform cell connectivity from VTK to SMDS
 857  * Usage: smdsIDs[i] = vtkIDs[ indices[ i ]]
 858  */
 859 //================================================================================
 860
 861 const std::vector<int>& SMDS_MeshCell::fromVtkOrder(VTKCellType vtkType)
 862 {
 863   return fromVtkOrder( toSmdsType( vtkType ));
 864 }