ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-02-05 18:24:17 +05:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Add an option to read/write or not groups of required entities
This commit is contained in:
eap 2012-11-14 13:15:59 +00:00
parent e1524c66bc
commit e867938e10
15 changed files with 229 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
idl/SMESH_Gen.idl
View File

@ -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 );

3
idl/SMESH_Mesh.idl
View File

@ -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,

68
src/DriverGMF/DriverGMF_Read.cxx
View File

@ -46,7 +46,8 @@ DriverGMF_MeshCloser::~DriverGMF_MeshCloser()
}
// --------------------------------------------------------------------------------
DriverGMF_Read::DriverGMF_Read():
Driver_SMESHDS_Mesh()
Driver_SMESHDS_Mesh(),
_makeRequiredGroups( true )
{
}
// --------------------------------------------------------------------------------
@ -277,40 +278,43 @@ Driver_Mesh::Status DriverGMF_Read::Perform()
// Read required entities into groups
// get ids of existing groups
std::set< int > groupIDs;
const std::set<SMESHDS_GroupBase*>& groups = myMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
for ( ; grIter != groups.end(); ++grIter )
groupIDs.insert( (*grIter)->GetID() );
if ( groupIDs.empty() ) groupIDs.insert( 0 );
const int kes[4][3] = { { GmfRequiredVertices, SMDSAbs_Node, nodeIDShift },
{ GmfRequiredEdges, SMDSAbs_Edge, edgeIDShift },
{ GmfRequiredTriangles, SMDSAbs_Face, triaIDShift },
{ GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }};
const char* names[4] = { "_required_Vertices" ,
"_required_Edges" ,
"_required_Triangles" ,
"_required_Quadrilaterals" };
for ( int i = 0; i < 4; ++i )
if ( _makeRequiredGroups )
{
int gmfKwd = kes[i][0];
SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
int shift = kes[i][2];
if ( int nb = GmfStatKwd(meshID, gmfKwd))
{
const int newID = *groupIDs.rbegin() + 1;
groupIDs.insert( newID );
SMESHDS_Group* group = new SMESHDS_Group( newID, myMesh, entity );
group->SetStoreName( names[i] );
myMesh->AddGroup( group );
// get ids of existing groups
std::set< int > groupIDs;
const std::set<SMESHDS_GroupBase*>& groups = myMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator grIter = groups.begin();
for ( ; grIter != groups.end(); ++grIter )
groupIDs.insert( (*grIter)->GetID() );
if ( groupIDs.empty() ) groupIDs.insert( 0 );
GmfGotoKwd(meshID, gmfKwd);
for ( int i = 0; i < nb; ++i )
const int kes[4][3] = { { GmfRequiredVertices, SMDSAbs_Node, nodeIDShift },
{ GmfRequiredEdges, SMDSAbs_Edge, edgeIDShift },
{ GmfRequiredTriangles, SMDSAbs_Face, triaIDShift },
{ GmfRequiredQuadrilaterals,SMDSAbs_Face, quadIDShift }};
const char* names[4] = { "_required_Vertices" ,
"_required_Edges" ,
"_required_Triangles" ,
"_required_Quadrilaterals" };
for ( int i = 0; i < 4; ++i )
{
int gmfKwd = kes[i][0];
SMDSAbs_ElementType entity = (SMDSAbs_ElementType) kes[i][1];
int shift = kes[i][2];
if ( int nb = GmfStatKwd(meshID, gmfKwd))
{
GmfGetLin(meshID, gmfKwd, &iN[0] );
group->Add( shift + iN[0] );
const int newID = *groupIDs.rbegin() + 1;
groupIDs.insert( newID );
SMESHDS_Group* group = new SMESHDS_Group( newID, myMesh, entity );
group->SetStoreName( names[i] );
myMesh->AddGroup( group );
GmfGotoKwd(meshID, gmfKwd);
for ( int i = 0; i < nb; ++i )
{
GmfGetLin(meshID, gmfKwd, &iN[0] );
group->Add( shift + iN[0] );
}
}
}
}

7
src/DriverGMF/DriverGMF_Read.hxx
View File

@ -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;
};

149
src/DriverGMF/DriverGMF_Write.cxx
View File

@ -57,7 +57,7 @@ extern "C"
DriverGMF_Write::DriverGMF_Write():
Driver_SMESHDS_Mesh()
Driver_SMESHDS_Mesh(), _exportRequiredGroups( true )
{
}
DriverGMF_Write::~DriverGMF_Write()
@ -233,85 +233,88 @@ Driver_Mesh::Status DriverGMF_Write::Perform()
END_ELEM_WRITE( prism );
// required entities
SMESH_Comment badGroups;
const std::set<SMESHDS_GroupBase*>& groupSet = myMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator grIt = groupSet.begin();
for ( ; grIt != groupSet.end(); ++grIt )
if ( _exportRequiredGroups )
{
const SMESHDS_GroupBase* group = *grIt;
std::string groupName = group->GetStoreName();
std::string::size_type pos = groupName.find( "_required_" );
if ( pos == std::string::npos ) continue;
int gmfKwd;
SMDSAbs_EntityType smdsEntity;
std::string entity = groupName.substr( pos + strlen("_required_"));
if ( entity == "Vertices" ) {
gmfKwd = GmfRequiredVertices;
smdsEntity = SMDSEntity_Node;
}
else if ( entity == "Edges" ) {
gmfKwd = GmfRequiredEdges;
smdsEntity = SMDSEntity_Edge;
}
else if ( entity == "Triangles" ) {
gmfKwd = GmfRequiredTriangles;
smdsEntity = SMDSEntity_Triangle;
}
else if ( entity == "Quadrilaterals" ) {
gmfKwd = GmfRequiredQuadrilaterals;
smdsEntity = SMDSEntity_Quadrangle;
}
else {
addMessage( SMESH_Comment("Invalig gmf entity name: ") << entity, /*fatal=*/false );
continue;
}
// check elem type in the group
int nbOkElems = 0;
SMDS_ElemIteratorPtr elemIt = group->GetElements();
while ( elemIt->more() )
nbOkElems += ( elemIt->next()->GetEntityType() == smdsEntity );
if ( nbOkElems != group->Extent() && nbOkElems == 0 )
// required entities
SMESH_Comment badGroups;
const std::set<SMESHDS_GroupBase*>& groupSet = myMesh->GetGroups();
std::set<SMESHDS_GroupBase*>::const_iterator grIt = groupSet.begin();
for ( ; grIt != groupSet.end(); ++grIt )
{
badGroups << " " << groupName;
continue;
}
const SMESHDS_GroupBase* group = *grIt;
std::string groupName = group->GetStoreName();
std::string::size_type pos = groupName.find( "_required_" );
if ( pos == std::string::npos ) continue;
// choose a TElem2IDMap
TElem2IDMap* elem2IDMap = 0;
if ( smdsEntity == SMDSEntity_Quadrangle && nbOkElems != myMesh->NbFaces() )
elem2IDMap = & quad2IDMap;
else if ( smdsEntity == SMDSEntity_Triangle && nbOkElems != myMesh->NbFaces() )
elem2IDMap = & tria2IDMap;
else if ( smdsEntity == SMDSEntity_Edge && nbOkElems != myMesh->NbEdges() )
elem2IDMap = & edge2IDMap;
// write the group
GmfSetKwd( meshID, gmfKwd, nbOkElems );
elemIt = group->GetElements();
if ( elem2IDMap )
for ( ; elemIt->more(); )
{
const SMDS_MeshElement* elem = elemIt->next();
if ( elem->GetEntityType() == smdsEntity )
GmfSetLin( meshID, gmfKwd, (*elem2IDMap)[ elem ] );
int gmfKwd;
SMDSAbs_EntityType smdsEntity;
std::string entity = groupName.substr( pos + strlen("_required_"));
if ( entity == "Vertices" ) {
gmfKwd = GmfRequiredVertices;
smdsEntity = SMDSEntity_Node;
}
else
for ( int gmfID = 1; elemIt->more(); ++gmfID)
{
const SMDS_MeshElement* elem = elemIt->next();
if ( elem->GetEntityType() == smdsEntity )
GmfSetLin( meshID, gmfKwd, gmfID );
else if ( entity == "Edges" ) {
gmfKwd = GmfRequiredEdges;
smdsEntity = SMDSEntity_Edge;
}
else if ( entity == "Triangles" ) {
gmfKwd = GmfRequiredTriangles;
smdsEntity = SMDSEntity_Triangle;
}
else if ( entity == "Quadrilaterals" ) {
gmfKwd = GmfRequiredQuadrilaterals;
smdsEntity = SMDSEntity_Quadrangle;
}
else {
addMessage( SMESH_Comment("Invalig gmf entity name: ") << entity, /*fatal=*/false );
continue;
}
} // loop on groups
// check elem type in the group
int nbOkElems = 0;
SMDS_ElemIteratorPtr elemIt = group->GetElements();
while ( elemIt->more() )
nbOkElems += ( elemIt->next()->GetEntityType() == smdsEntity );
if ( !badGroups.empty() )
addMessage( SMESH_Comment("Groups of elements of inappropriate geometry:")
<< badGroups, /*fatal=*/false );
if ( nbOkElems != group->Extent() && nbOkElems == 0 )
{
badGroups << " " << groupName;
continue;
}
// choose a TElem2IDMap
TElem2IDMap* elem2IDMap = 0;
if ( smdsEntity == SMDSEntity_Quadrangle && nbOkElems != myMesh->NbFaces() )
elem2IDMap = & quad2IDMap;
else if ( smdsEntity == SMDSEntity_Triangle && nbOkElems != myMesh->NbFaces() )
elem2IDMap = & tria2IDMap;
else if ( smdsEntity == SMDSEntity_Edge && nbOkElems != myMesh->NbEdges() )
elem2IDMap = & edge2IDMap;
// write the group
GmfSetKwd( meshID, gmfKwd, nbOkElems );
elemIt = group->GetElements();
if ( elem2IDMap )
for ( ; elemIt->more(); )
{
const SMDS_MeshElement* elem = elemIt->next();
if ( elem->GetEntityType() == smdsEntity )
GmfSetLin( meshID, gmfKwd, (*elem2IDMap)[ elem ] );
}
else
for ( int gmfID = 1; elemIt->more(); ++gmfID)
{
const SMDS_MeshElement* elem = elemIt->next();
if ( elem->GetEntityType() == smdsEntity )
GmfSetLin( meshID, gmfKwd, gmfID );
}
} // loop on groups
if ( !badGroups.empty() )
addMessage( SMESH_Comment("Groups of elements of inappropriate geometry:")
<< badGroups, /*fatal=*/false );
}
return DRS_OK;
}

9
src/DriverGMF/DriverGMF_Write.hxx
View File

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

9
src/SMESH/SMESH_Mesh.cxx
View File

@ -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();
}

6
src/SMESH/SMESH_Mesh.hxx
View File

@ -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);

65
src/SMESHGUI/SMESHGUI.cxx
View File

@ -226,10 +226,28 @@
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
anInitialPath = QDir::currentPath();
QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
anInitialPath,
filter,
QObject::tr( "SMESH_IMPORT_MESH" ) );
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() ) ) );
@ -598,11 +618,37 @@
else if ( isGMF )
aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
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){
@ -3046,8 +3093,8 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
type = SMDSEntity_TriQuad_Hexa; break;
default: break;
}
if ( type != SMDSEntity_Last )
( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
if ( type != SMDSEntity_Last )
( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
}
else {
SUIT_MessageBox::warning(SMESHGUI::desktop(),

4
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -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>

7
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -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();
}

1
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -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 );

15
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -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 << ")";
}
//=============================================================================

6
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -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,

9
src/SMESH_SWIG/smeshDC.py
View File

@ -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 \
not geom.GetStudyEntry() and \
if 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