src/SMDS/SMDS_MeshInfo.hxx

   1 // Copyright (C) 2007-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 // File      : SMDS_MeshInfo.hxx
  21 // Created   : Mon Sep 24 18:32:41 2007
  22 // Author    : Edward AGAPOV (eap)
  23 //
  24 #ifndef SMDS_MeshInfo_HeaderFile
  25 #define SMDS_MeshInfo_HeaderFile
  26
  27 #include <vector>
  28
  29 #include "SMESH_SMDS.hxx"
  30
  31 #include "SMDS_MeshElement.hxx"
  32
  33 class SMDS_EXPORT SMDS_MeshInfo
  34 {
  35 public:
  36
  37   inline SMDS_MeshInfo();
  38   inline SMDS_MeshInfo& operator=(const SMDS_MeshInfo& other);
  39   inline void Clear();
  40
  41   inline int NbElements(SMDSAbs_ElementType  type=SMDSAbs_All) const;
  42   inline int NbElements(SMDSAbs_EntityType   type) const { return NbEntities(type); }
  43   inline int NbElements(SMDSAbs_GeometryType type) const { return NbElementsOfGeom(type); }
  44
  45   inline int NbEntities(SMDSAbs_EntityType  type) const;
  46   inline int NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
  47
  48   int NbNodes()      const { return myNbNodes; }
  49   int Nb0DElements() const { return myNb0DElements; }
  50   int NbBalls()      const { return myNbBalls; }
  51   inline int NbEdges      (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  52
  53   inline int NbFaces      (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  54   inline int NbTriangles  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  55   inline int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
  56   int NbBiQuadTriangles() const { return myNbBiQuadTriangles; }
  57   int NbBiQuadQuadrangles() const { return myNbBiQuadQuadrangles; }
  58   inline int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
  59
  60   inline int NbVolumes (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  61   inline int NbTetras  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  62   inline int NbHexas   (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  63   inline int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
  64   inline int NbPrisms  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  65   inline int NbHexPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
  66   int NbTriQuadHexas() const { return myNbTriQuadHexas; }
  67   int NbQuadPrisms() const { return myNbQuadPrisms; }
  68   int NbBiQuadPrisms() const { return myNbBiQuadPrisms; }
  69   int NbPolyhedrons() const { return myNbPolyhedrons; }
  70
  71 protected:
  72   inline void addWithPoly(const SMDS_MeshElement* el);
  73   inline void setNb(const SMDSAbs_EntityType geomType, const int nb);
  74
  75 private:
  76   friend class SMDS_Mesh;
  77
  78   // methods to count NOT POLY elements
  79   inline void remove(const SMDS_MeshElement* el);
  80   inline void add   (const SMDS_MeshElement* el);
  81   inline int  index(SMDSAbs_ElementType type, int nbNodes) const;
  82   // methods to remove elements of ANY kind
  83   inline void RemoveEdge(const SMDS_MeshElement* el);
  84   inline void RemoveFace(const SMDS_MeshElement* el);
  85   inline void RemoveVolume(const SMDS_MeshElement* el);
  86
  87   int myNbNodes;
  88
  89   int myNb0DElements;
  90   int myNbBalls;
  91   int myNbEdges      , myNbQuadEdges      ;
  92   int myNbTriangles  , myNbQuadTriangles,   myNbBiQuadTriangles  ;
  93   int myNbQuadrangles, myNbQuadQuadrangles, myNbBiQuadQuadrangles;
  94   int myNbPolygons   , myNbQuadPolygons;
  95
  96   int myNbTetras  , myNbQuadTetras  ;
  97   int myNbHexas   , myNbQuadHexas,    myNbTriQuadHexas;
  98   int myNbPyramids, myNbQuadPyramids;
  99   int myNbPrisms  , myNbQuadPrisms,   myNbBiQuadPrisms;
 100   int myNbHexPrism;
 101   int myNbPolyhedrons;
 102
 103   std::vector<int*> myNb; // pointers to myNb... fields
 104   std::vector<int>  myShift; // shift to get an index in myNb by elem->NbNodes()
 105 };
 106
 107 inline SMDS_MeshInfo::SMDS_MeshInfo():
 108   myNbNodes      (0),
 109   myNb0DElements (0),
 110   myNbBalls      (0),
 111   myNbEdges      (0), myNbQuadEdges      (0),
 112   myNbTriangles  (0), myNbQuadTriangles  (0), myNbBiQuadTriangles(0),
 113   myNbQuadrangles(0), myNbQuadQuadrangles(0), myNbBiQuadQuadrangles(0),
 114   myNbPolygons   (0), myNbQuadPolygons   (0),
 115   myNbTetras     (0), myNbQuadTetras  (0),
 116   myNbHexas      (0), myNbQuadHexas   (0), myNbTriQuadHexas(0),
 117   myNbPyramids   (0), myNbQuadPyramids(0),
 118   myNbPrisms     (0), myNbQuadPrisms  (0), myNbBiQuadPrisms(0),
 119   myNbHexPrism   (0),
 120   myNbPolyhedrons(0)
 121 {
 122   // Number of nodes in standard element types (. - actual nb, * - after the shift)
 123   // n   v  f  e  0  n b
 124   // o   o  a  d  d  o a
 125   // d   l  c  g     d l
 126   // e      e  e     e l
 127   // s
 128   // ====================
 129   // 0 ------------------  - DON't USE 0!!!
 130   // 1            .  * .
 131   // 2         .       *
 132   // 3      .  .  *
 133   // 4   *  .
 134   // 5   *
 135   // 6   *  .
 136   // 7      .
 137   // 8   *  .
 138   // 9      .
 139   // 10  *
 140   // 11
 141   // 12  *
 142   // 13  *
 143   // 14
 144   // 15  *
 145   // 16        *
 146   // 17        *
 147   // 18     *
 148   // 19     *
 149   // 20  *
 150   // 21     *
 151   // 22     *
 152   // 23     *
 153   // 24     *
 154   // 25
 155   // 26
 156   // 27  *
 157   //
 158   // So to have a unique index for each type basing on nb of nodes, we use a shift:
 159   myShift.resize(SMDSAbs_NbElementTypes, 0);
 160
 161   myShift[ SMDSAbs_Face      ] = +15;// 3->18, 4->19, etc.
 162   myShift[ SMDSAbs_Edge      ] = +14;// 2->16, 3->17
 163   myShift[ SMDSAbs_0DElement ] = +2; // 1->3
 164   myShift[ SMDSAbs_Ball      ] = +1; // 1->2
 165
 166   myNb.resize( index( SMDSAbs_Volume,27 ) + 1, NULL);
 167
 168   myNb[ index( SMDSAbs_Node,1 )] = & myNbNodes;
 169   myNb[ index( SMDSAbs_0DElement,1 )] = & myNb0DElements;
 170   myNb[ index( SMDSAbs_Ball,1 )] = & myNbBalls;
 171
 172   myNb[ index( SMDSAbs_Edge,2 )] = & myNbEdges;
 173   myNb[ index( SMDSAbs_Edge,3 )] = & myNbQuadEdges;
 174
 175   myNb[ index( SMDSAbs_Face,3 )] = & myNbTriangles;
 176   myNb[ index( SMDSAbs_Face,4 )] = & myNbQuadrangles;
 177   myNb[ index( SMDSAbs_Face,6 )] = & myNbQuadTriangles;
 178   myNb[ index( SMDSAbs_Face,7 )] = & myNbBiQuadTriangles;
 179   myNb[ index( SMDSAbs_Face,8 )] = & myNbQuadQuadrangles;
 180   myNb[ index( SMDSAbs_Face,9 )] = & myNbBiQuadQuadrangles;
 181
 182   myNb[ index( SMDSAbs_Volume, 4)]  = & myNbTetras;
 183   myNb[ index( SMDSAbs_Volume, 5)]  = & myNbPyramids;
 184   myNb[ index( SMDSAbs_Volume, 6)]  = & myNbPrisms;
 185   myNb[ index( SMDSAbs_Volume, 8)]  = & myNbHexas;
 186   myNb[ index( SMDSAbs_Volume, 10)] = & myNbQuadTetras;
 187   myNb[ index( SMDSAbs_Volume, 12)] = & myNbHexPrism;
 188   myNb[ index( SMDSAbs_Volume, 13)] = & myNbQuadPyramids;
 189   myNb[ index( SMDSAbs_Volume, 15)] = & myNbQuadPrisms;
 190   myNb[ index( SMDSAbs_Volume, 20)] = & myNbQuadHexas;
 191   myNb[ index( SMDSAbs_Volume, 27)] = & myNbTriQuadHexas;
 192 }
 193
 194 inline SMDS_MeshInfo& // operator=
 195 SMDS_MeshInfo::operator=(const SMDS_MeshInfo& other)
 196 { for ( size_t i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=(*other.myNb[i]);
 197   myNbPolygons     = other.myNbPolygons;
 198   myNbQuadPolygons = other.myNbQuadPolygons;
 199   myNbPolyhedrons  = other.myNbPolyhedrons;
 200   return *this;
 201 }
 202
 203 inline void // Clear
 204 SMDS_MeshInfo::Clear()
 205 { for ( size_t i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
 206   myNbPolygons=myNbQuadPolygons=myNbPolyhedrons=0;
 207 }
 208
 209 inline int // index
 210 SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes) const
 211 { return nbNodes + myShift[ type ]; }
 212
 213 inline void // remove
 214 SMDS_MeshInfo::remove(const SMDS_MeshElement* el)
 215 { --(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
 216
 217 inline void // add
 218 SMDS_MeshInfo::add(const SMDS_MeshElement* el)
 219 { ++(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
 220
 221 inline void // addWithPoly
 222 SMDS_MeshInfo::addWithPoly(const SMDS_MeshElement* el) {
 223   switch ( el->GetEntityType() ) {
 224   case SMDSEntity_Polygon:      ++myNbPolygons; break;
 225   case SMDSEntity_Quad_Polygon: ++myNbQuadPolygons; break;
 226   case SMDSEntity_Polyhedra:    ++myNbPolyhedrons; break;
 227   default:                      add(el);
 228   }
 229 }
 230 inline void // RemoveEdge
 231 SMDS_MeshInfo::RemoveEdge(const SMDS_MeshElement* el)
 232 { if ( el->IsQuadratic() ) --myNbQuadEdges; else --myNbEdges; }
 233
 234 inline void // RemoveFace
 235 SMDS_MeshInfo::RemoveFace(const SMDS_MeshElement* el) {
 236   switch ( el->GetEntityType() ) {
 237   case SMDSEntity_Polygon:      --myNbPolygons; break;
 238   case SMDSEntity_Quad_Polygon: --myNbQuadPolygons; break;
 239   default:                      remove(el);
 240   }
 241 }
 242
 243 inline void // RemoveVolume
 244 SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
 245 { if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
 246
 247 inline int  // NbEdges
 248 SMDS_MeshInfo::NbEdges      (SMDSAbs_ElementOrder order) const
 249 { return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
 250
 251 inline int  // NbFaces
 252 SMDS_MeshInfo::NbFaces      (SMDSAbs_ElementOrder order) const
 253 { return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons ); }
 254
 255 inline int  // NbTriangles
 256 SMDS_MeshInfo::NbTriangles  (SMDSAbs_ElementOrder order) const
 257 { return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles+myNbBiQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles+myNbBiQuadTriangles; }
 258
 259 inline int  // NbQuadrangles
 260 SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
 261 { return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles+myNbBiQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles+myNbBiQuadQuadrangles; }
 262
 263 inline int  // NbPolygons
 264 SMDS_MeshInfo::NbPolygons(SMDSAbs_ElementOrder order) const
 265 { return order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons; }
 266
 267 inline int  // NbVolumes
 268 SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
 269 { return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + NbHexPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
 270
 271 inline int  // NbTetras
 272 SMDS_MeshInfo::NbTetras  (SMDSAbs_ElementOrder order) const
 273 { return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
 274
 275 inline int  // NbHexas
 276 SMDS_MeshInfo::NbHexas   (SMDSAbs_ElementOrder order) const
 277 { return order == ORDER_ANY ? myNbHexas+myNbQuadHexas+myNbTriQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas+myNbTriQuadHexas; }
 278
 279 inline int  // NbPyramids
 280 SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
 281 { return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
 282
 283 inline int  // NbPrisms
 284 SMDS_MeshInfo::NbPrisms  (SMDSAbs_ElementOrder order) const
 285 { return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
 286
 287 inline int  // NbHexPrisms
 288 SMDS_MeshInfo::NbHexPrisms  (SMDSAbs_ElementOrder order) const
 289 { return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; }
 290
 291 inline int  // NbElements
 292 SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
 293 {
 294   int nb = 0;
 295   switch (type) {
 296   case SMDSAbs_All:
 297     for ( size_t i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
 298     nb += myNbPolygons + myNbQuadPolygons + myNbPolyhedrons;
 299     break;
 300   case SMDSAbs_Volume:
 301     nb = ( myNbTetras+     myNbPyramids+     myNbPrisms+     myNbHexas+     myNbHexPrism+
 302            myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbBiQuadPrisms + myNbQuadHexas+ myNbTriQuadHexas+
 303            myNbPolyhedrons );
 304     break;
 305   case SMDSAbs_Face:
 306     nb = ( myNbTriangles+       myNbQuadrangles+
 307            myNbQuadTriangles+   myNbBiQuadTriangles+
 308            myNbQuadQuadrangles+ myNbBiQuadQuadrangles+ myNbPolygons+ myNbQuadPolygons );
 309     break;
 310   case SMDSAbs_Edge:
 311     nb = myNbEdges + myNbQuadEdges;
 312     break;
 313   case SMDSAbs_Node:
 314     nb = myNbNodes;
 315     break;
 316   case SMDSAbs_0DElement:
 317     nb = myNb0DElements;
 318     break;
 319   case SMDSAbs_Ball:
 320     nb = myNbBalls;
 321     break;
 322   default:;
 323   }
 324   return nb;
 325 }
 326
 327 inline int  // NbEntities
 328 SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
 329 {
 330   switch (type) {
 331   case SMDSEntity_Node:             return myNbNodes;
 332   case SMDSEntity_Edge:             return myNbEdges;
 333   case SMDSEntity_Quad_Edge:        return myNbQuadEdges;
 334   case SMDSEntity_Triangle:         return myNbTriangles;
 335   case SMDSEntity_Quad_Triangle:    return myNbQuadTriangles;
 336   case SMDSEntity_BiQuad_Triangle:  return myNbBiQuadTriangles;
 337   case SMDSEntity_Quadrangle:       return myNbQuadrangles;
 338   case SMDSEntity_Quad_Quadrangle:  return myNbQuadQuadrangles;
 339   case SMDSEntity_BiQuad_Quadrangle:return myNbBiQuadQuadrangles;
 340   case SMDSEntity_Polygon:          return myNbPolygons;
 341   case SMDSEntity_Tetra:            return myNbTetras;
 342   case SMDSEntity_Quad_Tetra:       return myNbQuadTetras;
 343   case SMDSEntity_Pyramid:          return myNbPyramids;
 344   case SMDSEntity_Quad_Pyramid:     return myNbQuadPyramids;
 345   case SMDSEntity_Hexa:             return myNbHexas;
 346   case SMDSEntity_Quad_Hexa:        return myNbQuadHexas;
 347   case SMDSEntity_TriQuad_Hexa:     return myNbTriQuadHexas;
 348   case SMDSEntity_Penta:            return myNbPrisms;
 349   case SMDSEntity_Quad_Penta:       return myNbQuadPrisms;
 350   case SMDSEntity_BiQuad_Penta:     return myNbBiQuadPrisms;
 351   case SMDSEntity_Hexagonal_Prism:  return myNbHexPrism;
 352   case SMDSEntity_Polyhedra:        return myNbPolyhedrons;
 353   case SMDSEntity_0D:               return myNb0DElements;
 354   case SMDSEntity_Ball:             return myNbBalls;
 355   case SMDSEntity_Quad_Polygon:     return myNbQuadPolygons;
 356   case SMDSEntity_Quad_Polyhedra:
 357   case SMDSEntity_Last:
 358     break;
 359   }
 360   return 0;
 361 }
 362
 363 inline int  // NbElementsOfGeom
 364 SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
 365 {
 366   switch ( geom ) {
 367     // 0D:
 368   case SMDSGeom_POINT:           return myNb0DElements;
 369     // 1D:
 370   case SMDSGeom_EDGE:            return (myNbEdges +
 371                                          myNbQuadEdges);
 372     // 2D:
 373   case SMDSGeom_TRIANGLE:        return (myNbTriangles +
 374                                          myNbQuadTriangles +
 375                                          myNbBiQuadTriangles );
 376   case SMDSGeom_QUADRANGLE:      return (myNbQuadrangles +
 377                                          myNbQuadQuadrangles +
 378                                          myNbBiQuadQuadrangles );
 379   case SMDSGeom_POLYGON:         return (myNbPolygons + myNbQuadPolygons );
 380     // 3D:
 381   case SMDSGeom_TETRA:           return (myNbTetras +
 382                                          myNbQuadTetras);
 383   case SMDSGeom_PYRAMID:         return (myNbPyramids +
 384                                          myNbQuadPyramids);
 385   case SMDSGeom_HEXA:            return (myNbHexas +
 386                                          myNbQuadHexas +
 387                                          myNbTriQuadHexas);
 388   case SMDSGeom_PENTA:           return (myNbPrisms +
 389                                          myNbQuadPrisms);
 390   case SMDSGeom_HEXAGONAL_PRISM: return myNbHexPrism;
 391   case SMDSGeom_POLYHEDRA:       return myNbPolyhedrons;
 392     // Discrete:
 393   case SMDSGeom_BALL:            return myNbBalls;
 394     //
 395   case SMDSGeom_NONE:
 396   default:;
 397   }
 398   return 0;
 399 }
 400
 401 inline void // setNb
 402 SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
 403 {
 404   switch (geomType) {
 405   case SMDSEntity_Node:             myNbNodes             = nb; break;
 406   case SMDSEntity_0D:               myNb0DElements        = nb; break;
 407   case SMDSEntity_Ball:             myNbBalls             = nb; break;
 408   case SMDSEntity_BiQuad_Quadrangle:myNbBiQuadQuadrangles = nb; break;
 409   case SMDSEntity_BiQuad_Triangle:  myNbBiQuadTriangles   = nb; break;
 410   case SMDSEntity_Edge:             myNbEdges             = nb; break;
 411   case SMDSEntity_Hexa:             myNbHexas             = nb; break;
 412   case SMDSEntity_Hexagonal_Prism:  myNbHexPrism          = nb; break;
 413   case SMDSEntity_Penta:            myNbPrisms            = nb; break;
 414   case SMDSEntity_Polygon:          myNbPolygons          = nb; break;
 415   case SMDSEntity_Polyhedra:        myNbPolyhedrons       = nb; break;
 416   case SMDSEntity_Pyramid:          myNbPyramids          = nb; break;
 417   case SMDSEntity_Quad_Edge:        myNbQuadEdges         = nb; break;
 418   case SMDSEntity_Quad_Hexa:        myNbQuadHexas         = nb; break;
 419   case SMDSEntity_Quad_Penta:       myNbQuadPrisms        = nb; break;
 420   case SMDSEntity_BiQuad_Penta:     myNbBiQuadPrisms      = nb; break;
 421   case SMDSEntity_Quad_Pyramid:     myNbQuadPyramids      = nb; break;
 422   case SMDSEntity_Quad_Quadrangle:  myNbQuadQuadrangles   = nb; break;
 423   case SMDSEntity_Quad_Tetra:       myNbQuadTetras        = nb; break;
 424   case SMDSEntity_Quad_Triangle:    myNbQuadTriangles     = nb; break;
 425   case SMDSEntity_Quadrangle:       myNbQuadrangles       = nb; break;
 426   case SMDSEntity_Tetra:            myNbTetras            = nb; break;
 427   case SMDSEntity_TriQuad_Hexa:     myNbTriQuadHexas      = nb; break;
 428   case SMDSEntity_Triangle:         myNbTriangles         = nb; break;
 429   case SMDSEntity_Quad_Polygon:     myNbQuadPolygons      = nb; break;
 430   case SMDSEntity_Quad_Polyhedra:
 431   case SMDSEntity_Last:
 432     break;
 433   }
 434 }
 435
 436 #endif