src/SMDS/SMDS_MeshInfo.hxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 // File      : SMDS_MeshInfo.hxx
  23 // Created   : Mon Sep 24 18:32:41 2007
  24 // Author    : Edward AGAPOV (eap)
  25 //
  26 #ifndef SMDS_MeshInfo_HeaderFile
  27 #define SMDS_MeshInfo_HeaderFile
  28
  29 using namespace std;
  30
  31 #include "SMESH_SMDS.hxx"
  32
  33 #include "SMDS_MeshElement.hxx"
  34
  35 class SMDS_EXPORT SMDS_MeshInfo
  36 {
  37 public:
  38
  39   inline SMDS_MeshInfo();
  40   inline void Clear();
  41
  42   int NbNodes() const { return myNbNodes; }
  43
  44   inline int NbEdges      (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  45   inline int NbFaces      (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  46   inline int NbTriangles  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  47   inline int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
  48   int NbPolygons() const { return myNbPolygons; }
  49
  50   inline int NbVolumes (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  51   inline int NbTetras  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  52   inline int NbHexas   (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  53   inline int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
  54   inline int NbPrisms  (SMDSAbs_ElementOrder order = ORDER_ANY) const;
  55   int NbPolyhedrons() const { return myNbPolyhedrons; }
  56
  57 private:
  58   friend class SMDS_Mesh;
  59
  60   // methods to count NOT POLY elements
  61   inline void remove(const SMDS_MeshElement* el);
  62   inline void add   (const SMDS_MeshElement* el);
  63   inline int  index(SMDSAbs_ElementType type, int nbNodes);
  64   // methods to remove elements of ANY kind
  65   inline void RemoveEdge(const SMDS_MeshElement* el);
  66   inline void RemoveFace(const SMDS_MeshElement* el);
  67   inline void RemoveVolume(const SMDS_MeshElement* el);
  68
  69   int myNbNodes;
  70
  71   int myNbEdges      , myNbQuadEdges      ;
  72   int myNbTriangles  , myNbQuadTriangles  ;
  73   int myNbQuadrangles, myNbQuadQuadrangles;
  74   int myNbPolygons;
  75
  76   int myNbTetras  , myNbQuadTetras  ;
  77   int myNbHexas   , myNbQuadHexas   ;
  78   int myNbPyramids, myNbQuadPyramids;
  79   int myNbPrisms  , myNbQuadPrisms  ;
  80   int myNbPolyhedrons;
  81
  82   std::vector<int*> myNb; // pointers to myNb... fields
  83   std::vector<int>  myShift; // shift to get an index in myNb by elem->NbNodes()
  84 };
  85
  86 inline SMDS_MeshInfo::SMDS_MeshInfo():
  87   myNbNodes(0),
  88   myNbEdges      (0), myNbQuadEdges      (0),
  89   myNbTriangles  (0), myNbQuadTriangles  (0),
  90   myNbQuadrangles(0), myNbQuadQuadrangles(0),
  91   myNbPolygons(0),
  92   myNbTetras  (0), myNbQuadTetras  (0),
  93   myNbHexas   (0), myNbQuadHexas   (0),
  94   myNbPyramids(0), myNbQuadPyramids(0),
  95   myNbPrisms  (0), myNbQuadPrisms  (0),
  96   myNbPolyhedrons(0)
  97 {
  98   // Number of nodes in standard element types
  99   // n   v  f  e
 100   // o   o  a  d
 101   // d   l  c  g
 102   // e      e  e
 103   // -----------
 104   // 1
 105   // 2         *
 106   // 3      *
 107   // 4   *  *  *
 108   // 5   *
 109   // 6   *  *
 110   // 7
 111   // 8   *  *
 112   // 9
 113   // 10  *
 114   // 11
 115   // 12
 116   // 13  *
 117   // 14
 118   // 15  *
 119   // 16
 120   // 17
 121   // 18
 122   // 19
 123   // 20  *
 124   //
 125   // So to have a unique index for each type basing on nb of nodes, we use a shift:
 126   myShift.resize(SMDSAbs_Volume + 1, 0);
 127   myShift[ SMDSAbs_Face ] = +8; // 3->11, 4->12, 6->14, 8->16
 128   myShift[ SMDSAbs_Edge ] = -2; // 2->0, 4->2
 129
 130   myNb.resize( index( SMDSAbs_Volume,20 ) + 1, NULL);
 131   myNb[ index( SMDSAbs_Node,1 )] = & myNbNodes;
 132
 133   myNb[ index( SMDSAbs_Edge,2 )] = & myNbEdges;
 134   myNb[ index( SMDSAbs_Edge,4 )] = & myNbQuadEdges;
 135
 136   myNb[ index( SMDSAbs_Face,3 )] = & myNbTriangles;
 137   myNb[ index( SMDSAbs_Face,4 )] = & myNbQuadrangles;
 138   myNb[ index( SMDSAbs_Face,6 )] = & myNbQuadTriangles;
 139   myNb[ index( SMDSAbs_Face,8 )] = & myNbQuadQuadrangles;
 140
 141   myNb[ index( SMDSAbs_Volume, 4)]  = & myNbTetras;
 142   myNb[ index( SMDSAbs_Volume, 5)]  = & myNbPyramids;
 143   myNb[ index( SMDSAbs_Volume, 6)]  = & myNbPrisms;
 144   myNb[ index( SMDSAbs_Volume, 8)]  = & myNbHexas;
 145   myNb[ index( SMDSAbs_Volume, 10)] = & myNbQuadTetras;
 146   myNb[ index( SMDSAbs_Volume, 13)] = & myNbQuadPyramids;
 147   myNb[ index( SMDSAbs_Volume, 15)] = & myNbQuadPrisms;
 148   myNb[ index( SMDSAbs_Volume, 20)] = & myNbQuadHexas;
 149 }
 150 inline void // Clear
 151 SMDS_MeshInfo::Clear()
 152 { for ( int i=0; i<myNb.size(); ++i ) if ( myNb[i] ) (*myNb[i])=0;
 153   myNbPolygons=myNbPolyhedrons=0;
 154 }
 155 inline int // index
 156 SMDS_MeshInfo::index(SMDSAbs_ElementType type, int nbNodes)
 157 { return nbNodes + myShift[ type ]; }
 158
 159 inline void // remove
 160 SMDS_MeshInfo::remove(const SMDS_MeshElement* el)
 161 { --(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
 162
 163 inline void // add
 164 SMDS_MeshInfo::add(const SMDS_MeshElement* el)
 165 { ++(*myNb[ index(el->GetType(), el->NbNodes()) ]); }
 166
 167 inline void // RemoveEdge
 168 SMDS_MeshInfo::RemoveEdge(const SMDS_MeshElement* el)
 169 { if ( el->IsQuadratic() ) --myNbQuadEdges; else --myNbEdges; }
 170
 171 inline void // RemoveFace
 172 SMDS_MeshInfo::RemoveFace(const SMDS_MeshElement* el)
 173 { if ( el->IsPoly() ) --myNbPolygons; else remove( el ); }
 174
 175 inline void // RemoveVolume
 176 SMDS_MeshInfo::RemoveVolume(const SMDS_MeshElement* el)
 177 { if ( el->IsPoly() ) --myNbPolyhedrons; else remove( el ); }
 178
 179 inline int // NbEdges
 180 SMDS_MeshInfo::NbEdges      (SMDSAbs_ElementOrder order) const
 181 { return order == ORDER_ANY ? myNbEdges+myNbQuadEdges : order == ORDER_LINEAR ? myNbEdges : myNbQuadEdges; }
 182
 183 inline int // NbFaces
 184 SMDS_MeshInfo::NbFaces      (SMDSAbs_ElementOrder order) const
 185 { return NbTriangles(order)+NbQuadrangles(order)+(order == ORDER_QUADRATIC ? 0 : myNbPolygons); }
 186
 187 inline int // NbTriangles
 188 SMDS_MeshInfo::NbTriangles  (SMDSAbs_ElementOrder order) const
 189 { return order == ORDER_ANY ? myNbTriangles+myNbQuadTriangles : order == ORDER_LINEAR ? myNbTriangles : myNbQuadTriangles; }
 190
 191 inline int // NbQuadrangles
 192 SMDS_MeshInfo::NbQuadrangles(SMDSAbs_ElementOrder order) const
 193 { return order == ORDER_ANY ? myNbQuadrangles+myNbQuadQuadrangles : order == ORDER_LINEAR ? myNbQuadrangles : myNbQuadQuadrangles; }
 194
 195 inline int // NbVolumes
 196 SMDS_MeshInfo::NbVolumes (SMDSAbs_ElementOrder order) const
 197 { return NbTetras(order) + NbHexas(order) + NbPyramids(order) + NbPrisms(order) + (order == ORDER_QUADRATIC ? 0 : myNbPolyhedrons); }
 198
 199 inline int // NbTetras
 200 SMDS_MeshInfo::NbTetras  (SMDSAbs_ElementOrder order) const
 201 { return order == ORDER_ANY ? myNbTetras+myNbQuadTetras : order == ORDER_LINEAR ? myNbTetras : myNbQuadTetras; }
 202
 203 inline int // NbHexas
 204 SMDS_MeshInfo::NbHexas   (SMDSAbs_ElementOrder order) const
 205 { return order == ORDER_ANY ? myNbHexas+myNbQuadHexas : order == ORDER_LINEAR ? myNbHexas : myNbQuadHexas; }
 206
 207 inline int // NbPyramids
 208 SMDS_MeshInfo::NbPyramids(SMDSAbs_ElementOrder order) const
 209 { return order == ORDER_ANY ? myNbPyramids+myNbQuadPyramids : order == ORDER_LINEAR ? myNbPyramids : myNbQuadPyramids; }
 210
 211 inline int // NbPrisms
 212 SMDS_MeshInfo::NbPrisms  (SMDSAbs_ElementOrder order) const
 213 { return order == ORDER_ANY ? myNbPrisms+myNbQuadPrisms : order == ORDER_LINEAR ? myNbPrisms : myNbQuadPrisms; }
 214
 215 #endif