// in shape_array listOfSubShape)
// raises (SALOME::SALOME_Exception);
-
+ /**
+ * Import a mesh from a file.
+ * @param fileName file name to be imported.
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ * @param studyId The id of the current study.
+ */
+ SMESH_Mesh Import(in long studyId, in string fileName, in string fileType);
};
};
raises (SALOME::SALOME_Exception);
/*!
- * Export Mesh with DAT and MED Formats
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
*/
- void ExportDAT( in string file )
- raises (SALOME::SALOME_Exception);
- void ExportMED( in string file )
- raises (SALOME::SALOME_Exception);
- void ExportUNV( in string file )
+ void Export( in string fileName, in string fileType )
raises (SALOME::SALOME_Exception);
/*!
{
myDocument = aDoc;
}
+
+void Document_Reader::Read()
+{
+ int myMeshId = myDocument->NewMesh();
+ SMDS_Mesh * myMesh = myDocument->GetMesh(myMeshId);
+ myReader->SetMesh(myMesh);
+ myReader->SetFile(myFile);
+ myReader->Read();
+}
+
+Document_Reader::Document_Reader(Mesh_Reader* reader): myReader(reader)
+{
+}
#define _INCLUDE_DOCUMENT_READER
#include "SMESHDS_Document.hxx"
+#include "Mesh_Reader.h"
#include <string>
class Document_Reader
{
public:
- virtual void Read() = 0;
+ virtual void Read();
void SetFile(string);
void SetDocument(SMESHDS_Document *);
+ Document_Reader(Mesh_Reader*);
protected:
- SMESHDS_Document * myDocument;
+ SMESHDS_Document * myDocument;
string myFile;
+
+ private:
+ Mesh_Reader* myReader;
};
#endif
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-//
-//
-//
-// File : Document_Writer.cxx
-// Module : SMESH
-using namespace std;
#include "Document_Writer.h"
+#include "utilities.h"
void Document_Writer::SetFile(string aFile)
{
{
myDocument = aDoc;
}
+
+void Document_Writer::Write()
+{
+ SCRUTE(myFile);
+ SMESHDS_Mesh * myMesh;
+ int nb_of_meshes = myDocument->NbMeshes(); //voir avec Yves
+ SCRUTE(nb_of_meshes);
+
+ int numero = 0;
+
+ myDocument->InitMeshesIterator();
+ while(myDocument->MoreMesh())
+ {
+ numero++;
+ myMesh = myDocument->NextMesh();
+ myWriter->SetMesh(myMesh);
+ myWriter->SetFile(myFile);
+ myWriter->SetMeshId(numero);
+ myWriter->Add();
+ }
+}
+
+Document_Writer::Document_Writer(Mesh_Writer* writer): myWriter(writer)
+{
+}
#define _INCLUDE_DOCUMENT_WRITER
#include "SMESHDS_Document.hxx"
+#include "Mesh_Writer.h"
#include <string>
class Document_Writer
{
- public:virtual void Write() = 0;
+ public:virtual void Write();
void SetFile(string);
void SetDocument(SMESHDS_Document *);
+ Document_Writer(Mesh_Writer* );
- protected: SMESHDS_Document * myDocument;
+ protected:
+ SMESHDS_Document * myDocument;
string myFile;
+ Mesh_Writer * myWriter;
};
#endif
@COMMENCE@
# header files
-EXPORT_HEADERS= Document_Reader.h Document_Writer.h Mesh_Reader.h Mesh_Writer.h
+EXPORT_HEADERS = \
+ SMESHDriver.h \
+ Document_Reader.h \
+ Document_Writer.h \
+ Mesh_Reader.h \
+ Mesh_Writer.h
# Libraries targets
LIB = libMeshDriver.la
-LIB_SRC = Document_Reader.cxx Document_Writer.cxx Mesh_Reader.cxx Mesh_Writer.cxx
+LIB_SRC = \
+ SMESHDriver.cxx \
+ Document_Reader.cxx \
+ Document_Writer.cxx
+# Mesh_Reader.cxx \
+# Mesh_Writer.cxx \
LIB_CLIENT_IDL =
-// SMESH Driver : implementaion of driver for reading and writing
+// SMESH Driver : implementation of driver for reading and writing
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-//
-//
-//
-// File : SMESHDriver.cxx
-// Module : SMESH
-using namespace std;
#include "SMESHDriver.h"
#include <dlfcn.h>
#include <utilities.h>
-//A enlever
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMDS_Mesh.h"
-#include "DriverMED_W_SMESHDS_Document.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverMED_W_SMDS_Mesh.h"
-
-#include "DriverDAT_R_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Mesh.h"
-#include "DriverDAT_R_SMDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Document.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMDS_Mesh.h"
-//
-
-Document_Reader* SMESHDriver::GetDocumentReader(string Extension, string Class) {
- if (Extension==string("MED")) {
- DriverMED_R_SMESHDS_Document* myDriver = new DriverMED_R_SMESHDS_Document();
- return (myDriver);
- }
- else if (Extension==string("DAT")) {
- DriverDAT_R_SMESHDS_Document* myDriver = new DriverDAT_R_SMESHDS_Document();
- return (myDriver);
- }
- else {
- MESSAGE("No driver known for this extension");
- return (Document_Reader*)NULL;
- }
-
-
+Document_Reader* SMESHDriver::GetDocumentReader(string Extension)
+{
+ // if there is not document reader in the driver create a default
+ // one with the mesh reader.
+ Document_Reader * docReader=
+ (Document_Reader*)getMeshDocumentDriver(Extension);
+
+ if(docReader==NULL)
+ {
+ Mesh_Reader * reader=GetMeshReader(Extension);
+ if(reader==NULL)
+ {
+ MESSAGE("No driver known for this extension");
+ return NULL;
+ }
+ return new Document_Reader(reader);
+ }
+ else return docReader;
}
-Document_Writer* SMESHDriver::GetDocumentWriter(string Extension, string Class) {
- if (Extension==string("MED")) {
- DriverMED_W_SMESHDS_Document* myDriver = new DriverMED_W_SMESHDS_Document();
- return (myDriver);
- }
- else if (Extension==string("DAT")) {
- DriverDAT_W_SMESHDS_Document* myDriver = new DriverDAT_W_SMESHDS_Document();
- return (myDriver);
- }
- else {
- MESSAGE("No driver known for this extension");
- return (Document_Writer*)NULL;
- }
-
-
+Document_Writer* SMESHDriver::GetDocumentWriter(string Extension)
+{
+ Mesh_Writer * writer=GetMeshWriter(Extension);
+ if(writer==NULL)
+ {
+ MESSAGE("No driver known for this extension");
+ return NULL;
+ }
+ return new Document_Writer(writer);
}
-Mesh_Reader* SMESHDriver::GetMeshReader(string Extension, string Class) {
- if (Extension==string("MED")) {
-
- if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
- DriverMED_R_SMESHDS_Mesh* myDriver = new DriverMED_R_SMESHDS_Mesh();
- return (myDriver);
- }
- else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
- DriverMED_R_SMDS_Mesh* myDriver = new DriverMED_R_SMDS_Mesh();
- return (myDriver);
- }
-
- }
- else if (Extension==string("DAT")) {
-
- if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
- DriverDAT_R_SMESHDS_Mesh* myDriver = new DriverDAT_R_SMESHDS_Mesh();
- return (myDriver);
- }
- else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
- DriverDAT_R_SMDS_Mesh* myDriver = new DriverDAT_R_SMDS_Mesh();
- return (myDriver);
- }
-
- }
-
-
+Mesh_Reader* SMESHDriver::GetMeshReader(string extension)
+{
+ void * driver = getMeshDriver(extension, string("Reader"));
+ return (Mesh_Reader*)driver;
}
-Mesh_Writer* SMESHDriver::GetMeshWriter(string Extension, string Class) {
- if (Extension==string("MED")) {
-
- if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
- DriverMED_W_SMESHDS_Mesh* myDriver = new DriverMED_W_SMESHDS_Mesh();
- return (myDriver);
- }
- else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
- DriverMED_W_SMDS_Mesh* myDriver = new DriverMED_W_SMDS_Mesh();
- return (myDriver);
- }
-
- }
- else if (Extension==string("DAT")) {
-
- if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
- DriverDAT_W_SMESHDS_Mesh* myDriver = new DriverDAT_W_SMESHDS_Mesh();
- return (myDriver);
- }
- else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
- DriverDAT_W_SMDS_Mesh* myDriver = new DriverDAT_W_SMDS_Mesh();
- return (myDriver);
- }
-
- }
+Mesh_Writer* SMESHDriver::GetMeshWriter(string extension)
+{
+ void * driver = getMeshDriver(extension, string("Writer"));
+ return (Mesh_Writer*)driver;
+}
+void * SMESHDriver::getMeshDriver(string extension, string type)
+{
+ string libName = string("libMeshDriver")+extension+string(".so");
+ void * handle = dlopen(libName.c_str(), RTLD_LAZY);
+ if(!handle)
+ {
+ fputs (dlerror(), stderr);
+ return NULL;
+ }
+ else
+ {
+ void * (*factory)();
+ string symbol = string("SMESH_create")+extension+string("Mesh")+type;
+ factory = (void * (*)()) dlsym(handle, symbol.c_str());
+ if(factory==NULL)
+ {
+ fputs (dlerror(), stderr);
+ return NULL;
+ }
+ else return factory();
+ }
}
+void * SMESHDriver::getMeshDocumentDriver(string extension)
+{
+ string libName = string("libMeshDriver")+extension+string(".so");
+ void * handle = dlopen(libName.c_str(), RTLD_LAZY);
+ if(!handle)
+ {
+ fputs (dlerror(), stderr);
+ return NULL;
+ }
+ else
+ {
+ void * (*factory)();
+ string symbol = string("SMESH_create")+extension+string("DocumentReader");
+ factory = (void * (*)()) dlsym(handle, symbol.c_str());
+ if(factory==NULL)
+ {
+ fputs (dlerror(), stderr);
+ return NULL;
+ }
+ else return factory();
+ }
+}
#include "Mesh_Reader.h"
#include "Mesh_Writer.h"
-class SMESHDriver {
-
+class SMESHDriver
+{
public :
- static Document_Reader* GetDocumentReader(string Extension, string Class);
- static Document_Writer* GetDocumentWriter(string Extension, string Class);
+ static Document_Reader* GetDocumentReader(string Extension);
+ static Document_Writer* GetDocumentWriter(string Extension);
- static Mesh_Reader* GetMeshReader(string Extension, string Class);
- static Mesh_Writer* GetMeshWriter(string Extension, string Class);
+ static Mesh_Reader* GetMeshReader(string Extension);
+ static Mesh_Writer* GetMeshWriter(string Extension);
+ private:
+ static void * getMeshDriver(string Extension, string type);
+ static void * getMeshDocumentDriver(string Extension);
};
#endif
// File : DriverDAT_R_SMDS_Mesh.cxx
// Module : SMESH
-using namespace std;
#include "DriverDAT_R_SMDS_Mesh.h"
-
#include "utilities.h"
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createDATMeshReader()
+{
+ return new DriverDAT_R_SMDS_Mesh();
+}
+}
+
DriverDAT_R_SMDS_Mesh::DriverDAT_R_SMDS_Mesh()
{
;
// File : DriverDAT_W_SMDS_Mesh.cxx
// Module : SMESH
-using namespace std;
#include "DriverDAT_W_SMDS_Mesh.h"
-
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
-
#include "utilities.h"
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createDATMeshWriter()
+{
+ return new DriverDAT_W_SMDS_Mesh();
+}
+}
+
DriverDAT_W_SMDS_Mesh::DriverDAT_W_SMDS_Mesh()
{
- ;
}
DriverDAT_W_SMDS_Mesh::~DriverDAT_W_SMDS_Mesh()
void DriverDAT_W_SMDS_Mesh::Add()
{
- ;
+ MESSAGE("Adding a mesh to a DAT document. As DAT do not support more than one mesh in a file, the previous mesh is deleted");
+ Write();
}
void DriverDAT_W_SMDS_Mesh::Write()
{
-
int nbNodes, nbCells;
int i;
fprintf(stderr, ">> ERREUR : ouverture du fichier %s \n", file2Read);
exit(EXIT_FAILURE);
}
- SCRUTE(myMesh);
+
/****************************************************************************
* NOMBRES D'OBJETS *
****************************************************************************/
nb_of_faces = myMesh->NbFaces();
nb_of_volumes = myMesh->NbVolumes();
nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
- SCRUTE(nb_of_edges);
- SCRUTE(nb_of_faces);
- SCRUTE(nb_of_volumes);
fprintf(stdout, "%d %d\n", nbNodes, nbCells);
fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
fprintf(myFileId, "%d %e %e %e\n", node->GetID(), node->X(),
node->Y(), node->Z());
}
-
+ delete itNodes;
+
/****************************************************************************
* ECRITURE DES ELEMENTS *
****************************************************************************/
fprintf(stdout, "(**************************)");
/* Ecriture des connectivites, noms, numeros des mailles */
- SMDS_Iterator<const SMDS_MeshEdge *> * itEdges=myMesh->edgesIterator();
+ SMDS_Iterator<const SMDS_MeshEdge*> * itEdges=myMesh->edgesIterator();
while(itEdges->more())
{
- const SMDS_MeshElement * elem = itEdges->next();
+ const SMDS_MeshEdge * elem = itEdges->next();
switch (elem->NbNodes())
{
}
}
- SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
- while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
-
+ SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
+ while(itNodes->more())
+ fprintf(myFileId, "%d ", itNodes->next()->GetID());
+
fprintf(myFileId, "\n");
}
+ delete itEdges;
SMDS_Iterator<const SMDS_MeshFace *> * itFaces=myMesh->facesIterator();
while(itFaces->more())
}
}
- SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
- while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
-
+ SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
+ while(itNodes->more())
+ fprintf(myFileId, "%d ", itNodes->next()->GetID());
+ delete itNodes;
+
fprintf(myFileId, "\n");
}
+ delete itFaces;
- SMDS_Iterator<const SMDS_MeshVolume *> * itVolumes=myMesh->volumesIterator();
+ SMDS_Iterator<const SMDS_MeshVolume*> * itVolumes=myMesh->volumesIterator();
while(itVolumes->more())
{
const SMDS_MeshElement * elem = itVolumes->next();
}
}
- SMDS_Iterator<const SMDS_MeshElement *> * it=elem->nodesIterator();
- while(it->more()) fprintf(myFileId, "%d ", it->next()->GetID());
+ SMDS_Iterator<const SMDS_MeshElement *> * itNodes=elem->nodesIterator();
+ while(itNodes->more())
+ fprintf(myFileId, "%d ", itNodes->next()->GetID());
+ delete itNodes;
fprintf(myFileId, "\n");
}
+ delete itVolumes;
fclose(myFileId);
}
@COMMENCE@
# header files
-EXPORT_HEADERS= DriverDAT_R_SMDS_Mesh.h DriverDAT_R_SMESHDS_Mesh.h DriverDAT_R_SMESHDS_Document.h DriverDAT_W_SMDS_Mesh.h DriverDAT_W_SMESHDS_Mesh.h DriverDAT_W_SMESHDS_Document.h
+EXPORT_HEADERS = \
+ DriverDAT_R_SMDS_Mesh.h \
+ DriverDAT_R_SMESHDS_Mesh.h \
+ DriverDAT_W_SMDS_Mesh.h \
+ DriverDAT_W_SMESHDS_Mesh.h
+# DriverDAT_W_SMESHDS_Document.h \
+# DriverDAT_R_SMESHDS_Document.h \
# Libraries targets
LIB = libMeshDriverDAT.la
-LIB_SRC = DriverDAT_R_SMDS_Mesh.cxx DriverDAT_R_SMESHDS_Mesh.cxx DriverDAT_R_SMESHDS_Document.cxx DriverDAT_W_SMDS_Mesh.cxx DriverDAT_W_SMESHDS_Mesh.cxx DriverDAT_W_SMESHDS_Document.cxx
+LIB_SRC = \
+ DriverDAT_R_SMDS_Mesh.cxx \
+ DriverDAT_R_SMESHDS_Mesh.cxx \
+ DriverDAT_W_SMDS_Mesh.cxx \
+ DriverDAT_W_SMESHDS_Mesh.cxx
+ #DriverDAT_W_SMESHDS_Document.cxx \
+ #DriverDAT_R_SMESHDS_Document.cxx \
LIB_CLIENT_IDL =
extern "C"
{
- Document_Reader *maker()
+ void * SMESH_createMEDDocumentReader()
{
return new DriverMED_R_SMESHDS_Document;
}
}
DriverMED_R_SMESHDS_Document::DriverMED_R_SMESHDS_Document()
+ :Document_Reader(new DriverMED_R_SMESHDS_Mesh())
{
;
}
int myMeshId;
- //string myFile = string("/home/home_users/cai/projects/salome_prev04/SALOME_ROOT/data/fra1.med");
-
/****************************************************************************
* OUVERTURE DU FICHIER EN LECTURE *
****************************************************************************/
#include <stdlib.h>
+extern "C"
+{
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createMEDMeshReader()
+{
+ return new DriverMED_R_SMESHDS_Mesh();
+}
+
+}
+
DriverMED_R_SMESHDS_Mesh::DriverMED_R_SMESHDS_Mesh()
{
myFileId = -1;
#include <vector>
#include "utilities.h"
+extern "C"
+{
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createMEDMeshWriter()
+{
+ return new DriverMED_W_SMESHDS_Mesh();
+}
+
+}
+
DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh()
{
;
void DriverMED_W_SMESHDS_Mesh::Write()
{
-
- string myClass = string("SMDS_Mesh");
- string myExtension = string("MED");
-
- DriverMED_W_SMDS_Mesh *myWriter = new DriverMED_W_SMDS_Mesh;
-
- myWriter->SetMesh(myMesh);
- // myWriter->SetFile(myFile);
- myWriter->SetMeshId(myMeshId);
- myWriter->SetFileId(myFileId);
-
- myWriter->Write();
-
+ Add();
}
void DriverMED_W_SMESHDS_Mesh::Add()
{
int nbFamillesElts = 0;
SMESHDS_Mesh * mySMESHDSMesh = dynamic_cast<SMESHDS_Mesh *>(myMesh);
- TopTools_IndexedMapOfShape myIndexToShape;
- TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
-
map<int,int> mapFamille;
- if (besoinfamilledemaille == 1)
+ if(!mySMESHDSMesh->ShapeToMesh().IsNull())
{
- int t;
- for (t = 1; t <= myIndexToShape.Extent(); t++)
+ TopTools_IndexedMapOfShape myIndexToShape;
+ TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
+
+
+ if (besoinfamilledemaille == 1)
{
- const TopoDS_Shape S = myIndexToShape(t);
- if (mySMESHDSMesh->HasMeshElements(S))
+ int t;
+ for (t = 1; t <= myIndexToShape.Extent(); t++)
{
- //MESSAGE ("********* Traitement de la Famille "<<-t);
-
- SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
- SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
- bool plein = false;
- while(ite->more())
- {
- mapFamille[ite->next()->GetID()] = -t;
- plein = true;
- }
- if (plein)
+ const TopoDS_Shape S = myIndexToShape(t);
+ if (mySMESHDSMesh->HasMeshElements(S))
{
- nbFamillesElts++;
- char famille[MED_TAILLE_NOM + 1];
- sprintf(famille, "E%d", t);
- CreateFamily(strdup(nommaa), strdup(famille), -t,
- attvalabs++);
+ //MESSAGE ("********* Traitement de la Famille "<<-t);
+
+ SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
+ SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
+ bool plein = false;
+ while(ite->more())
+ {
+ mapFamille[ite->next()->GetID()] = -t;
+ plein = true;
+ }
+ if (plein)
+ {
+ nbFamillesElts++;
+ char famille[MED_TAILLE_NOM + 1];
+ sprintf(famille, "E%d", t);
+ CreateFamily(strdup(nommaa), strdup(famille), -t,
+ attvalabs++);
+ }
}
}
}
}
+ else besoinfamilledemaille = 0;
int indice = 1;
for (i = 0; i < MED_NBR_GEOMETRIE_MAILLE; i++)
#
# See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
#
-#
-#
# File : Makefile.in
# Author : Marc Tajchman (CEA)
# Module : SMESH
-# $Header$
top_srcdir=@top_srcdir@
top_builddir=../..
@COMMENCE@
# header files
-EXPORT_HEADERS= DriverMED_R_SMDS_Mesh.h DriverMED_R_SMESHDS_Mesh.h DriverMED_R_SMESHDS_Document.h DriverMED_W_SMDS_Mesh.h DriverMED_W_SMESHDS_Mesh.h DriverMED_W_SMESHDS_Document.h
+EXPORT_HEADERS = \
+ DriverMED_R_SMESHDS_Mesh.h \
+ DriverMED_R_SMESHDS_Document.h \
+ DriverMED_R_SMDS_Mesh.h \
+ DriverMED_W_SMESHDS_Mesh.h
+ #DriverMED_W_SMDS_Mesh.h \
+ #DriverMED_W_SMESHDS_Document.h
# Libraries targets
LIB = libMeshDriverMED.la
LIB_SRC = \
- DriverMED_R_SMDS_Mesh.cxx \
DriverMED_R_SMESHDS_Mesh.cxx \
DriverMED_R_SMESHDS_Document.cxx \
- DriverMED_W_SMDS_Mesh.cxx \
- DriverMED_W_SMESHDS_Document.cxx \
- DriverMED_W_SMESHDS_Mesh.cxx
-
+ DriverMED_R_SMDS_Mesh.cxx \
+ DriverMED_W_SMESHDS_Mesh.cxx
+ #DriverMED_W_SMDS_Mesh.cxx \
+ #DriverMED_W_SMESHDS_Document.cxx
LIB_CLIENT_IDL =
LIB_SERVER_IDL =
#include "utilities.h"
+
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createUNVMeshReader()
+{
+ return new DriverUNV_R_SMDS_Mesh();
+}
+
+}
+
DriverUNV_R_SMDS_Mesh::DriverUNV_R_SMDS_Mesh()
{
;
-using namespace std;
#include "DriverUNV_W_SMDS_Mesh.h"
-
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
-
-
-
-
#include <utilities.h>
#define sNODE_UNV_ID " 2411"
#define sELT_BEAM_DESC1 "%10d %2d 1 1 7 %1d\n"
#define sELT_BEAM_DESC2 " 0 1 1\n"
+extern "C"
+{
+
+/**
+ * Factory function which will be called by SMESHDriver
+ */
+void * SMESH_createUNVMeshWriter()
+{
+ return new DriverUNV_W_SMDS_Mesh();
+}
+
+}
+
DriverUNV_W_SMDS_Mesh::DriverUNV_W_SMDS_Mesh()
{
;
SCRUTE(nb_of_volumes);
fprintf(stdout, "%d %d\n", nbNodes, nbCells);
- fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
/****************************************************************************
* ECRITURE DES NOEUDS *
@COMMENCE@
# header files
-EXPORT_HEADERS= DriverUNV_R_SMDS_Mesh.h DriverUNV_R_SMESHDS_Mesh.h DriverUNV_R_SMESHDS_Document.h \
- DriverUNV_W_SMDS_Mesh.h DriverUNV_W_SMESHDS_Mesh.h DriverUNV_W_SMESHDS_Document.h
+EXPORT_HEADERS = \
+ DriverUNV_R_SMDS_Mesh.h \
+ DriverUNV_W_SMDS_Mesh.h
+ #DriverUNV_W_SMESHDS_Mesh.h \
+ #DriverUNV_W_SMESHDS_Document.h \
+ #DriverUNV_R_SMESHDS_Mesh.h \
+ #DriverUNV_R_SMESHDS_Document.h \
# Libraries targets
LIB = libMeshDriverUNV.la
LIB_SRC = \
DriverUNV_R_SMDS_Mesh.cxx \
- DriverUNV_R_SMESHDS_Mesh.cxx \
- DriverUNV_R_SMESHDS_Document.cxx \
- DriverUNV_W_SMESHDS_Document.cxx \
- DriverUNV_W_SMDS_Mesh.cxx \
- DriverUNV_W_SMESHDS_Mesh.cxx
+ DriverUNV_W_SMDS_Mesh.cxx
+ #DriverUNV_W_SMESHDS_Mesh.cxx \
+ #DriverUNV_R_SMESHDS_Mesh.cxx \
+ #DriverUNV_R_SMESHDS_Document.cxx \
+ #DriverUNV_W_SMESHDS_Document.cxx \
LIB_CLIENT_IDL =
#include "SMESH_subMesh.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
+#include "SMESHDriver.h"
#include <gp_Pnt.hxx>
#include <BRep_Tool.hxx>
// SCRUTE(shapeDim);
return shapeDim;
}
+
+/**
+ * Import a mesh from a file
+ * @param fileName file name to be imported
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ * @todo
+ */
+SMESH_Mesh * SMESH_Gen::Import(int studyId, const char * fileName,
+ const char * fileType)
+{
+ MESSAGE("SMESH_Gen::Import("<<studyId<<","<<fileName<<","<<fileType<<")");
+
+ // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+ StudyContextStruct *myStudyContext = GetStudyContext(studyId);
+
+ // will be used with document
+ /*Document_Reader * reader = SMESHDriver::GetDocumentReader(string(fileType));
+ reader->SetDocument(myStudyContext->myDocument);
+ reader->SetFile(string(fileName));
+ reader->Read();*/
+ // currently we only read one mesh from a file (limitation on MED files).
+
+ // create a new SMESH_mesh object
+ SMESH_Mesh *mesh = new SMESH_Mesh(_localId++, studyId, this,
+ myStudyContext->myDocument);
+ myStudyContext->mapMesh[_localId] = mesh;
+
+ Mesh_Reader * reader = SMESHDriver::GetMeshReader(string(fileType));
+ reader->SetMesh(mesh->GetMeshDS());
+ reader->SetFile(string(fileName));
+ reader->Read();
+
+ return mesh;
+}
+
static int GetShapeDim(const TopoDS_Shape & aShape);
SMESH_Algo *GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape);
-
+ SMESH_Mesh *Import(int studyId, const char * fileName, const char * fileType);
+
// inherited methods from SALOMEDS::Driver
void Save(int studyId, const char *aUrlOfFile);
#include "SMESH_Hypothesis.hxx"
#include "SMESHDS_Script.hxx"
#include "SMDS_MeshVolume.hxx"
-
#include "utilities.h"
-
-#include "Mesh_Writer.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverUNV_W_SMESHDS_Mesh.h"
+#include "SMESHDriver.h"
#include <TCollection_AsciiString.hxx>
return _subMeshesUsingHypothesisList;
}
-//=============================================================================
/*!
- *
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
*/
-//=============================================================================
-
-void SMESH_Mesh::ExportMED(const char *file) throw(SALOME_Exception)
-{
- Mesh_Writer *myWriter = new DriverMED_W_SMESHDS_Mesh;
- myWriter->SetFile(string(file));
- myWriter->SetMesh(_myMeshDS);
- MESSAGE(" _idDoc " << _idDoc) myWriter->SetMeshId(_idDoc);
- myWriter->Add();
-}
-
-void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
-{
- Mesh_Writer *myWriter = new DriverDAT_W_SMESHDS_Mesh;
- myWriter->SetFile(string(file));
- myWriter->SetMesh(_myMeshDS);
- myWriter->SetMeshId(_idDoc);
- myWriter->Add();
-}
-
-void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
+void SMESH_Mesh::Export(const char *fileName, const char *fileType)
+ throw(SALOME_Exception)
{
- Mesh_Writer *myWriter = new DriverUNV_W_SMESHDS_Mesh;
- myWriter->SetFile(string(file));
- myWriter->SetMesh(_myMeshDS);
- myWriter->SetMeshId(_idDoc);
- myWriter->Add();
+ MESSAGE("SMESH_Mesh::Export("<<fileName<<","<<fileType<<")");
+ Mesh_Writer * writer = SMESHDriver::GetMeshWriter(string(fileType));
+ if(writer!=NULL)
+ {
+ writer->SetMesh(GetMeshDS());
+ writer->SetFile(string(fileName));
+ writer->Write();
+ }
}
//=============================================================================
GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
throw(SALOME_Exception);
- void ExportDAT(const char *file) throw(SALOME_Exception);
- void ExportMED(const char *file) throw(SALOME_Exception);
- void ExportUNV(const char *file) throw(SALOME_Exception);
+ void Export(const char *fileName, const char *fileType)
+ throw(SALOME_Exception);
int NbNodes() throw(SALOME_Exception);
CXXFLAGS += -I${KERNEL_ROOT_DIR}/include/salome -I${GEOM_ROOT_DIR}/include/salome
#$(OCC_CXXFLAGS)
-LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lSMESHObject -lSMDS -lSMESHDS -lSMESHFiltersSelection -lGEOMClient -lMeshDriverDAT -lMeshDriverMED -lMeshDriverUNV $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
+LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lSMESHObject -lSMDS -lSMESHDS -lSMESHFiltersSelection -lGEOMClient $(OCC_KERNEL_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome -L${GEOM_ROOT_DIR}/lib/salome
@CONCLUDE@
#include "SALOMEGUI_QtCatchCorbaException.hxx"
#include "utilities.h"
-#include "SMDS_Mesh.hxx"
-#include "SMESHDS_Document.hxx"
-#include "Document_Reader.h"
-#include "Document_Writer.h"
-#include "Mesh_Reader.h"
-#include "Mesh_Writer.h"
-
-#include "DriverDAT_R_SMESHDS_Document.h"
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverUNV_R_SMESHDS_Document.h"
-#include "DriverDAT_W_SMESHDS_Document.h"
-#include "DriverMED_W_SMESHDS_Document.h"
-#include "DriverUNV_W_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverUNV_R_SMESHDS_Mesh.h"
-#include "DriverDAT_W_SMESHDS_Mesh.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverUNV_W_SMESHDS_Mesh.h"
-
// QT Includes
#define INCLUDE_MENUITEM_DEF
#include <qapplication.h>
smeshGUI->myStudyAPI =
SMESHGUI_StudyAPI(smeshGUI->myStudy, smeshGUI->myComponentMesh);
- smeshGUI->myDocument = new SMESHDS_Document(1); //NBU
-
smeshGUI->mySimulationActors = vtkActorCollection::New();
smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
}
case 112:
case 111:
{
- Import_Document(parent, theCommandID); //NBU
- //Import_Mesh(parent,theCommandID);
+ smeshGUI->Import_Document(parent, theCommandID);
break;
}
return listSOmesh._retn();
}
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-void SMESHGUI::Import_Mesh(QAD_Desktop * parent, int theCommandID)
-{
- QString filter;
- string myExtension;
- Mesh_Reader *myReader;
-
- if (theCommandID == 113)
- {
- filter = tr("MED files (*.med)");
- myExtension = string("MED");
- myReader = new DriverMED_R_SMESHDS_Mesh;
- }
- else if (theCommandID == 112)
- {
- filter = tr("IDEAS files (*.unv)");
- myExtension = string("UNV");
- }
- else if (theCommandID == 111)
- {
- filter = tr("DAT files (*.dat)");
- myExtension = string("MED");
- myReader = new DriverDAT_R_SMESHDS_Mesh;
- }
-
- QString filename = QAD_FileDlg::getFileName(parent,
- "",
- filter,
- tr("Import mesh"),
- true);
- if (!filename.isEmpty())
- {
- QApplication::setOverrideCursor(Qt::waitCursor);
- string myClass = string("SMESHDS_Mesh");
-// Mesh_Reader* myReader = SMESHDriver::GetMeshReader(myExtension, myClass);
-
- int myMeshId = (smeshGUI->myDocument)->NewMesh();
- SMDS_Mesh *myMesh = (smeshGUI->myDocument)->GetMesh(myMeshId);
-
- myReader->SetFile(string(filename.latin1()));
- myReader->SetMesh(myMesh);
- myReader->SetMeshId(myMeshId);
- myReader->Read();
-
- QApplication::restoreOverrideCursor();
- }
-}
-
//=============================================================================
/*!
*
if (!filename.isEmpty())
{
QApplication::setOverrideCursor(Qt::waitCursor);
- aMesh->ExportMED(filename.latin1());
+ aMesh->Export(filename.latin1(), "MED");
QApplication::restoreOverrideCursor();
}
}
if (!filename.isEmpty())
{
QApplication::setOverrideCursor(Qt::waitCursor);
- aMesh->ExportDAT(filename.latin1());
+ aMesh->Export(filename.latin1(), "DAT");
QApplication::restoreOverrideCursor();
}
}
if (!filename.isEmpty())
{
QApplication::setOverrideCursor(Qt::waitCursor);
- aMesh->ExportUNV(filename.latin1());
+ aMesh->Export(filename.latin1(), "UNV");
QApplication::restoreOverrideCursor();
}
else
- aMesh->ExportDAT(filename.latin1());
+ aMesh->Export(filename.latin1(), "DAT");
QApplication::restoreOverrideCursor();
{
QString filter;
string myExtension;
- Document_Reader *myReader;
if (theCommandID == 113)
{
filter = tr("MED files (*.med)");
myExtension = string("MED");
- myReader = new DriverMED_R_SMESHDS_Document;
}
else if (theCommandID == 112)
{
filter = tr("IDEAS files (*.unv)");
myExtension = string("UNV");
- myReader = new DriverUNV_R_SMESHDS_Document;
}
else if (theCommandID == 111)
{
filter = tr("DAT files (*.dat)");
myExtension = string("DAT");
- myReader = new DriverDAT_R_SMESHDS_Document;
}
- QString filename = QAD_FileDlg::getFileName(parent,
- "",
- filter,
- tr("Import document"),
- true);
- if (!filename.isEmpty())
- {
- QApplication::setOverrideCursor(Qt::waitCursor);
- string myClass = string("SMESHDS_Document");
-// Document_Reader* myReader = SMESHDriver::GetDocumentReader(myExtension, myClass);
- SMESHDS_Document *newDocument = new SMESHDS_Document(1);
-
- myReader->SetFile(string(filename.latin1()));
- myReader->SetDocument(smeshGUI->myDocument);
- myReader->Read();
- QApplication::restoreOverrideCursor();
- }
-}
-
-void SMESHGUI::Export_Document(QAD_Desktop * parent, int theCommandID)
-{
- QString filter;
- Document_Writer *myWriter;
- string myExtension;
-
- if (theCommandID == 122)
- {
- filter = tr("MED files (*.med)");
- myExtension = string("MED");
- myWriter = new DriverMED_W_SMESHDS_Document;
- }
- else if (theCommandID == 121)
- {
- filter = tr("DAT files (*.dat)");
- myExtension = string("DAT");
- myWriter = new DriverDAT_W_SMESHDS_Document;
- }
- else if (theCommandID == 123)
- {
- filter = tr("IDEAS files (*.unv)");
- myExtension = string("UNV");
- myWriter = new DriverUNV_W_SMESHDS_Document;
- }
+ QString filename = QAD_FileDlg::getFileName(parent, "", filter,
+ tr("Import document"), true);
- QString filename = QAD_FileDlg::getFileName(parent,
- "",
- filter,
- tr("Export document"),
- false);
if (!filename.isEmpty())
{
QApplication::setOverrideCursor(Qt::waitCursor);
- string myClass = string("SMESHDS_Document");
- //Document_Writer* myWriter = SMESHDriver::GetDocumentWriter(myExtension, myClass);
-
- myWriter->SetFile(string(filename.latin1()));
- myWriter->SetDocument(smeshGUI->myDocument);
-
- //StudyContextStruct* myStudyContext = _impl.GetStudyContext(myStudyId);
- //Handle(SMESHDS_Document) myDocument = myStudyContext->myDocument;
- //myWriter->SetDocument(myDocument);
-
- myWriter->Write();
+ try
+ {
+ if (!myComponentMesh->_is_nil())
+ {
+ SMESH::SMESH_Mesh_var aMesh =
+ myComponentMesh->Import(myStudyId, filename.latin1(),
+ myExtension.c_str());
+
+ if (!aMesh->_is_nil())
+ {
+ SALOMEDS::SObject_var SM = myStudyAPI.AddNewMesh(aMesh);
+ myStudyAPI.SetName(SM, filename);
+ }
+ }
+ }
+ catch(const SALOME::SALOME_Exception & S_ex)
+ {
+ QtCatchCorbaException(S_ex);
+ }
+ myActiveStudy->updateObjBrowser(true);
QApplication::restoreOverrideCursor();
}
}
// vtkScalarBarActor* myScalarBar;
- SMESHDS_Document * myDocument;//NBU
-
bool myAutomaticUpdate;
public :
static void setOrb();
/* Import/Export */ //NBU
- static void Import_Document(QAD_Desktop* parent, int theCommandID);
- static void Export_Document(QAD_Desktop* parent, int theCommandID);
- static void Import_Mesh(QAD_Desktop* parent, int theCommandID);
+ void Import_Document(QAD_Desktop* parent, int theCommandID);
static void Export_Mesh(QAD_Desktop* parent, int theCommandID);
signals:
#include "SMESH_MaxElementArea_i.hxx"
#include "SMESH_MaxElementVolume_i.hxx"
-#include "SMESHDS_Document.hxx"
-
-#include "Document_Reader.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverMED_R_SMESHDS_Document.h"
-#include "DriverUNV_R_SMESHDS_Document.h"
-#include "DriverDAT_R_SMESHDS_Document.h"
+#include "SMESHDriver.h"
#include "Utils_CorbaException.hxx"
#include "utilities.h"
SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
SCRUTE(mySMESHDSMesh->NbNodes());
- if (mySMESHDSMesh->NbNodes()>0) {//checks if the mesh is not empty
-
- DriverMED_W_SMESHDS_Mesh* myWriter = new DriverMED_W_SMESHDS_Mesh;
+ if (mySMESHDSMesh->NbNodes()>0)
+ {
+ //checks if the mesh is not empty
+ Mesh_Writer * myWriter = SMESHDriver::GetMeshWriter("MED");
myWriter->SetFile(meshfile.ToCString());
-
myWriter->SetMesh(mySMESHDSMesh);
myWriter->SetMeshId(gotBranch->Tag());
myWriter->Add();
//**********
//********** Loading of mesh data
- if (strcmp(datafilename,"No data")!=0) {
-
- med_idt fid;
+ if (strcmp(datafilename,"No data")!=0)
+ {
int ret;
-
- //****************************************************************************
- //* OUVERTURE DU FICHIER EN LECTURE *
- //****************************************************************************
-
- fid = MEDouvrir(datafilename,MED_LECT);
- if (fid < 0)
- {
- printf(">> ERREUR : ouverture du fichier %s \n",datafilename);
- exit(EXIT_FAILURE);
- }
- else {
-
- StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
- int meshId = myNewMesh->GetId();
- SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId];
- ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
- SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
-
- DriverMED_R_SMESHDS_Mesh* myReader = new DriverMED_R_SMESHDS_Mesh;
-
- myReader->SetMesh(mySMESHDSMesh);
- myReader->SetMeshId(myMeshId);
- myReader->SetFileId(fid);
- myReader->ReadMySelf();
- //SCRUTE(mySMESHDSMesh->NbNodes());
- //myNewMesh->ExportUNV("/tmp/test.unv");//only to check out
-
- //****************************************************************************
- //* FERMETURE DU FICHIER *
- //****************************************************************************
- ret = MEDfermer(fid);
-
- if (ret != 0)
- printf(">> ERREUR : erreur a la fermeture du fichier %s\n",datafilename);
-
- }
+ StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
+ int meshId = myNewMesh->GetId();
+ SMESH_Mesh_i* meshServant = myStudyContext->mapMesh_i[meshId];
+ ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
+ SMESHDS_Mesh* mySMESHDSMesh = myLocMesh.GetMeshDS();
+
+ Mesh_Reader* myReader = SMESHDriver::GetMeshReader("MED");
+ myReader->SetMesh(mySMESHDSMesh);
+ myReader->SetMeshId(myMeshId);
+ myReader->SetFile(datafilename);
+ myReader->Read();
+ //SCRUTE(mySMESHDSMesh->NbNodes());
+ //myNewMesh->ExportUNV("/tmp/test.unv");//only to check out
}
}
//**********
return myTopo;
}
+/**
+ * Import a mesh from a file
+ * @param fileName file name to be imported
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ */
+SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Import(CORBA::Long studyId,
+ const char* fileName, const char* fileType)
+{
+ MESSAGE("SMESH_Gen_I::Import");
+ SMESH_Mesh_i* meshServant;
+ try
+ {
+ if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end())
+ {
+ _mapStudyContext_i[studyId] = new StudyContext_iStruct;
+ }
+ StudyContext_iStruct* myStudyContext = _mapStudyContext_i[studyId];
+
+ // create a new mesh object servant, store it in a map in study context
+ meshServant = new SMESH_Mesh_i(this, NULL, studyId, _localId);
+ myStudyContext->mapMesh_i[_localId] = meshServant;
+ _localId++;
+
+ // create a new mesh object
+ meshServant->SetImpl(_impl.Import(studyId, fileName, fileType));
+ }
+ catch (SALOME_Exception& S_ex)
+ {
+ THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+ }
+
+ // activate the CORBA servant of Mesh
+
+ SMESH::SMESH_Mesh_var mesh
+ = SMESH::SMESH_Mesh::_narrow(meshServant->_this());
+
+ meshServant->SetIor(mesh);
+ return SMESH::SMESH_Mesh::_duplicate(mesh);
+}
+
//=============================================================================
/*!
* C factory, accessible with dlsym, after dlopen
const SMESH::shape_array& listOfSubShape)
throw (SALOME::SALOME_Exception);
+ SMESH::SMESH_Mesh_ptr Import(CORBA::Long studyId, const char* fileName,
+ const char* fileType);
// inherited methods from SALOMEDS::Driver
*/
//=============================================================================
-void SMESH_Mesh_i::ExportMED(const char *file) throw(SALOME::SALOME_Exception)
-{
- _impl->ExportMED(file);
-}
-void SMESH_Mesh_i::ExportDAT(const char *file) throw(SALOME::SALOME_Exception)
-{
- _impl->ExportDAT(file);
-}
-void SMESH_Mesh_i::ExportUNV(const char *file) throw(SALOME::SALOME_Exception)
-{
- _impl->ExportUNV(file);
-}
-
-//=============================================================================
-/*!
- *
- */
-//=============================================================================
-
SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
{
SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
{
return _impl->NbSubMesh();
}
+
+/*!
+ * Export mesh to a file
+ * @param fileName file name where to export the file
+ * @param fileType Currently it could be either "DAT", "UNV" or "MED".
+ */
+void SMESH_Mesh_i::Export(const char* fileName, const char* fileType)
+ throw (SALOME::SALOME_Exception)
+{
+ _impl->Export(fileName, fileType);
+}
CORBA::Long GetStudyId()
throw (SALOME::SALOME_Exception);
+ void Export(const char* fileName, const char* fileType)
+ throw (SALOME::SALOME_Exception);
+
// --- C++ interface
void SetImpl(::SMESH_Mesh* impl);
void SetIor(SMESH::SMESH_Mesh_ptr myIor);
SMESH::SMESH_Mesh_ptr GetIor();
- void ExportMED( const char* file )
- throw (SALOME::SALOME_Exception);
- void ExportDAT( const char* file )
- throw (SALOME::SALOME_Exception);
- void ExportUNV( const char* file )
- throw (SALOME::SALOME_Exception);
-
SALOME_MED::MESH_ptr GetMEDMesh()
throw (SALOME::SALOME_Exception);
