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