21382: EDF 1985 SMESH: Read/write of .mesh files (GMF format)

Add an option to read/write or not groups of required entities

idl/SMESH_Gen.idl

@@ -240,8 +240,11 @@ module SMESH
 
     /*!
      * Create Mesh object importing data from given GMF file
+     *  \param theFileName - a name of file to import
+     *  \param theMakeRequiredGroups - if true, groups of required entities will be created
      */
     SMESH_Mesh CreateMeshesFromGMF( in string               theFileName,
+                                    in boolean              theMakeRequiredGroups,
                                     out SMESH::ComputeError theError)
       raises ( SALOME::SALOME_Exception );
 

idl/SMESH_Mesh.idl

@@ -663,7 +663,8 @@ module SMESH
                      in string         file,
                      in boolean        overwrite ) raises (SALOME::SALOME_Exception);
     void ExportGMF( in SMESH_IDSource  meshPart, 
-                    in string          file ) raises (SALOME::SALOME_Exception);
+                    in string          file,
+                    in boolean         withRequiredGroups) raises (SALOME::SALOME_Exception);
     void ExportPartToDAT( in SMESH_IDSource meshPart, 
                           in string         file ) raises (SALOME::SALOME_Exception);
     void ExportPartToUNV( in SMESH_IDSource meshPart, 

src/DriverGMF/DriverGMF_Read.cxx

@@ -46,7 +46,8 @@ DriverGMF_MeshCloser::~DriverGMF_MeshCloser()
 }
 // --------------------------------------------------------------------------------
 DriverGMF_Read::DriverGMF_Read():
-  Driver_SMESHDS_Mesh()
+  Driver_SMESHDS_Mesh(),
+  _makeRequiredGroups( true )
 {
 }
 // --------------------------------------------------------------------------------
@@ -277,6 +278,8 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
 
   // Read required entities into groups
 
+  if ( _makeRequiredGroups )
+  {
     // get ids of existing groups
     std::set< int > groupIDs;
     const std::set<SMESHDS_GroupBase*>& groups = myMesh->GetGroups();
@@ -314,6 +317,7 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
         }
       }
     }
+  }
 
   return status;
 }

src/DriverGMF/DriverGMF_Read.hxx

@@ -45,12 +45,19 @@ public:
   DriverGMF_Read();
   ~DriverGMF_Read();
 
+  void SetMakeRequiredGroups( bool theMakeRequiredGroups )
+  {
+    _makeRequiredGroups = theMakeRequiredGroups;
+  }
+
   virtual Status Perform();
 
  private:
 
   Status storeBadNodeIds(const char* gmfKwd, int elemNb, int nb, ...);
 
+  bool _makeRequiredGroups;
+
 };
 
 

src/DriverGMF/DriverGMF_Write.cxx

@@ -57,7 +57,7 @@ extern "C"
 
 
 DriverGMF_Write::DriverGMF_Write():
-  Driver_SMESHDS_Mesh()
+  Driver_SMESHDS_Mesh(), _exportRequiredGroups( true )
 {
 }
 DriverGMF_Write::~DriverGMF_Write()
@@ -233,6 +233,8 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
     END_ELEM_WRITE( prism );
 
 
+  if ( _exportRequiredGroups )
+  {
     // required entities
     SMESH_Comment badGroups;
     const std::set<SMESHDS_GroupBase*>&      groupSet = myMesh->GetGroups();
@@ -312,6 +314,7 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
     if ( !badGroups.empty() )
       addMessage( SMESH_Comment("Groups of elements of inappropriate geometry:")
                   << badGroups, /*fatal=*/false );
+  }
 
   return DRS_OK;
 }

src/DriverGMF/DriverGMF_Write.hxx

@@ -42,7 +42,16 @@ public:
   DriverGMF_Write();
   ~DriverGMF_Write();
 
+  void SetExportRequiredGroups( bool toExport )
+  {
+    _exportRequiredGroups = toExport;
+  }
+
   virtual Status Perform();
+
+ private:
+
+  bool _exportRequiredGroups;
 };
 
 /*!

src/SMESH/SMESH_Mesh.cxx

@@ -545,11 +545,13 @@ int SMESH_Mesh::CGNSToMesh(const char*  theFileName,
  */
 //================================================================================
 
-SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName)
+SMESH_ComputeErrorPtr SMESH_Mesh::GMFToMesh(const char* theFileName,
+                                            bool        theMakeRequiredGroups)
 {
   DriverGMF_Read myReader;
   myReader.SetMesh(_myMeshDS);
   myReader.SetFile(theFileName);
+  myReader.SetMakeRequiredGroups( theMakeRequiredGroups );
   myReader.Perform();
   //theMeshName = myReader.GetMeshName();
 
@@ -1419,11 +1421,14 @@ void SMESH_Mesh::ExportCGNS(const char *        file,
 //================================================================================
 
 void SMESH_Mesh::ExportGMF(const char *        file,
-                           const SMESHDS_Mesh* meshDS)
+                           const SMESHDS_Mesh* meshDS,
+                           bool                withRequiredGroups)
 {
   DriverGMF_Write myWriter;
   myWriter.SetFile( file );
   myWriter.SetMesh( const_cast<SMESHDS_Mesh*>( meshDS ));
+  myWriter.SetExportRequiredGroups( withRequiredGroups );
+
   myWriter.Perform();
 }
 

src/SMESH/SMESH_Mesh.hxx

@@ -122,7 +122,8 @@ public:
 
   int CGNSToMesh(const char* theFileName, const int theMeshIndex, std::string& theMeshName);
   
-  SMESH_ComputeErrorPtr GMFToMesh(const char* theFileName);
+  SMESH_ComputeErrorPtr GMFToMesh(const char* theFileName,
+                                  bool        theMakeRequiredGroups);
 
   SMESH_Hypothesis::Hypothesis_Status
   AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId)
@@ -244,7 +245,8 @@ public:
   void ExportCGNS(const char *        file,
                   const SMESHDS_Mesh* mesh);
   void ExportGMF(const char *        file,
-                 const SMESHDS_Mesh* mesh);
+                 const SMESHDS_Mesh* mesh,
+                 bool                withRequiredGroups);
   void ExportSAUV(const char *file, 
                   const char* theMeshName = NULL, 
                   bool theAutoGroups = true) throw(SALOME_Exception);

src/SMESHGUI/SMESHGUI.cxx

@@ -226,10 +226,28 @@
     if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
       anInitialPath = QDir::currentPath();
 
-    QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
+    QStringList filenames;
+    bool toCreateGroups = true;
+
+    // if ( theCommandID == 118 ) { // GMF
+    //   SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
+    //     ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
+    //   fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
+    //   fd->setNameFilters( filter );
+    //   fd->SetChecked( true );
+    //   if ( fd->exec() )
+    //     filenames << fd->selectedFile();
+    //   toCreateGroups = fd->IsChecked();
+
+    //   delete fd;
+    // }
+    // else
+    {
+      filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
                                                   anInitialPath,
                                                   filter,
                                                   QObject::tr( "SMESH_IMPORT_MESH" ) );
+    }
     if ( filenames.count() > 0 ) {
       SUIT_OverrideCursor wc;
       _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
@@ -308,7 +326,9 @@
               // GMF format
               SMESH::ComputeError_var res;
               aMeshes->length( 1 );
-              aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(), res.out() );
+              aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toLatin1().constData(),
+                                                                  toCreateGroups,
+                                                                  res.out() );
               if ( res->code != SMESH::DRS_OK ) {
                 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
                                arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
@@ -603,6 +623,32 @@
                                             anInitialPath + QString("/") + aMeshName,
                                             aFilter, aTitle, false);
     }
+    // else if ( isGMF )// Export to GMF
+    // {
+      // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
+      //   ( SMESHGUI::desktop(), false, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
+      // QStringList filters;
+      // filters << QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)"
+      //         << QObject::tr( "GMF_BINARY_FILES_FILTER" )  + " (*.meshb)";
+      // fd->setWindowTitle( aTitle );
+      // fd->setNameFilters( filters );
+
+      // if ( !aMeshOrGroup->_is_equivalent( aMesh ))
+      //   toCreateGroups = false;
+      // else
+      //   toCreateGroups = ( aMesh->NbGroups() > 0 );
+
+      // fd->SetChecked( true );
+      // if ( !anInitialPath.isEmpty() )
+      //   fd->setDirectory( anInitialPath );
+      // fd->selectFile(aMeshName);
+
+      // if ( fd->exec() )
+      //   aFilename = fd->selectedFile();
+      // toCreateGroups = fd->IsChecked();
+
+      // delete fd;
+    // }
     else if ( isCGNS )// Export to CGNS
     {
       SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
@@ -848,7 +894,8 @@
         }
         else if ( isGMF )
         {
-          aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data() );
+          toCreateGroups = true;
+          aMesh->ExportGMF( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups );
         }
       }
       catch (const SALOME::SALOME_Exception& S_ex){

src/SMESHGUI/SMESH_msg_en.ts

@@ -1273,6 +1273,10 @@ Please enter correct values and try again</translation>
         <source>SMESH_AUTO_GROUPS</source>
         <translation>Automatically create groups</translation>
     </message>
+    <message>
+        <source>SMESH_REQUIRED_GROUPS</source>
+        <translation>Create groups of required entities</translation>
+    </message>
     <message>
         <source>SMESH_AVAILABLE</source>
         <translation>Available</translation>

src/SMESH_I/SMESH_Gen_i.cxx

@@ -1232,6 +1232,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
 
 SMESH::SMESH_Mesh_ptr
 SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
+                                  CORBA::Boolean          theMakeRequiredGroups,
                                   SMESH::ComputeError_out theError)
     throw ( SALOME::SALOME_Exception )
 {
@@ -1254,12 +1255,14 @@ SMESH_Gen_i::CreateMeshesFromGMF( const char*             theFileName,
     aStudyBuilder->CommitCommand();
     if ( !aSO->_is_nil() ) {
       // Update Python script
-      TPythonDump() << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'" << theFileName << "')";
+      TPythonDump() << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'"
+                    << theFileName << "', "
+                    << theMakeRequiredGroups << " )";
     }
   }
   SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
   ASSERT( aServant );
-  theError = aServant->ImportGMFFile( theFileName );
+  theError = aServant->ImportGMFFile( theFileName, theMakeRequiredGroups );
   aServant->GetImpl().GetMeshDS()->Modified();
   return aMesh._retn();
 }

src/SMESH_I/SMESH_Gen_i.hxx

@@ -263,6 +263,7 @@ public:
 
   //  Create a mesh and import data from a GMF file
   SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char*             theFileName,
+                                             CORBA::Boolean          theMakeRequiredGroups,
                                              SMESH::ComputeError_out theError)
     throw ( SALOME::SALOME_Exception );
 

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -483,12 +483,13 @@ int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
  */
 //================================================================================
 
-SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName )
+SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
+                                                  bool        theMakeRequiredGroups )
   throw (SALOME::SALOME_Exception)
 {
   SMESH_ComputeErrorPtr error;
   try {
-    error = _impl->GMFToMesh( theFileName );
+    error = _impl->GMFToMesh( theFileName, theMakeRequiredGroups );
   }
   catch ( std::bad_alloc& exc ) {
     error = SMESH_ComputeError::New( Driver_Mesh::DRS_FAIL, "std::bad_alloc raised" );
@@ -3039,7 +3040,8 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
 //================================================================================
 
 void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
-                             const char*                 file)
+                             const char*                 file,
+                             bool                        withRequiredGroups)
   throw (SALOME::SALOME_Exception)
 {
   Unexpect aCatch(SALOME_SalomeException);
@@ -3049,9 +3051,12 @@ void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
   PrepareForWriting(file,/*overwrite=*/true);
 
   SMESH_MeshPartDS partDS( meshPart );
-  _impl->ExportGMF(file, &partDS);
+  _impl->ExportGMF(file, &partDS, withRequiredGroups);
 
-  TPythonDump() << _this() << ".ExportGMF( " << meshPart<< ", r'" << file << "')";
+  TPythonDump() << _this() << ".ExportGMF( "
+                << meshPart<< ", r'"
+                << file << "', "
+                << withRequiredGroups << ")";
 }
 
 //=============================================================================

src/SMESH_I/SMESH_Mesh_i.hxx

@@ -198,7 +198,8 @@ public:
   int ImportSTLFile( const char* theFileName )
     throw (SALOME::SALOME_Exception);
 
-  SMESH::ComputeError* ImportGMFFile( const char* theFileName )
+  SMESH::ComputeError* ImportGMFFile( const char* theFileName,
+                                      bool        theMakeRequiredGroups)
     throw (SALOME::SALOME_Exception);
 
   /*!
@@ -249,7 +250,8 @@ public:
                   const char*               file,
                   CORBA::Boolean            overwrite) throw (SALOME::SALOME_Exception);
   void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
-                 const char*               file) throw (SALOME::SALOME_Exception);
+                 const char*               file,
+                 CORBA::Boolean            withRequiredGroups) throw (SALOME::SALOME_Exception);
 
   void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
                        const char*               file,

src/SMESH_SWIG/smeshDC.py

@@ -255,8 +255,7 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo):
 def AssureGeomPublished(mesh, geom, name=''):
     if not isinstance( geom, geompyDC.GEOM._objref_GEOM_Object ):
         return
-    if not geom.IsSame( mesh.geom ) and \
+    if not geom.GetStudyEntry() and \
-           not geom.GetStudyEntry() and \
            mesh.smeshpyD.GetCurrentStudy():
         ## set the study
         studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId()
@@ -508,7 +507,9 @@ class smeshDC(SMESH._objref_SMESH_Gen):
     #  @return [ an instance of Mesh class, SMESH::ComputeError ]
     #  @ingroup l2_impexp
     def CreateMeshesFromGMF( self, theFileName ):
-        aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self,theFileName)
+        aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self,
+                                                                        theFileName,
+                                                                        True)
         if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment
         return Mesh(self, self.geompyD, aSmeshMesh), error
 
@@ -1482,7 +1483,7 @@ class Mesh:
             meshPart = meshPart.mesh
         elif not meshPart:
             meshPart = self.mesh
-        self.mesh.ExportGMF(meshPart, f)
+        self.mesh.ExportGMF(meshPart, f, True)
 
     ## Deprecated, used only for compatibility! Please, use ExportToMEDX() method instead.
     #  Exports the mesh in a file in MED format and chooses the \a version of MED format