src/DriverGMF/DriverGMF_Write.cxx

   1 // Copyright (C) 2007-2012  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      : DriverGMF_Write.cxx
  23 // Created   : Mon Sep 17 17:03:02 2012
  24 // Author    : Edward AGAPOV (eap)
  25
  26 #include "DriverGMF_Write.hxx"
  27
  28 #include "SMESHDS_GroupBase.hxx"
  29 #include "SMESHDS_Mesh.hxx"
  30 #include "SMESH_Comment.hxx"
  31
  32 #include <Basics_Utils.hxx>
  33
  34 extern "C"
  35 {
  36 #include "libmesh5.h"
  37 }
  38
  39 #include <vector>
  40
  41 #define BEGIN_ELEM_WRITE( SMDSEntity, GmfKwd, elem )                    \
  42   elemIt = myMesh->elementEntityIterator( SMDSEntity );                 \
  43   if ( elemIt->more() )                                                 \
  44   {                                                                     \
  45   GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbEntities( SMDSEntity )); \
  46   for ( int gmfID = 1; elemIt->more(); ++gmfID )                        \
  47   {                                                                     \
  48   const SMDS_MeshElement* elem = elemIt->next();                        \
  49   GmfSetLin(meshID, GmfKwd,
  50
  51 #define END_ELEM_WRITE( elem )                  \
  52   elem->getshapeId() );                         \
  53   }}                                            \
  54
  55 #define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id )         \
  56   elem->getshapeId() );                                 \
  57   e2id.insert( e2id.end(), make_pair( elem, gmfID ));   \
  58   }}                                                    \
  59
  60
  61 DriverGMF_Write::DriverGMF_Write():
  62   Driver_SMESHDS_Mesh(), _exportRequiredGroups( true )
  63 {
  64 }
  65 DriverGMF_Write::~DriverGMF_Write()
  66 {
  67 }
  68
  69 Driver_Mesh::Status DriverGMF_Write::Perform()
  70 {
  71   Kernel_Utils::Localizer loc;
  72
  73   const int dim = 3, version = sizeof(long) == 4 ? 2 : 3;
  74
  75   int meshID = GmfOpenMesh( myFile.c_str(), GmfWrite, version, dim );
  76   if ( !meshID )
  77     return addMessage( SMESH_Comment("Can't open for writing ") << myFile, /*fatal=*/true );
  78
  79   DriverGMF_MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction
  80
  81   // nodes
  82   std::map< const SMDS_MeshNode* , int > node2IdMap;
  83   int iN = 0, nbNodes = myMesh->NbNodes();
  84   GmfSetKwd( meshID, GmfVertices, nbNodes );
  85   double xyz[3];
  86   SMDS_NodeIteratorPtr nodeIt = myMesh->nodesIterator();
  87   while ( nodeIt->more() )
  88   {
  89     const SMDS_MeshNode* n = nodeIt->next();
  90     n->GetXYZ( xyz );
  91     GmfSetLin( meshID, GmfVertices, xyz[0], xyz[1], xyz[2], n->getshapeId() );
  92     node2IdMap.insert( node2IdMap.end(), make_pair( n, ++iN ));
  93   }
  94   if ( iN != nbNodes )
  95     return addMessage("Wrong nb of nodes returned by nodesIterator", /*fatal=*/true);
  96
  97
  98   SMDS_ElemIteratorPtr elemIt;
  99   typedef std::map< const SMDS_MeshElement*, size_t, TIDCompare > TElem2IDMap;
 100
 101   // edges
 102   TElem2IDMap edge2IDMap;
 103   BEGIN_ELEM_WRITE( SMDSEntity_Edge, GmfEdges, edge )
 104     node2IdMap[ edge->GetNode( 0 )],
 105     node2IdMap[ edge->GetNode( 1 )],
 106     END_ELEM_WRITE_ADD_TO_MAP( edge, edge2IDMap );
 107
 108   // quadratic edges
 109   BEGIN_ELEM_WRITE( SMDSEntity_Quad_Edge, GmfEdgesP2, edge )
 110     node2IdMap[ edge->GetNode( 0 )],
 111     node2IdMap[ edge->GetNode( 1 )],
 112     node2IdMap[ edge->GetNode( 2 )],
 113     END_ELEM_WRITE( edge );
 114
 115   // triangles
 116   TElem2IDMap tria2IDMap;
 117   BEGIN_ELEM_WRITE( SMDSEntity_Triangle, GmfTriangles, tria )
 118     node2IdMap[ tria->GetNode( 0 )],
 119     node2IdMap[ tria->GetNode( 1 )],
 120     node2IdMap[ tria->GetNode( 2 )],
 121     END_ELEM_WRITE_ADD_TO_MAP( tria, tria2IDMap );
 122
 123   // quadratic triangles
 124   BEGIN_ELEM_WRITE( SMDSEntity_Quad_Triangle, GmfTrianglesP2, tria )
 125     node2IdMap[ tria->GetNode( 0 )],
 126     node2IdMap[ tria->GetNode( 1 )],
 127     node2IdMap[ tria->GetNode( 2 )],
 128     node2IdMap[ tria->GetNode( 3 )],
 129     node2IdMap[ tria->GetNode( 4 )],
 130     node2IdMap[ tria->GetNode( 5 )],
 131     END_ELEM_WRITE( tria );
 132
 133   // quadrangles
 134   TElem2IDMap quad2IDMap;
 135   BEGIN_ELEM_WRITE( SMDSEntity_Quadrangle, GmfQuadrilaterals, quad )
 136     node2IdMap[ quad->GetNode( 0 )],
 137     node2IdMap[ quad->GetNode( 1 )],
 138     node2IdMap[ quad->GetNode( 2 )],
 139     node2IdMap[ quad->GetNode( 3 )],
 140     END_ELEM_WRITE_ADD_TO_MAP( quad, quad2IDMap );
 141
 142   // bi-quadratic quadrangles
 143   BEGIN_ELEM_WRITE( SMDSEntity_BiQuad_Quadrangle, GmfQuadrilateralsQ2, quad )
 144     node2IdMap[ quad->GetNode( 0 )],
 145     node2IdMap[ quad->GetNode( 3 )],
 146     node2IdMap[ quad->GetNode( 2 )],
 147     node2IdMap[ quad->GetNode( 1 )],
 148     node2IdMap[ quad->GetNode( 7 )],
 149     node2IdMap[ quad->GetNode( 6 )],
 150     node2IdMap[ quad->GetNode( 5 )],
 151     node2IdMap[ quad->GetNode( 4 )],
 152     node2IdMap[ quad->GetNode( 8 )],
 153     END_ELEM_WRITE( quad );
 154
 155   // terahedra
 156   BEGIN_ELEM_WRITE( SMDSEntity_Tetra, GmfTetrahedra, tetra )
 157     node2IdMap[ tetra->GetNode( 0 )],
 158     node2IdMap[ tetra->GetNode( 2 )],
 159     node2IdMap[ tetra->GetNode( 1 )],
 160     node2IdMap[ tetra->GetNode( 3 )],
 161     END_ELEM_WRITE( tetra );
 162
 163   // quadratic terahedra
 164   BEGIN_ELEM_WRITE( SMDSEntity_Quad_Tetra, GmfTetrahedraP2, tetra )
 165     node2IdMap[ tetra->GetNode( 0 )],
 166     node2IdMap[ tetra->GetNode( 2 )],
 167     node2IdMap[ tetra->GetNode( 1 )],
 168     node2IdMap[ tetra->GetNode( 3 )],
 169     node2IdMap[ tetra->GetNode( 6 )],
 170     node2IdMap[ tetra->GetNode( 5 )],
 171     node2IdMap[ tetra->GetNode( 4 )],
 172     node2IdMap[ tetra->GetNode( 7 )],
 173     node2IdMap[ tetra->GetNode( 9 )],
 174     node2IdMap[ tetra->GetNode( 8 )],
 175     END_ELEM_WRITE( tetra );
 176
 177   // pyramids
 178   BEGIN_ELEM_WRITE( SMDSEntity_Pyramid, GmfPyramids, pyra )
 179     node2IdMap[ pyra->GetNode( 0 )],
 180     node2IdMap[ pyra->GetNode( 2 )],
 181     node2IdMap[ pyra->GetNode( 1 )],
 182     node2IdMap[ pyra->GetNode( 3 )],
 183     node2IdMap[ pyra->GetNode( 4 )],
 184     END_ELEM_WRITE( pyra );
 185
 186   // hexahedra
 187   BEGIN_ELEM_WRITE( SMDSEntity_Hexa, GmfHexahedra, hexa )
 188     node2IdMap[ hexa->GetNode( 0 )],
 189     node2IdMap[ hexa->GetNode( 3 )],
 190     node2IdMap[ hexa->GetNode( 2 )],
 191     node2IdMap[ hexa->GetNode( 1 )],
 192     node2IdMap[ hexa->GetNode( 4 )],
 193     node2IdMap[ hexa->GetNode( 7 )],
 194     node2IdMap[ hexa->GetNode( 6 )],
 195     node2IdMap[ hexa->GetNode( 5 )],
 196     END_ELEM_WRITE( hexa );
 197
 198   // tri-quadratic hexahedra
 199   BEGIN_ELEM_WRITE( SMDSEntity_TriQuad_Hexa, GmfHexahedraQ2, hexa )
 200     node2IdMap[ hexa->GetNode( 0 )],
 201     node2IdMap[ hexa->GetNode( 3 )],
 202     node2IdMap[ hexa->GetNode( 2 )],
 203     node2IdMap[ hexa->GetNode( 1 )],
 204     node2IdMap[ hexa->GetNode( 4 )],
 205     node2IdMap[ hexa->GetNode( 7 )],
 206     node2IdMap[ hexa->GetNode( 6 )],
 207     node2IdMap[ hexa->GetNode( 5 )],
 208     node2IdMap[ hexa->GetNode( 11 )],
 209     node2IdMap[ hexa->GetNode( 10 )],
 210     node2IdMap[ hexa->GetNode( 9 )],
 211     node2IdMap[ hexa->GetNode( 8 )],
 212     node2IdMap[ hexa->GetNode( 12 )],
 213     node2IdMap[ hexa->GetNode( 15 )],
 214     node2IdMap[ hexa->GetNode( 14 )],
 215     node2IdMap[ hexa->GetNode( 13 )],
 216     node2IdMap[ hexa->GetNode( 19 )],
 217     node2IdMap[ hexa->GetNode( 18 )],
 218     node2IdMap[ hexa->GetNode( 17 )],
 219     node2IdMap[ hexa->GetNode( 16 )],
 220     node2IdMap[ hexa->GetNode( 20 )],
 221     node2IdMap[ hexa->GetNode( 24 )],
 222     node2IdMap[ hexa->GetNode( 23 )],
 223     node2IdMap[ hexa->GetNode( 22 )],
 224     node2IdMap[ hexa->GetNode( 21 )],
 225     node2IdMap[ hexa->GetNode( 25 )],
 226     node2IdMap[ hexa->GetNode( 26 )],
 227     END_ELEM_WRITE( hexa );
 228
 229   // prism
 230   BEGIN_ELEM_WRITE( SMDSEntity_Penta, GmfPrisms, prism )
 231     node2IdMap[ prism->GetNode( 0 )],
 232     node2IdMap[ prism->GetNode( 2 )],
 233     node2IdMap[ prism->GetNode( 1 )],
 234     node2IdMap[ prism->GetNode( 3 )],
 235     node2IdMap[ prism->GetNode( 5 )],
 236     node2IdMap[ prism->GetNode( 4 )],
 237     END_ELEM_WRITE( prism );
 238
 239
 240   if ( _exportRequiredGroups )
 241   {
 242     // required entities
 243     SMESH_Comment badGroups;
 244     const std::set<SMESHDS_GroupBase*>&      groupSet = myMesh->GetGroups();
 245     std::set<SMESHDS_GroupBase*>::const_iterator grIt = groupSet.begin();
 246     for ( ; grIt != groupSet.end(); ++grIt )
 247     {
 248       const SMESHDS_GroupBase* group = *grIt;
 249       std::string          groupName = group->GetStoreName();
 250       std::string::size_type     pos = groupName.find( "_required_" );
 251       if ( pos == std::string::npos ) continue;
 252
 253       int                    gmfKwd;
 254       SMDSAbs_EntityType smdsEntity;
 255       std::string entity = groupName.substr( pos + strlen("_required_"));
 256       if      ( entity == "Vertices" ) {
 257         gmfKwd   = GmfRequiredVertices;
 258         smdsEntity = SMDSEntity_Node;
 259       }
 260       else if ( entity == "Edges" ) {
 261         gmfKwd   = GmfRequiredEdges;
 262         smdsEntity = SMDSEntity_Edge;
 263       }
 264       else if ( entity == "Triangles" ) {
 265         gmfKwd   = GmfRequiredTriangles;
 266         smdsEntity = SMDSEntity_Triangle;
 267       }
 268       else if ( entity == "Quadrilaterals" ) {
 269         gmfKwd   = GmfRequiredQuadrilaterals;
 270         smdsEntity = SMDSEntity_Quadrangle;
 271       }
 272       else {
 273         addMessage( SMESH_Comment("Invalig gmf entity name: ") << entity, /*fatal=*/false );
 274         continue;
 275       }
 276
 277       // check elem type in the group
 278       int nbOkElems = 0;
 279       SMDS_ElemIteratorPtr elemIt = group->GetElements();
 280       while ( elemIt->more() )
 281         nbOkElems += ( elemIt->next()->GetEntityType() == smdsEntity );
 282
 283       if ( nbOkElems != group->Extent() && nbOkElems == 0 )
 284       {
 285         badGroups << " " << groupName;
 286         continue;
 287       }
 288
 289       // choose a TElem2IDMap
 290       TElem2IDMap* elem2IDMap = 0;
 291       if ( smdsEntity == SMDSEntity_Quadrangle && nbOkElems != myMesh->NbFaces() )
 292         elem2IDMap = & quad2IDMap;
 293       else if ( smdsEntity == SMDSEntity_Triangle && nbOkElems != myMesh->NbFaces() )
 294         elem2IDMap = & tria2IDMap;
 295       else if ( smdsEntity == SMDSEntity_Edge && nbOkElems != myMesh->NbEdges() )
 296         elem2IDMap = & edge2IDMap;
 297
 298       // write the group
 299       GmfSetKwd( meshID, gmfKwd, nbOkElems );
 300       elemIt = group->GetElements();
 301       if ( elem2IDMap )
 302         for ( ; elemIt->more(); )
 303         {
 304           const SMDS_MeshElement* elem = elemIt->next();
 305           if ( elem->GetEntityType() == smdsEntity )
 306             GmfSetLin( meshID, gmfKwd, (*elem2IDMap)[ elem ] );
 307         }
 308       else
 309         for ( int gmfID = 1; elemIt->more(); ++gmfID)
 310         {
 311           const SMDS_MeshElement* elem = elemIt->next();
 312           if ( elem->GetEntityType() == smdsEntity )
 313             GmfSetLin( meshID, gmfKwd, gmfID );
 314         }
 315
 316     } // loop on groups
 317
 318     if ( !badGroups.empty() )
 319       addMessage( SMESH_Comment("Groups of elements of inappropriate geometry:")
 320                   << badGroups, /*fatal=*/false );
 321   }
 322
 323   return DRS_OK;
 324 }