]> SALOME platform Git repositories - modules/smesh.git/commitdiff
Salome HOME
0022134: DriverGMF : reading quadratic meshes
authoreap <eap@opencascade.com>
Thu, 28 Feb 2013 11:36:54 +0000 (11:36 +0000)
committereap <eap@opencascade.com>
Thu, 28 Feb 2013 11:36:54 +0000 (11:36 +0000)
  Fix errors of import/export of meshes including both linear and
  quadratic elements.

src/DriverGMF/DriverGMF_Read.cxx
src/DriverGMF/DriverGMF_Write.cxx

index e3fc5d76bd1d60e737cd22e8628a3c3b1172bb4a..0d70c8d5aeea181d2218c555e43e0a7036cf33b0 100644 (file)
@@ -29,6 +29,7 @@
 #include "SMESHDS_Group.hxx"
 #include "SMESHDS_Mesh.hxx"
 #include "SMESH_Comment.hxx"
+#include "SMESH_TypeDefs.hxx"
 
 #include <Basics_Utils.hxx>
 
@@ -69,9 +70,11 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
   if ( !meshID )
   {
     if ( DriverGMF::isExtensionCorrect( myFile ))
-      return addMessage( SMESH_Comment("Can't open for reading ") << myFile, /*fatal=*/true );
+      return addMessage( SMESH_Comment("Can't open for reading ") << myFile,
+                         /*fatal=*/true );
     else
-      return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile, /*fatal=*/true );
+      return addMessage( SMESH_Comment("Not '.mesh' or '.meshb' extension of file ") << myFile,
+                         /*fatal=*/true );
   }
   DriverGMF::MeshCloser aMeshCloser( meshID ); // An object closing GMF mesh at destruction
 
@@ -109,34 +112,33 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
 
   int iN[28]; // 28 - nb nodes in HEX27 (+ 1 for safety :)
 
-  /* Read extra vertices for quadratic edges */
-  std::vector<int> quadNodesAtEdges;
-  int nbQuadEdges = 0;
-  if ( (nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges)) )
-  {
-    quadNodesAtEdges.reserve( nbQuadEdges );
-    GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
-    for ( int i = 1; i <= nbQuadEdges; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
-      quadNodesAtEdges.push_back(iN[2]);
-    }
-  }
-
   /* Read edges */
   const int edgeIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbEdges = GmfStatKwd(meshID, GmfEdges))
   {
-    const bool readQuadNodes = ( nbQuadEdges == nbEdges );
+    // read extra vertices for quadratic edges
+    std::vector<int> quadNodesAtEdges( nbEdges + 1, -1 );
+    if ( int nbQuadEdges = GmfStatKwd(meshID, GmfExtraVerticesAtEdges))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtEdges);
+      for ( int i = 1; i <= nbQuadEdges; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtEdges, &iN[0], &iN[1], &iN[2]);
+        if ( iN[1] >= 1 )
+          quadNodesAtEdges[ iN[0] ] = iN[2];
+      }
+    }
+    // create edges
     GmfGotoKwd(meshID, GmfEdges);
     for ( int i = 1; i <= nbEdges; ++i )
     {
       GmfGetLin(meshID, GmfEdges, &iN[0], &iN[1], &ref);
-      if ( readQuadNodes )
+      const int midN = quadNodesAtEdges[ i ];
+      if ( midN > 0 )
       {
-        const int midN = quadNodesAtEdges[i-1];
         if ( !myMesh->AddEdgeWithID( iN[0], iN[1], midN, edgeIDShift + i ))
-          status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i, 3, iN[0],iN[1],midN);
+          status = storeBadNodeIds( "GmfEdges + GmfExtraVerticesAtEdges",i,
+                                    3, iN[0], iN[1], midN);
       }
       else
       {
@@ -145,47 +147,40 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
       }
     }
   }
-  // the vector of extra vertices at edges won't be used anymore so it is cleared
-  quadNodesAtEdges.clear();
-
-  /* Read extra vertices for quadratic triangles */
-  std::vector< std::vector<int> > quadNodesAtTriangles;
-  int nbQuadTria = 0;
-  if ( (nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtTriangles);
-    quadNodesAtTriangles.reserve( nbQuadTria );
-    std::vector<int> nodes(4);
-    for ( int i = 1; i <= nbQuadTria; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
-                &iN[5]); // iN[5] - preview TRIA7
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtTriangles.push_back(nodes);
-    }
-  }
 
   /* Read triangles */
   const int triaIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbTria = GmfStatKwd(meshID, GmfTriangles))
   {
-    const bool readQuadNodes = (nbQuadTria == nbTria);
+    // read extra vertices for quadratic triangles
+    std::vector< std::vector<int> > quadNodesAtTriangles( nbTria + 1 );
+    if ( int nbQuadTria = GmfStatKwd(meshID, GmfExtraVerticesAtTriangles ))
+    {
+      GmfGotoKwd( meshID, GmfExtraVerticesAtTriangles );
+      for ( int i = 1; i <= nbQuadTria; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtTriangles,
+                  &iN[0], &iN[1], &iN[2], &iN[3], &iN[4],
+                  &iN[5]); // iN[5] - preview TRIA7
+        if ( iN[0] <= nbTria )
+        {
+          std::vector<int>& nodes = quadNodesAtTriangles[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[5+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create triangles
     GmfGotoKwd(meshID, GmfTriangles);
     for ( int i = 1; i <= nbTria; ++i )
     {
       GmfGetLin(meshID, GmfTriangles, &iN[0], &iN[1], &iN[2], &ref);
-      if ( readQuadNodes )
+      std::vector<int>& midN = quadNodesAtTriangles[ i ];
+      if ( midN.size() >= 3 )
       {
-        const std::vector<int>& midN = quadNodesAtTriangles[ i-1 ];
-        if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],  triaIDShift + i ))
-          status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6, 
+        if ( !myMesh->AddFaceWithID( iN[0],iN[1],iN[2], midN[0],midN[1],midN[2],
+                                     triaIDShift + i ))
+          status = storeBadNodeIds( "GmfTriangles + GmfExtraVerticesAtTriangles",i, 6,
                                     iN[0],iN[1],iN[2], midN[0],midN[1],midN[2] );
       }
       else
@@ -193,127 +188,108 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], triaIDShift + i ))
           status = storeBadNodeIds( "GmfTriangles",i, 3, iN[0], iN[1], iN[2] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at triangles won't be used anymore so it is cleared
-  quadNodesAtTriangles.clear();
 
-  /* Read extra vertices for quadratic quadrangles */
-  std::vector< std::vector<int> > quadNodesAtQuadrilaterals;
-  int nbQuadQuad = 0;
-  if ( (nbQuadQuad = GmfStatKwd(meshID, GmfExtraVerticesAtQuadrilaterals)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
-    quadNodesAtQuadrilaterals.reserve( nbQuadQuad );
-    std::vector<int> nodes( 5 );
-    for ( int i = 1; i <= nbQuadQuad; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.push_back(iN[6]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtQuadrilaterals.push_back(nodes);
-    }
-  }
-
- /* Read quadrangles */
+  /* Read quadrangles */
   const int quadIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbQuad = GmfStatKwd(meshID, GmfQuadrilaterals))
   {
-    const bool readQuadNodes = (nbQuadQuad == nbQuad);
+    // read extra vertices for quadratic quadrangles
+    std::vector< std::vector<int> > quadNodesAtQuadrilaterals( nbQuad + 1 );
+    if ( int nbQuadQuad = GmfStatKwd( meshID, GmfExtraVerticesAtQuadrilaterals ))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtQuadrilaterals);
+      for ( int i = 1; i <= nbQuadQuad; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtQuadrilaterals,
+                  &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6]);
+        if ( iN[0] <= nbQuad )
+        {
+          std::vector<int>& nodes = quadNodesAtQuadrilaterals[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[6+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create quadrangles
     GmfGotoKwd(meshID, GmfQuadrilaterals);
     for ( int i = 1; i <= nbQuad; ++i )
     {
       GmfGetLin(meshID, GmfQuadrilaterals, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
-      if ( readQuadNodes )
+      std::vector<int>& midN = quadNodesAtQuadrilaterals[ i ];
+      if ( midN.size() == 8-4 ) // QUAD8
       {
-        const std::vector<int>& midN = quadNodesAtQuadrilaterals[ i-1 ];
-        if ( midN.size() == 4 )
-        {
-          if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
-                                       midN[0], midN[1], midN[2], midN[3],
-                                       quadIDShift + i ))
-            status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
-                                      iN[0], iN[1],iN[2], iN[3],
-                                      midN[0], midN[1], midN[2], midN[3]);
-        }
-        else
-        {
-          if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
-                                       midN[0], midN[1], midN[2], midN[3], midN[4],
-                                       quadIDShift + i ))
-            status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
-                                      iN[0], iN[1],iN[2], iN[3],
-                                      midN[0], midN[1], midN[2], midN[3], midN[4]);
-        }
+        if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
+                                     midN[0], midN[1], midN[2], midN[3],
+                                     quadIDShift + i ))
+          status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 8,
+                                    iN[0], iN[1],iN[2], iN[3],
+                                    midN[0], midN[1], midN[2], midN[3]);
       }
-      else
+      else if ( midN.size() > 8-4 ) // QUAD9
+      {
+        if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3],
+                                     midN[0], midN[1], midN[2], midN[3], midN[4],
+                                     quadIDShift + i ))
+          status = storeBadNodeIds( "GmfQuadrilaterals + GmfExtraVerticesAtQuadrilaterals",i, 9,
+                                    iN[0], iN[1],iN[2], iN[3],
+                                    midN[0], midN[1], midN[2], midN[3], midN[4]);
+      }
+      else // QUAD4
       {
         if ( !myMesh->AddFaceWithID( iN[0], iN[1], iN[2], iN[3], quadIDShift + i ))
           status = storeBadNodeIds( "GmfQuadrilaterals",i, 4, iN[0], iN[1],iN[2], iN[3] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at quadrilaterals won't be used anymore so it is cleared
-  quadNodesAtQuadrilaterals.clear();
 
-  /* Read extra vertices for quadratic tetrahedra */
-  std::vector< std::vector<int> > quadNodesAtTetrahedra;
-  int nbQuadTetra = 0;
-  if ( (nbQuadTetra = GmfStatKwd(meshID, GmfExtraVerticesAtTetrahedra)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
-    quadNodesAtTetrahedra.reserve( nbQuadTetra );
-    std::vector<int> nodes( 6 );
-    for ( int i = 1; i <= nbQuadTetra; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.push_back(iN[6]);
-      nodes.push_back(iN[7]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtTetrahedra.push_back(nodes);
-    }
-  }
   /* Read terahedra */
   const int tetIDShift = myMesh->GetMeshInfo().NbElements();
-  if ( int nbTet = GmfStatKwd(meshID, GmfTetrahedra))
+  if ( int nbTet = GmfStatKwd( meshID, GmfTetrahedra ))
   {
-    const bool readQuadNodes = (nbQuadTetra == nbTet);
+    // read extra vertices for quadratic tetrahedra
+    std::vector< std::vector<int> > quadNodesAtTetrahedra( nbTet + 1 );
+    if ( int nbQuadTetra = GmfStatKwd( meshID, GmfExtraVerticesAtTetrahedra ))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtTetrahedra);
+      for ( int i = 1; i <= nbQuadTetra; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtTetrahedra,
+                  &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &iN[6], &iN[7]);
+        if ( iN[0] <= nbTet )
+        {
+          std::vector<int>& nodes = quadNodesAtTetrahedra[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[7+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create tetrahedra
     GmfGotoKwd(meshID, GmfTetrahedra);
     for ( int i = 1; i <= nbTet; ++i )
     {
       GmfGetLin(meshID, GmfTetrahedra, &iN[0], &iN[1], &iN[2], &iN[3], &ref);
-      if ( readQuadNodes )
+      std::vector<int>& midN = quadNodesAtTetrahedra[ i ];  
+      if ( midN.size() >= 10-4 ) // TETRA10
       {
-        const std::vector<int>& midN = quadNodesAtTetrahedra[ i-1 ];  
         if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], 
-                                       midN[2], midN[1], midN[0], midN[3], midN[5], midN[4], tetIDShift + i ))
-          status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10, iN[0], iN[2], iN[1], iN[3], 
-                                                                midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
+                                       midN[2], midN[1], midN[0], midN[3], midN[5], midN[4],
+                                       tetIDShift + i ))
+          status = storeBadNodeIds( "GmfTetrahedra + GmfExtraVerticesAtTetrahedra",i, 10,
+                                    iN[0], iN[2], iN[1], iN[3], 
+                                    midN[2], midN[1], midN[0], midN[3], midN[5], midN[4] );
       }
-      else
+      else // TETRA4
       {
-        if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ) )
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], tetIDShift + i ))
           status = storeBadNodeIds( "GmfTetrahedra" ,i, 4, iN[0], iN[2], iN[1], iN[3] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at tetrahedra won't be used anymore so it is cleared
-  quadNodesAtTetrahedra.clear();
 
   /* Read pyramids */
   const int pyrIDShift = myMesh->GetMeshInfo().NbElements();
@@ -328,92 +304,58 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
     }
   }
 
-  /* Read extra vertices for quadratic hexahedra */
-  std::vector< std::vector<int> > quadNodesAtHexahedra;
-  int nbQuadHexa = 0;
-  if ( (nbQuadHexa = GmfStatKwd(meshID, GmfExtraVerticesAtHexahedra)) )
-  {
-    GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
-    quadNodesAtHexahedra.reserve( nbQuadHexa );
-    std::vector<int> nodes( 19 );
-    for ( int i = 1; i <= nbQuadHexa; ++i )
-    {
-      GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1],    // Hexa Id, Nb of extra vertices
-                                                     &iN[2], &iN[3], &iN[4], &iN[5],
-                                                     &iN[6], &iN[7], &iN[8], &iN[9],
-                                                     &iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
-                                                     &iN[14], 
-                                                     &iN[15], &iN[16], &iN[17], &iN[18], 
-                                                     &iN[19],
-                                                     &iN[20]);                          // HEXA27
-      nodes.clear();
-      nodes.push_back(iN[2]);
-      nodes.push_back(iN[3]);
-      nodes.push_back(iN[4]);
-      nodes.push_back(iN[5]);
-      nodes.push_back(iN[6]);
-      nodes.push_back(iN[7]);
-      nodes.push_back(iN[8]);
-      nodes.push_back(iN[9]);
-      nodes.push_back(iN[10]);
-      nodes.push_back(iN[11]);
-      nodes.push_back(iN[12]);
-      nodes.push_back(iN[13]);     
-      nodes.push_back(iN[14]);
-      nodes.push_back(iN[15]);
-      nodes.push_back(iN[16]);
-      nodes.push_back(iN[17]);
-      nodes.push_back(iN[18]);
-      nodes.push_back(iN[19]);
-      nodes.push_back(iN[20]);
-      nodes.resize( iN[1] );
-
-      quadNodesAtHexahedra.push_back(nodes);
-    }
-  }
-  
   /* Read hexahedra */
   const int hexIDShift = myMesh->GetMeshInfo().NbElements();
   if ( int nbHex = GmfStatKwd(meshID, GmfHexahedra))
   {
-    const bool readQuadNodes = (nbQuadHexa == nbHex);
+    // read extra vertices for quadratic hexahedra
+    std::vector< std::vector<int> > quadNodesAtHexahedra( nbHex + 1 );
+    if ( int nbQuadHexa = GmfStatKwd( meshID, GmfExtraVerticesAtHexahedra ))
+    {
+      GmfGotoKwd(meshID, GmfExtraVerticesAtHexahedra);
+      for ( int i = 1; i <= nbQuadHexa; ++i )
+      {
+        GmfGetLin(meshID, GmfExtraVerticesAtHexahedra, &iN[0], &iN[1], // Hexa Id, Nb extra vertices
+                  &iN[2], &iN[3], &iN[4], &iN[5],
+                  &iN[6], &iN[7], &iN[8], &iN[9],
+                  &iN[10], &iN[11], &iN[12], &iN[13], // HEXA20
+                  &iN[14],
+                  &iN[15], &iN[16], &iN[17], &iN[18], 
+                  &iN[19],
+                  &iN[20]);                          // HEXA27
+        if ( iN[0] <= nbHex )
+        {
+          std::vector<int>& nodes = quadNodesAtHexahedra[ iN[0] ];
+          nodes.insert( nodes.end(), & iN[2], & iN[20+1] );
+          nodes.resize( iN[1] );
+        }
+      }
+    }
+    // create hexhedra
     GmfGotoKwd(meshID, GmfHexahedra);
     for ( int i = 1; i <= nbHex; ++i )
     {
       GmfGetLin(meshID, GmfHexahedra, &iN[0], &iN[1], &iN[2], &iN[3],
-                                      &iN[4], &iN[5], &iN[6], &iN[7],&ref);
-      if ( readQuadNodes )
+                &iN[4], &iN[5], &iN[6], &iN[7], &ref);
+      std::vector<int>& midN = quadNodesAtHexahedra[ i ];
+      if ( midN.size() == 20-8 ) // HEXA20
       {
-        const std::vector<int>& midN = quadNodesAtHexahedra[ i-1 ];  
-        if ( midN.size() == 12 )  // HEXA20
-        {
-          if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
-                                         iN[4], iN[7], iN[6], iN[5],
-                                         midN[3], midN[2], midN[1], midN[0],
-                                         midN[7], midN[6], midN[5], midN[4],
-                                         midN[8], midN[11], midN[10], midN[9],
-                                         tetIDShift + i ))
-            status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20, 
-                                       iN[0], iN[3], iN[2], iN[1],
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
                                        iN[4], iN[7], iN[6], iN[5],
                                        midN[3], midN[2], midN[1], midN[0],
                                        midN[7], midN[6], midN[5], midN[4],
-                                       midN[8], midN[11], midN[10], midN[9]);
-        }
-        else                      // HEXA27
-        {
-           if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
-                                          iN[4], iN[7], iN[6], iN[5],
-                                          midN[3], midN[2], midN[1], midN[0],
-                                          midN[7], midN[6], midN[5], midN[4],
-                                          midN[8], midN[11], midN[10], midN[9],
-                                          midN[12],
-                                          midN[16], midN[15], midN[14], midN[13],
-                                          midN[17],
-                                          midN[18],                                                        
-                                          tetIDShift + i ))
-            status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27, 
-                                       iN[0], iN[3], iN[2], iN[1],
+                                       midN[8], midN[11], midN[10], midN[9],
+                                       hexIDShift + i ))
+          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 20, 
+                                    iN[0], iN[3], iN[2], iN[1],
+                                    iN[4], iN[7], iN[6], iN[5],
+                                    midN[3], midN[2], midN[1], midN[0],
+                                    midN[7], midN[6], midN[5], midN[4],
+                                    midN[8], midN[11], midN[10], midN[9]);
+      }
+      else if ( midN.size() >= 27-8 ) // HEXA27
+      {
+        if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
                                        iN[4], iN[7], iN[6], iN[5],
                                        midN[3], midN[2], midN[1], midN[0],
                                        midN[7], midN[6], midN[5], midN[4],
@@ -421,20 +363,29 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
                                        midN[12],
                                        midN[16], midN[15], midN[14], midN[13],
                                        midN[17],
-                                       midN[18]);
-        }
+                                       midN[18],
+                                       hexIDShift + i ))
+          status = storeBadNodeIds( "GmfHexahedra + GmfExtraVerticesAtHexahedra",i, 27, 
+                                    iN[0], iN[3], iN[2], iN[1],
+                                    iN[4], iN[7], iN[6], iN[5],
+                                    midN[3], midN[2], midN[1], midN[0],
+                                    midN[7], midN[6], midN[5], midN[4],
+                                    midN[8], midN[11], midN[10], midN[9],
+                                    midN[12],
+                                    midN[16], midN[15], midN[14], midN[13],
+                                    midN[17],
+                                    midN[18]);
       }
-      else
+      else // HEXA8
       {
         if ( !myMesh->AddVolumeWithID( iN[0], iN[3], iN[2], iN[1],
                                        iN[4], iN[7], iN[6], iN[5], hexIDShift + i ) )
           status = storeBadNodeIds( "GmfHexahedra" ,i, 8, iN[0], iN[3], iN[2], iN[1],
-                                                          iN[4], iN[7], iN[6], iN[5] );
+                                    iN[4], iN[7], iN[6], iN[5] );
       }
+      if ( !midN.empty() ) SMESHUtils::FreeVector( midN );
     }
   }
-  // the vector of extra vertices at tetrahedra won't be used anymore so it is cleared
-  quadNodesAtHexahedra.clear();
 
   /* Read prism */
   const int prismIDShift = myMesh->GetMeshInfo().NbElements();
@@ -443,8 +394,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
     GmfGotoKwd(meshID, GmfPrisms);
     for ( int i = 1; i <= nbPrism; ++i )
     {
-      GmfGetLin(meshID, GmfPrisms,
-                &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
+      GmfGetLin(meshID, GmfPrisms, &iN[0], &iN[1], &iN[2], &iN[3], &iN[4], &iN[5], &ref);
       if ( !myMesh->AddVolumeWithID( iN[0], iN[2], iN[1], iN[3], iN[5], iN[4], prismIDShift + i))
         status = storeBadNodeIds( "GmfPrisms",i,
                                   6, iN[0], iN[1],iN[2], iN[3], iN[4], iN[5] );
index 432551e796d2c73a51c613eb0213acce045a4b30..0a3c5ca683972dd79eb23f5f5ebd8c5d547ce70d 100644 (file)
@@ -40,37 +40,42 @@ extern "C"
 #include <vector>
 
 #define BEGIN_ELEM_WRITE( SMDSEntity, GmfKwd, elem )                    \
-  elemIt = myMesh->elementEntityIterator( SMDSEntity );                 \
+  elemIt = elementIterator( SMDSEntity );                               \
   if ( elemIt->more() )                                                 \
   {                                                                     \
-  GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbEntities( SMDSEntity )); \
+  GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbElements( SMDSEntity )); \
   for ( int gmfID = 1; elemIt->more(); ++gmfID )                        \
   {                                                                     \
   const SMDS_MeshElement* elem = elemIt->next();                        \
   GmfSetLin(meshID, GmfKwd,
 
-#define BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity, GmfKwd, elem, nbVertices ) \
-  elemIt = myMesh->elementEntityIterator( SMDSEntity );                 \
+#define BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom, LinType, GmfKwd, elem )   \
+  elemIt = elementIterator( SMDSGeom );                                 \
   if ( elemIt->more() )                                                 \
   {                                                                     \
-  GmfSetKwd(meshID, GmfKwd, myMesh->GetMeshInfo().NbEntities( SMDSEntity )); \
+  int totalNbElems  = myMesh->GetMeshInfo().NbElements( SMDSGeom );     \
+  int nbLinearElems = myMesh->GetMeshInfo().NbElements( LinType );      \
+  if ( totalNbElems - nbLinearElems > 0 )                               \
+  {                                                                     \
+  GmfSetKwd(meshID, GmfKwd, totalNbElems - nbLinearElems);              \
   for ( int gmfID = 1; elemIt->more(); ++gmfID )                        \
   {                                                                     \
   const SMDS_MeshElement* elem = elemIt->next();                        \
-  GmfSetLin(meshID, GmfKwd, gmfID, nbVertices,
+  if ( elem->IsQuadratic() ) {                                          \
+  GmfSetLin(meshID, GmfKwd, gmfID, elem->NbNodes() - elem->NbCornerNodes(),
 
 #define END_ELEM_WRITE( elem )                  \
   elem->getshapeId() );                         \
-  }}                                            \
+  }}
 
 #define END_ELEM_WRITE_ADD_TO_MAP( elem, e2id )         \
   elem->getshapeId() );                                 \
   e2id.insert( e2id.end(), make_pair( elem, gmfID ));   \
-  }}                                                    \
+  }}
 
 #define END_EXTRA_VERTICES_WRITE()           \
   );                                         \
-  }}                                         \
+  }}}}
 
 
 DriverGMF_Write::DriverGMF_Write():
@@ -126,107 +131,73 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
 
   // edges
   TElem2IDMap edge2IDMap;
-  BEGIN_ELEM_WRITE( SMDSEntity_Edge, GmfEdges, edge )
+  BEGIN_ELEM_WRITE( SMDSGeom_EDGE, GmfEdges, edge )
     node2IdMap[ edge->GetNode( 0 )],
     node2IdMap[ edge->GetNode( 1 )],
     END_ELEM_WRITE_ADD_TO_MAP( edge, edge2IDMap );
 
-  // quadratic edges
-  BEGIN_ELEM_WRITE( SMDSEntity_Quad_Edge, GmfEdges, edge )
-    node2IdMap[ edge->GetNode( 0 )],
-    node2IdMap[ edge->GetNode( 1 )],
-    END_ELEM_WRITE( edge );
-
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Edge, GmfExtraVerticesAtEdges, edge, 1 )
+  // nodes of quadratic edges
+  BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_EDGE, SMDSEntity_Edge,
+                              GmfExtraVerticesAtEdges, edge )
     node2IdMap[ edge->GetNode( 2 )]
     END_EXTRA_VERTICES_WRITE();
 
   // triangles
   TElem2IDMap tria2IDMap;
-  BEGIN_ELEM_WRITE( SMDSEntity_Triangle, GmfTriangles, tria )
+  BEGIN_ELEM_WRITE( SMDSGeom_TRIANGLE, GmfTriangles, tria )
     node2IdMap[ tria->GetNode( 0 )],
     node2IdMap[ tria->GetNode( 1 )],
     node2IdMap[ tria->GetNode( 2 )],
     END_ELEM_WRITE_ADD_TO_MAP( tria, tria2IDMap );
 
-  // quadratic triangles
-  BEGIN_ELEM_WRITE( SMDSEntity_Quad_Triangle, GmfTriangles, tria )
-    node2IdMap[ tria->GetNode( 0 )],
-    node2IdMap[ tria->GetNode( 1 )],
-    node2IdMap[ tria->GetNode( 2 )],
-    END_ELEM_WRITE( tria );
-
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Triangle, GmfExtraVerticesAtTriangles, tria, 3 )
+  // nodes of quadratic triangles
+  BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_TRIANGLE, SMDSEntity_Triangle,
+                              GmfExtraVerticesAtTriangles, tria )
     node2IdMap[ tria->GetNode( 3 )],
     node2IdMap[ tria->GetNode( 4 )],
     node2IdMap[ tria->GetNode( 5 )]
+    //node2IdMap[ tria->GetNodeWrap( 6 )] // for TRIA7
     END_EXTRA_VERTICES_WRITE();
 
   // quadrangles
   TElem2IDMap quad2IDMap;
-  BEGIN_ELEM_WRITE( SMDSEntity_Quadrangle, GmfQuadrilaterals, quad )
+  BEGIN_ELEM_WRITE( SMDSGeom_QUADRANGLE, GmfQuadrilaterals, quad )
     node2IdMap[ quad->GetNode( 0 )],
     node2IdMap[ quad->GetNode( 1 )],
     node2IdMap[ quad->GetNode( 2 )],
     node2IdMap[ quad->GetNode( 3 )],
     END_ELEM_WRITE_ADD_TO_MAP( quad, quad2IDMap );
 
-  // quadratic quadrangles
-  BEGIN_ELEM_WRITE( SMDSEntity_Quad_Quadrangle, GmfQuadrilaterals, quad )
-    node2IdMap[ quad->GetNode( 0 )],
-    node2IdMap[ quad->GetNode( 1 )],
-    node2IdMap[ quad->GetNode( 2 )],
-    node2IdMap[ quad->GetNode( 3 )],
-    END_ELEM_WRITE( quad );
-
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Quadrangle, GmfExtraVerticesAtQuadrilaterals, quad, 4 )
-    node2IdMap[ quad->GetNode( 4 )],
-    node2IdMap[ quad->GetNode( 5 )],
-    node2IdMap[ quad->GetNode( 6 )],
-    node2IdMap[ quad->GetNode( 7 )]
-    END_EXTRA_VERTICES_WRITE();
-
-  // bi-quadratic quadrangles
-  BEGIN_ELEM_WRITE( SMDSEntity_BiQuad_Quadrangle, GmfQuadrilaterals, quad )
-    node2IdMap[ quad->GetNode( 0 )],
-    node2IdMap[ quad->GetNode( 1 )],
-    node2IdMap[ quad->GetNode( 2 )],
-    node2IdMap[ quad->GetNode( 3 )],
-    END_ELEM_WRITE( quad );
-
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_BiQuad_Quadrangle, GmfExtraVerticesAtQuadrilaterals, quad, 5 )
+  // nodes of quadratic quadrangles
+  BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_QUADRANGLE, SMDSEntity_Quadrangle,
+                              GmfExtraVerticesAtQuadrilaterals, quad )
     node2IdMap[ quad->GetNode( 4 )],
     node2IdMap[ quad->GetNode( 5 )],
     node2IdMap[ quad->GetNode( 6 )],
     node2IdMap[ quad->GetNode( 7 )],
-    node2IdMap[ quad->GetNode( 8 )]
+    node2IdMap[ quad->GetNodeWrap( 8 )] // for QUAD9
     END_EXTRA_VERTICES_WRITE();
 
   // terahedra
-  BEGIN_ELEM_WRITE( SMDSEntity_Tetra, GmfTetrahedra, tetra )
+  BEGIN_ELEM_WRITE( SMDSGeom_TETRA, GmfTetrahedra, tetra )
     node2IdMap[ tetra->GetNode( 0 )],
     node2IdMap[ tetra->GetNode( 2 )],
     node2IdMap[ tetra->GetNode( 1 )],
     node2IdMap[ tetra->GetNode( 3 )],
     END_ELEM_WRITE( tetra );
 
-  // quadratic terahedra
-  BEGIN_ELEM_WRITE( SMDSEntity_Quad_Tetra, GmfTetrahedra, tetra )
-    node2IdMap[ tetra->GetNode( 0 )],
-    node2IdMap[ tetra->GetNode( 2 )],
-    node2IdMap[ tetra->GetNode( 1 )],
-    node2IdMap[ tetra->GetNode( 3 )],
-    END_ELEM_WRITE( tetra );
-    
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Tetra, GmfExtraVerticesAtTetrahedra, tetra, 6 )
+  // nodes of quadratic terahedra
+  BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_TETRA, SMDSEntity_Tetra,
+                              GmfExtraVerticesAtTetrahedra, tetra )
     node2IdMap[ tetra->GetNode( 6 )],
     node2IdMap[ tetra->GetNode( 5 )],
     node2IdMap[ tetra->GetNode( 4 )],
     node2IdMap[ tetra->GetNode( 7 )],
     node2IdMap[ tetra->GetNode( 9 )],
     node2IdMap[ tetra->GetNode( 8 )]
+    //node2IdMap[ tetra->GetNodeWrap( 10 )], // for TETRA11
     END_EXTRA_VERTICES_WRITE();
-    
+
   // pyramids
   BEGIN_ELEM_WRITE( SMDSEntity_Pyramid, GmfPyramids, pyra )
     node2IdMap[ pyra->GetNode( 0 )],
@@ -237,7 +208,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
     END_ELEM_WRITE( pyra );
 
   // hexahedra
-  BEGIN_ELEM_WRITE( SMDSEntity_Hexa, GmfHexahedra, hexa )
+  BEGIN_ELEM_WRITE( SMDSGeom_HEXA, GmfHexahedra, hexa )
     node2IdMap[ hexa->GetNode( 0 )],
     node2IdMap[ hexa->GetNode( 3 )],
     node2IdMap[ hexa->GetNode( 2 )],
@@ -248,65 +219,28 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
     node2IdMap[ hexa->GetNode( 5 )],
     END_ELEM_WRITE( hexa );
 
-  // quadratic hexahedra
-  BEGIN_ELEM_WRITE( SMDSEntity_Quad_Hexa, GmfHexahedra, hexa )
-    node2IdMap[ hexa->GetNode( 0 )],
-    node2IdMap[ hexa->GetNode( 3 )],
-    node2IdMap[ hexa->GetNode( 2 )],
-    node2IdMap[ hexa->GetNode( 1 )],
-    node2IdMap[ hexa->GetNode( 4 )],
-    node2IdMap[ hexa->GetNode( 7 )],
-    node2IdMap[ hexa->GetNode( 6 )],
-    node2IdMap[ hexa->GetNode( 5 )],
-    END_ELEM_WRITE( hexa );
-    
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_Quad_Hexa, GmfExtraVerticesAtHexahedra, hexa, 12 )
-    node2IdMap[ hexa->GetNode( 11 )],
+  // nodes of quadratic hexahedra
+  BEGIN_EXTRA_VERTICES_WRITE( SMDSGeom_HEXA, SMDSEntity_Hexa,
+                              GmfExtraVerticesAtHexahedra, hexa )
+    node2IdMap[ hexa->GetNode( 11 )], // HEXA20
     node2IdMap[ hexa->GetNode( 10 )],
-    node2IdMap[ hexa->GetNode( 9 )],
-    node2IdMap[ hexa->GetNode( 8 )],
+    node2IdMap[ hexa->GetNode(  9 )],
+    node2IdMap[ hexa->GetNode(  8 )],
     node2IdMap[ hexa->GetNode( 15 )],
     node2IdMap[ hexa->GetNode( 14 )],
     node2IdMap[ hexa->GetNode( 13 )],
     node2IdMap[ hexa->GetNode( 12 )],
     node2IdMap[ hexa->GetNode( 16 )],
     node2IdMap[ hexa->GetNode( 19 )],
-    node2IdMap[ hexa->GetNode( 18 )],
-    node2IdMap[ hexa->GetNode( 17 )]
-    END_EXTRA_VERTICES_WRITE();
-    
-  // tri-quadratic hexahedra
-  BEGIN_ELEM_WRITE( SMDSEntity_TriQuad_Hexa, GmfHexahedra, hexa )
-    node2IdMap[ hexa->GetNode( 0 )],
-    node2IdMap[ hexa->GetNode( 3 )],
-    node2IdMap[ hexa->GetNode( 2 )],
-    node2IdMap[ hexa->GetNode( 1 )],
-    node2IdMap[ hexa->GetNode( 4 )],
-    node2IdMap[ hexa->GetNode( 7 )],
-    node2IdMap[ hexa->GetNode( 6 )],
-    node2IdMap[ hexa->GetNode( 5 )],
-    END_ELEM_WRITE( hexa );
-    
-  BEGIN_EXTRA_VERTICES_WRITE( SMDSEntity_TriQuad_Hexa, GmfExtraVerticesAtHexahedra, hexa, 19 )
-    node2IdMap[ hexa->GetNode( 11 )],
-    node2IdMap[ hexa->GetNode( 10 )],
-    node2IdMap[ hexa->GetNode( 9 )],
-    node2IdMap[ hexa->GetNode( 8 )],
-    node2IdMap[ hexa->GetNode( 15 )],
-    node2IdMap[ hexa->GetNode( 14 )],
-    node2IdMap[ hexa->GetNode( 13 )],
-    node2IdMap[ hexa->GetNode( 12 )],
-    node2IdMap[ hexa->GetNode( 16 )],
-    node2IdMap[ hexa->GetNode( 19 )],
-    node2IdMap[ hexa->GetNode( 18 )],
-    node2IdMap[ hexa->GetNode( 17 )],
-    node2IdMap[ hexa->GetNode( 20 )],
-    node2IdMap[ hexa->GetNode( 24 )],
-    node2IdMap[ hexa->GetNode( 23 )],
-    node2IdMap[ hexa->GetNode( 22 )],
-    node2IdMap[ hexa->GetNode( 21 )],
-    node2IdMap[ hexa->GetNode( 25 )],
-    node2IdMap[ hexa->GetNode( 26 )]
+    node2IdMap[ hexa->GetNodeWrap( 18 )], // + HEXA27
+    node2IdMap[ hexa->GetNodeWrap( 17 )],
+    node2IdMap[ hexa->GetNodeWrap( 20 )],
+    node2IdMap[ hexa->GetNodeWrap( 24 )],
+    node2IdMap[ hexa->GetNodeWrap( 23 )],
+    node2IdMap[ hexa->GetNodeWrap( 22 )],
+    node2IdMap[ hexa->GetNodeWrap( 21 )],
+    node2IdMap[ hexa->GetNodeWrap( 25 )],
+    node2IdMap[ hexa->GetNodeWrap( 26 )]
     END_EXTRA_VERTICES_WRITE();
 
   // prism
@@ -405,3 +339,22 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
 
   return DRS_OK;
 }
+
+//================================================================================
+/*!
+ * \brief Returns an iterator on elements of a certain type
+ */
+//================================================================================
+
+SMDS_ElemIteratorPtr DriverGMF_Write::elementIterator(SMDSAbs_ElementType type)
+{
+  return myMesh->elementsIterator(type);
+}
+SMDS_ElemIteratorPtr DriverGMF_Write::elementIterator(SMDSAbs_EntityType type) 
+{
+  return myMesh->elementEntityIterator(type);
+}
+SMDS_ElemIteratorPtr DriverGMF_Write::elementIterator(SMDSAbs_GeometryType type)
+{
+  return myMesh->elementGeomIterator(type);
+}