X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMDS%2FSMDS_MeshInfo.hxx;h=250442335d971018fa26b457b03c10410504d036;hb=67312ab966a7c21fe835917978028643ffadd99e;hp=026590a2e58a91c7aee552f3b3c1c9b033a7f828;hpb=bd4e115a78b52e3fbc016e5e30bb0e19b2a9e7d6;p=modules%2Fsmesh.git

diff --git a/src/SMDS/SMDS_MeshInfo.hxx b/src/SMDS/SMDS_MeshInfo.hxx
index 026590a2e..250442335 100644
--- a/src/SMDS/SMDS_MeshInfo.hxx
+++ b/src/SMDS/SMDS_MeshInfo.hxx
@@ -1,9 +1,9 @@
-// Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -25,11 +25,11 @@
 #define SMDS_MeshInfo_HeaderFile
 
 #include <vector>
-using namespace std;
 
 #include "SMESH_SMDS.hxx"
 
 #include "SMDS_MeshElement.hxx"
+#include<utilities.h>
 
 class SMDS_EXPORT SMDS_MeshInfo
 {
@@ -39,8 +39,12 @@ public:
   inline SMDS_MeshInfo& operator=(const SMDS_MeshInfo& other);
   inline void Clear();
 
-  inline int NbElements(SMDSAbs_ElementType type=SMDSAbs_All) const;
+  inline int NbElements(SMDSAbs_ElementType  type=SMDSAbs_All) const;
+  inline int NbElements(SMDSAbs_EntityType   type) const { return NbEntities(type); }
+  inline int NbElements(SMDSAbs_GeometryType type) const { return NbElementsOfGeom(type); }
+
   inline int NbEntities(SMDSAbs_EntityType  type) const;
+  inline int NbElementsOfGeom(SMDSAbs_GeometryType geom) const;
 
   int NbNodes()      const { return myNbNodes; }
   int Nb0DElements() const { return myNb0DElements; }
@@ -50,8 +54,9 @@ public:
   inline int NbFaces      (SMDSAbs_ElementOrder order = ORDER_ANY) const;
   inline int NbTriangles  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
   inline int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
+  int NbBiQuadTriangles() const { return myNbBiQuadTriangles; }
   int NbBiQuadQuadrangles() const { return myNbBiQuadQuadrangles; }
-  int NbPolygons() const { return myNbPolygons; }
+  inline int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
 
   inline int NbVolumes (SMDSAbs_ElementOrder order = ORDER_ANY) const;
   inline int NbTetras  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
@@ -60,6 +65,8 @@ public:
   inline int NbPrisms  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
   inline int NbHexPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
   int NbTriQuadHexas() const { return myNbTriQuadHexas; }
+  int NbQuadPrisms() const { return myNbQuadPrisms; }
+  int NbBiQuadPrisms() const { return myNbBiQuadPrisms; }
   int NbPolyhedrons() const { return myNbPolyhedrons; }
 
 protected:
@@ -83,14 +90,14 @@ private:
   int myNb0DElements;
   int myNbBalls;
   int myNbEdges      , myNbQuadEdges      ;
-  int myNbTriangles  , myNbQuadTriangles  ;
+  int myNbTriangles  , myNbQuadTriangles,   myNbBiQuadTriangles  ;
   int myNbQuadrangles, myNbQuadQuadrangles, myNbBiQuadQuadrangles;
-  int myNbPolygons;
+  int myNbPolygons   , myNbQuadPolygons;
 
   int myNbTetras  , myNbQuadTetras  ;
   int myNbHexas   , myNbQuadHexas,    myNbTriQuadHexas;
   int myNbPyramids, myNbQuadPyramids;
-  int myNbPrisms  , myNbQuadPrisms  ;
+  int myNbPrisms  , myNbQuadPrisms,   myNbBiQuadPrisms;
   int myNbHexPrism;
   int myNbPolyhedrons;
 
@@ -103,13 +110,13 @@ inline SMDS_MeshInfo::SMDS_MeshInfo():
   myNb0DElements (0),
   myNbBalls      (0),
   myNbEdges      (0), myNbQuadEdges      (0),
-  myNbTriangles  (0), myNbQuadTriangles  (0),
+  myNbTriangles  (0), myNbQuadTriangles  (0), myNbBiQuadTriangles(0),
   myNbQuadrangles(0), myNbQuadQuadrangles(0), myNbBiQuadQuadrangles(0),
-  myNbPolygons   (0),
+  myNbPolygons   (0), myNbQuadPolygons   (0),
   myNbTetras     (0), myNbQuadTetras  (0),
   myNbHexas      (0), myNbQuadHexas   (0), myNbTriQuadHexas(0),
   myNbPyramids   (0), myNbQuadPyramids(0),
-  myNbPrisms     (0), myNbQuadPrisms  (0),
+  myNbPrisms     (0), myNbQuadPrisms  (0), myNbBiQuadPrisms(0),
   myNbHexPrism   (0),
   myNbPolyhedrons(0)
 {
@@ -123,52 +130,57 @@ inline SMDS_MeshInfo::SMDS_MeshInfo():
   // 0 ------------------  - DON't USE 0!!!
   // 1            .  * .
   // 2         .       *
-  // 3      .     *
-  // 4   *  .  .
+  // 3      .  .  *
+  // 4   *  .
   // 5   *
   // 6   *  .
-  // 7         *
+  // 7      .
   // 8   *  .
-  // 9      .  *
+  // 9      .
   // 10  *
   // 11
   // 12  *
   // 13  *
   // 14
   // 15  *
-  // 16     *
-  // 17     *
-  // 18
-  // 19     *
-  // 20  *
-  // 21     *
-  // 22     *
+  // 16        *
+  // 17        *
+  // 18  *
+  // 19
+  // 20  *   
+  // 21
+  // 22
   // 23
   // 24
-  // 25
-  // 26
+  // 25     *
+  // 26     *
   // 27  *
+  // 28     *
+  // 29     *
+  // 30     *
+  // 31     *
   //
   // So to have a unique index for each type basing on nb of nodes, we use a shift:
   myShift.resize(SMDSAbs_NbElementTypes, 0);
 
-  myShift[ SMDSAbs_Face            ] = +13;// 3->16, 4->17, 6->19, 8->21, 9->22
-  myShift[ SMDSAbs_Edge            ] = +5; // 2->7, 4->9
-  myShift[ SMDSAbs_0DElement       ] = +2; // 1->3
-  myShift[ SMDSAbs_Ball ] = +1; // 1->2
+  myShift[ SMDSAbs_Face      ] = +22;// 3->25, 4->26, etc.
+  myShift[ SMDSAbs_Edge      ] = +14;// 2->16, 3->17
+  myShift[ SMDSAbs_0DElement ] = +2; // 1->3
+  myShift[ SMDSAbs_Ball      ] = +1; // 1->2
 
-  myNb.resize( index( SMDSAbs_Volume,27 ) + 1, NULL);
+  myNb.resize( index( SMDSAbs_Face,9 ) + 1, NULL);
 
   myNb[ index( SMDSAbs_Node,1 )] = & myNbNodes;
   myNb[ index( SMDSAbs_0DElement,1 )] = & myNb0DElements;
   myNb[ index( SMDSAbs_Ball,1 )] = & myNbBalls;
 
   myNb[ index( SMDSAbs_Edge,2 )] = & myNbEdges;
-  myNb[ index( SMDSAbs_Edge,4 )] = & myNbQuadEdges;
+  myNb[ index( SMDSAbs_Edge,3 )] = & myNbQuadEdges;
 
   myNb[ index( SMDSAbs_Face,3 )] = & myNbTriangles;
   myNb[ index( SMDSAbs_Face,4 )] = & myNbQuadrangles;
   myNb[ index( SMDSAbs_Face,6 )] = & myNbQuadTriangles;
+  myNb[ index( SMDSAbs_Face,7 )] = & myNbBiQuadTriangles;
   myNb[ index( SMDSAbs_Face,8 )] = & myNbQuadQuadrangles;
   myNb[ index( SMDSAbs_Face,9 )] = & myNbBiQuadQuadrangles;
 
@@ -180,22 +192,24 @@ inline SMDS_MeshInfo::SMDS_MeshInfo():
   myNb[ index( SMDSAbs_Volume, 12)] = & myNbHexPrism;
   myNb[ index( SMDSAbs_Volume, 13)] = & myNbQuadPyramids;
   myNb[ index( SMDSAbs_Volume, 15)] = & myNbQuadPrisms;  
+  myNb[ index( SMDSAbs_Volume, 18)] = & myNbBiQuadPrisms;
   myNb[ index( SMDSAbs_Volume, 20)] = & myNbQuadHexas;   
   myNb[ index( SMDSAbs_Volume, 27)] = & myNbTriQuadHexas;   
 }
 
 inline SMDS_MeshInfo& // operator=
 SMDS_MeshInfo::operator=(const SMDS_MeshInfo& other)
-{ for ( int i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=(*other.myNb[i]);
-  myNbPolygons = other.myNbPolygons;
-  myNbPolyhedrons = other.myNbPolyhedrons;
+{ for ( size_t i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=(*other.myNb[i]);
+  myNbPolygons     = other.myNbPolygons;
+  myNbQuadPolygons = other.myNbQuadPolygons;
+  myNbPolyhedrons  = other.myNbPolyhedrons;
   return *this;
 }
 
 inline void // Clear
 SMDS_MeshInfo::Clear()
-{ for ( int i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
-  myNbPolygons=myNbPolyhedrons=0;
+{ for ( size_t i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
+  myNbPolygons=myNbQuadPolygons=myNbPolyhedrons=0;
 }
 
 inline int // index
@@ -211,82 +225,93 @@ SMDS_MeshInfo::add(const SMDS_MeshElement* el)
 { ++(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
 
 inline void // addWithPoly
-SMDS_MeshInfo::addWithPoly(const SMDS_MeshElement* el)
-{
-  if ( el->IsPoly() )
-    ++( el->GetType()==SMDSAbs_Face ? myNbPolygons : myNbPolyhedrons );
-  else
-    add(el);
+SMDS_MeshInfo::addWithPoly(const SMDS_MeshElement* el) {
+  switch ( el->GetEntityType() ) {
+  case SMDSEntity_Polygon:      ++myNbPolygons; break;
+  case SMDSEntity_Quad_Polygon: ++myNbQuadPolygons; break;
+  case SMDSEntity_Polyhedra:    ++myNbPolyhedrons; break;
+  default:                      add(el);
+  }
 }
 inline void // RemoveEdge
 SMDS_MeshInfo::RemoveEdge(const SMDS_MeshElement* el)
 { if ( el->IsQuadratic() ) --myNbQuadEdges; else --myNbEdges; }
 
 inline void // RemoveFace
-SMDS_MeshInfo::RemoveFace(const SMDS_MeshElement* el)
-{ if ( el->IsPoly() ) --myNbPolygons; else remove( el ); }
+SMDS_MeshInfo::RemoveFace(const SMDS_MeshElement* el) {
+  switch ( el->GetEntityType() ) {
+  case SMDSEntity_Polygon:      --myNbPolygons; break;
+  case SMDSEntity_Quad_Polygon: --myNbQuadPolygons; break;
+  default:                      remove(el);
+  }
+}
 
 inline void // RemoveVolume
 SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
 { if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
 
-inline int // NbEdges
+inline int  // NbEdges
 SMDS_MeshInfo::NbEdges      (SMDSAbs_ElementOrder order) const
 { return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
 
-inline int // NbFaces
+inline int  // NbFaces
 SMDS_MeshInfo::NbFaces      (SMDSAbs_ElementOrder order) const
-{ return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_QUADRATIC ? 0 : myNbPolygons); }
+{ return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons ); }
 
-inline int // NbTriangles
+inline int  // NbTriangles
 SMDS_MeshInfo::NbTriangles  (SMDSAbs_ElementOrder order) const
-{ return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles; }
+{ return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles+myNbBiQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles+myNbBiQuadTriangles; }
 
-inline int // NbQuadrangles
+inline int  // NbQuadrangles
 SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
 { return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles+myNbBiQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles+myNbBiQuadQuadrangles; }
 
-inline int // NbVolumes
+inline int  // NbPolygons
+SMDS_MeshInfo::NbPolygons(SMDSAbs_ElementOrder order) const
+{ return order == ORDER_ANY ? myNbPolygons+myNbQuadPolygons : order == ORDER_LINEAR ? myNbPolygons : myNbQuadPolygons; }
+
+inline int  // NbVolumes
 SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
 { return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + NbHexPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
 
-inline int // NbTetras
+inline int  // NbTetras
 SMDS_MeshInfo::NbTetras  (SMDSAbs_ElementOrder order) const
 { return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
 
-inline int // NbHexas
+inline int  // NbHexas
 SMDS_MeshInfo::NbHexas   (SMDSAbs_ElementOrder order) const
 { return order == ORDER_ANY ? myNbHexas+myNbQuadHexas+myNbTriQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas+myNbTriQuadHexas; }
 
-inline int // NbPyramids
+inline int  // NbPyramids
 SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
 { return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
 
-inline int // NbPrisms
+inline int  // NbPrisms
 SMDS_MeshInfo::NbPrisms  (SMDSAbs_ElementOrder order) const
-{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
+{ return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms+myNbBiQuadPrisms: order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms+myNbBiQuadPrisms; }
 
-inline int // NbHexPrisms
+inline int  // NbHexPrisms
 SMDS_MeshInfo::NbHexPrisms  (SMDSAbs_ElementOrder order) const
 { return order == ORDER_ANY ? myNbHexPrism : order == ORDER_LINEAR ? myNbHexPrism : 0; }
 
-inline int // NbElements
+inline int  // NbElements
 SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
 { 
   int nb = 0;
   switch (type) {
   case SMDSAbs_All:
-    for ( int i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
-    nb += myNbPolygons + myNbPolyhedrons;
+    for ( size_t i=1+index( SMDSAbs_Node,1 ); i<myNb.size(); ++i ) if ( myNb[i] ) nb += *myNb[i];
+    nb += myNbPolygons + myNbQuadPolygons + myNbPolyhedrons;
     break;
   case SMDSAbs_Volume:
-    nb = myNbTetras+ myNbPyramids+ myNbPrisms+ myNbHexas+ myNbHexPrism+
-      myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbQuadHexas+ myNbTriQuadHexas+
-      myNbPolyhedrons;
+    nb = ( myNbTetras+     myNbPyramids+     myNbPrisms+     myNbHexas+     myNbHexPrism+
+           myNbQuadTetras+ myNbQuadPyramids+ myNbQuadPrisms+ myNbBiQuadPrisms + myNbQuadHexas+ myNbTriQuadHexas+
+           myNbPolyhedrons );
     break;
   case SMDSAbs_Face:
-    nb = myNbTriangles+ myNbQuadrangles+
-      myNbQuadTriangles+ myNbQuadQuadrangles+ myNbBiQuadQuadrangles+ myNbPolygons;
+    nb = ( myNbTriangles+       myNbQuadrangles+
+           myNbQuadTriangles+   myNbBiQuadTriangles+
+           myNbQuadQuadrangles+ myNbBiQuadQuadrangles+ myNbPolygons+ myNbQuadPolygons );
     break;
   case SMDSAbs_Edge:
     nb = myNbEdges + myNbQuadEdges;
@@ -305,7 +330,7 @@ SMDS_MeshInfo::NbElements(SMDSAbs_ElementType type) const
   return nb;
 }
 
-int // NbEntities
+inline int  // NbEntities
 SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
 {
   switch (type) {
@@ -314,6 +339,7 @@ SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
   case SMDSEntity_Quad_Edge:        return myNbQuadEdges;
   case SMDSEntity_Triangle:         return myNbTriangles;
   case SMDSEntity_Quad_Triangle:    return myNbQuadTriangles;
+  case SMDSEntity_BiQuad_Triangle:  return myNbBiQuadTriangles;
   case SMDSEntity_Quadrangle:       return myNbQuadrangles;
   case SMDSEntity_Quad_Quadrangle:  return myNbQuadQuadrangles;
   case SMDSEntity_BiQuad_Quadrangle:return myNbBiQuadQuadrangles;
@@ -327,18 +353,59 @@ SMDS_MeshInfo::NbEntities(SMDSAbs_EntityType type) const
   case SMDSEntity_TriQuad_Hexa:     return myNbTriQuadHexas;
   case SMDSEntity_Penta:            return myNbPrisms;
   case SMDSEntity_Quad_Penta:       return myNbQuadPrisms;
+  case SMDSEntity_BiQuad_Penta:     return myNbBiQuadPrisms;
   case SMDSEntity_Hexagonal_Prism:  return myNbHexPrism;
   case SMDSEntity_Polyhedra:        return myNbPolyhedrons;
   case SMDSEntity_0D:               return myNb0DElements;
   case SMDSEntity_Ball:             return myNbBalls;
-  case SMDSEntity_Quad_Polygon:
+  case SMDSEntity_Quad_Polygon:     return myNbQuadPolygons;
   case SMDSEntity_Quad_Polyhedra:
+  case SMDSEntity_Last:
     break;
   }
   return 0;
 }
 
-void // set
+inline int  // NbElementsOfGeom
+SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
+{
+  switch ( geom ) {
+    // 0D:
+  case SMDSGeom_POINT:           return myNb0DElements;
+    // 1D:
+  case SMDSGeom_EDGE:            return (myNbEdges +
+                                         myNbQuadEdges);
+    // 2D:
+  case SMDSGeom_TRIANGLE:        return (myNbTriangles +
+                                         myNbQuadTriangles +
+                                         myNbBiQuadTriangles );
+  case SMDSGeom_QUADRANGLE:      return (myNbQuadrangles +
+                                         myNbQuadQuadrangles +
+                                         myNbBiQuadQuadrangles );
+  case SMDSGeom_POLYGON:         return (myNbPolygons + myNbQuadPolygons );
+    // 3D:
+  case SMDSGeom_TETRA:           return (myNbTetras +
+                                         myNbQuadTetras);
+  case SMDSGeom_PYRAMID:         return (myNbPyramids +
+                                         myNbQuadPyramids);
+  case SMDSGeom_HEXA:            return (myNbHexas +
+                                         myNbQuadHexas +
+                                         myNbTriQuadHexas);
+  case SMDSGeom_PENTA:           return (myNbPrisms +
+                                         myNbQuadPrisms +
+                                         myNbBiQuadPrisms);
+  case SMDSGeom_HEXAGONAL_PRISM: return myNbHexPrism;
+  case SMDSGeom_POLYHEDRA:       return myNbPolyhedrons;
+    // Discrete:
+  case SMDSGeom_BALL:            return myNbBalls;
+    //
+  case SMDSGeom_NONE:
+  default:;
+  }
+  return 0;
+}
+
+inline void // setNb
 SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
 {
   switch (geomType) {
@@ -346,6 +413,7 @@ SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
   case SMDSEntity_0D:               myNb0DElements        = nb; break;
   case SMDSEntity_Ball:             myNbBalls             = nb; break;
   case SMDSEntity_BiQuad_Quadrangle:myNbBiQuadQuadrangles = nb; break;
+  case SMDSEntity_BiQuad_Triangle:  myNbBiQuadTriangles   = nb; break;
   case SMDSEntity_Edge:             myNbEdges             = nb; break;
   case SMDSEntity_Hexa:             myNbHexas             = nb; break;
   case SMDSEntity_Hexagonal_Prism:  myNbHexPrism          = nb; break;
@@ -356,6 +424,7 @@ SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
   case SMDSEntity_Quad_Edge:        myNbQuadEdges         = nb; break;
   case SMDSEntity_Quad_Hexa:        myNbQuadHexas         = nb; break;
   case SMDSEntity_Quad_Penta:       myNbQuadPrisms        = nb; break;
+  case SMDSEntity_BiQuad_Penta:     myNbBiQuadPrisms      = nb; break;
   case SMDSEntity_Quad_Pyramid:     myNbQuadPyramids      = nb; break;
   case SMDSEntity_Quad_Quadrangle:  myNbQuadQuadrangles   = nb; break;
   case SMDSEntity_Quad_Tetra:       myNbQuadTetras        = nb; break;
@@ -364,8 +433,9 @@ SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb)
   case SMDSEntity_Tetra:            myNbTetras            = nb; break;
   case SMDSEntity_TriQuad_Hexa:     myNbTriQuadHexas      = nb; break;
   case SMDSEntity_Triangle:         myNbTriangles         = nb; break;
-  case SMDSEntity_Quad_Polygon:
+  case SMDSEntity_Quad_Polygon:     myNbQuadPolygons      = nb; break;
   case SMDSEntity_Quad_Polyhedra:
+  case SMDSEntity_Last:
     break;
   }
 }