ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-29 23:20:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

Import mesh is now done in the SMESH container, not in SMESHGUI. Each mesh file parser and writer is a plugin loadable as a shared library

Browse Source
This commit is contained in:
jrt 2004-02-16 10:13:47 +00:00
parent a907e4482a
commit c33d1b0113
30 changed files with 493 additions and 486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
idl/SMESH_Gen.idl
View File

@ -104,7 +104,13 @@ module SMESH
// 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);
};
};

10
idl/SMESH_Mesh.idl
View File

@ -161,13 +161,11 @@ module SMESH
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);
/*!

13
src/Driver/Document_Reader.cxx
View File

@ -38,3 +38,16 @@ void Document_Reader::SetDocument(SMESHDS_Document * aDoc)
{
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)
{
}

9
src/Driver/Document_Reader.h
View File

@ -28,17 +28,22 @@
#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

32
src/Driver/Document_Writer.cxx
View File

@ -18,14 +18,9 @@
// 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)
{
@ -36,3 +31,28 @@ void Document_Writer::SetDocument(SMESHDS_Document * aDoc)
{
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)
{
}

8
src/Driver/Document_Writer.h
View File

@ -28,17 +28,21 @@
#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

14
src/Driver/Makefile.in
View File

@ -35,11 +35,21 @@ VPATH=.:@srcdir@
@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 =

185
src/Driver/SMESHDriver.cxx
View File

@ -1,4 +1,4 @@
// 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
@ -18,122 +18,97 @@
// 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();
}
}

15
src/Driver/SMESHDriver.h
View File

@ -32,14 +32,17 @@
#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

14
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
View File

@ -24,11 +24,21 @@
// 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()
{
;

58
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
View File

@ -24,17 +24,25 @@
// 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()
@ -64,12 +72,12 @@ void DriverDAT_W_SMDS_Mesh::SetMeshId(int aMeshId)
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;
@ -80,7 +88,7 @@ void DriverDAT_W_SMDS_Mesh::Write()
fprintf(stderr, ">> ERREUR : ouverture du fichier %s \n", file2Read);
exit(EXIT_FAILURE);
}
SCRUTE(myMesh);
/****************************************************************************
* NOMBRES D'OBJETS *
****************************************************************************/
@ -97,9 +105,6 @@ void DriverDAT_W_SMDS_Mesh::Write()
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);
@ -118,7 +123,8 @@ void DriverDAT_W_SMDS_Mesh::Write()
fprintf(myFileId, "%d %e %e %e\n", node->GetID(), node->X(),
node->Y(), node->Z());
}
delete itNodes;
/****************************************************************************
* ECRITURE DES ELEMENTS *
****************************************************************************/
@ -127,10 +133,10 @@ void DriverDAT_W_SMDS_Mesh::Write()
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())
{
@ -146,11 +152,13 @@ void DriverDAT_W_SMDS_Mesh::Write()
}
}
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())
@ -176,13 +184,16 @@ void DriverDAT_W_SMDS_Mesh::Write()
}
}
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();
@ -196,11 +207,14 @@ void DriverDAT_W_SMDS_Mesh::Write()
}
}
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);
}

16
src/DriverDAT/Makefile.in
View File

@ -35,11 +35,23 @@ VPATH=.:@srcdir@
@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 =

5
src/DriverMED/DriverMED_R_SMESHDS_Document.cxx
View File

@ -31,13 +31,14 @@ using namespace std;
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())
{
;
}
@ -60,8 +61,6 @@ void DriverMED_R_SMESHDS_Document::Read()
int myMeshId;
//string myFile = string("/home/home_users/cai/projects/salome_prev04/SALOME_ROOT/data/fra1.med");
/****************************************************************************
* OUVERTURE DU FICHIER EN LECTURE *
****************************************************************************/

12
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -31,6 +31,18 @@ using namespace std;
#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;

81
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
View File

@ -33,6 +33,18 @@ using namespace std;
#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()
{
;
@ -65,19 +77,7 @@ void DriverMED_W_SMESHDS_Mesh::SetMeshId(int aMeshId)
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()
@ -520,40 +520,45 @@ 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++)
{
const TopoDS_Shape S = myIndexToShape(t);
if (mySMESHDSMesh->HasMeshElements(S))
{
//MESSAGE ("********* Traitement de la Famille "<<-t);
TopTools_IndexedMapOfShape myIndexToShape;
TopExp::MapShapes(mySMESHDSMesh->ShapeToMesh(), myIndexToShape);
SMESHDS_SubMesh * SM = mySMESHDSMesh->MeshElements(S);
SMDS_Iterator<const SMDS_MeshElement*> * ite=SM->GetElements();
bool plein = false;
while(ite->more())
if (besoinfamilledemaille == 1)
{
int t;
for (t = 1; t <= myIndexToShape.Extent(); t++)
{
const TopoDS_Shape S = myIndexToShape(t);
if (mySMESHDSMesh->HasMeshElements(S))
{
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++);
//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++)

20
src/DriverMED/Makefile.in
View File

@ -19,12 +19,9 @@
#
# 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=../..
@ -35,18 +32,23 @@ VPATH=.:@srcdir@
@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 =

14
src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx
View File

@ -3,6 +3,20 @@ using namespace std;
#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()
{
;

20
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
View File

@ -1,13 +1,7 @@
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"
@ -19,6 +13,19 @@ using namespace std;
#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()
{
;
@ -89,7 +96,6 @@ void DriverUNV_W_SMDS_Mesh::Write()
SCRUTE(nb_of_volumes);
fprintf(stdout, "%d %d\n", nbNodes, nbCells);
fprintf(myFileId, "%d %d\n", nbNodes, nbCells);
/****************************************************************************
* ECRITURE DES NOEUDS *

19
src/DriverUNV/Makefile.in
View File

@ -35,18 +35,23 @@ VPATH=.:@srcdir@
@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 =

36
src/SMESH/SMESH_Gen.cxx
View File

@ -30,6 +30,7 @@
#include "SMESH_subMesh.hxx"
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMESHDriver.h"
#include <gp_Pnt.hxx>
#include <BRep_Tool.hxx>
@ -404,3 +405,38 @@ int SMESH_Gen::GetShapeDim(const TopoDS_Shape & aShape)
// 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;
}

3
src/SMESH/SMESH_Gen.hxx
View File

@ -69,7 +69,8 @@ class SMESH_Gen
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);

48
src/SMESH/SMESH_Mesh.cxx
View File

@ -32,13 +32,8 @@
#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>
@ -415,37 +410,22 @@ throw(SALOME_Exception)
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)
void SMESH_Mesh::Export(const char *fileName, const char *fileType)
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)
{
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();
}
}
//=============================================================================

5
src/SMESH/SMESH_Mesh.hxx
View File

@ -101,9 +101,8 @@ class SMESH_Mesh
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);

2
src/SMESHGUI/Makefile.in
View File

@ -126,6 +126,6 @@ CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYT
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@

172
src/SMESHGUI/SMESHGUI.cxx
View File

@ -87,26 +87,6 @@ using namespace std;
#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>
@ -237,8 +217,6 @@ SMESHGUI *SMESHGUI::GetOrCreateSMESHGUI(QAD_Desktop * desktop)
smeshGUI->myStudyAPI =
SMESHGUI_StudyAPI(smeshGUI->myStudy, smeshGUI->myComponentMesh);
smeshGUI->myDocument = new SMESHDS_Document(1); //NBU
smeshGUI->mySimulationActors = vtkActorCollection::New();
smeshGUI->mySimulationActors2D = vtkActor2DCollection::New();
}
@ -2104,8 +2082,7 @@ bool SMESHGUI::OnGUIEvent(int theCommandID, QAD_Desktop * parent)
case 112:
case 111:
{
Import_Document(parent, theCommandID); //NBU
//Import_Mesh(parent,theCommandID);
smeshGUI->Import_Document(parent, theCommandID);
break;
}
@ -3498,58 +3475,6 @@ SALOMEDS::Study::ListOfSObject *
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();
}
}
//=============================================================================
/*!
*
@ -3577,7 +3502,7 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
if (!filename.isEmpty())
{
QApplication::setOverrideCursor(Qt::waitCursor);
aMesh->ExportMED(filename.latin1());
aMesh->Export(filename.latin1(), "MED");
QApplication::restoreOverrideCursor();
}
}
@ -3591,7 +3516,7 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
if (!filename.isEmpty())
{
QApplication::setOverrideCursor(Qt::waitCursor);
aMesh->ExportDAT(filename.latin1());
aMesh->Export(filename.latin1(), "DAT");
QApplication::restoreOverrideCursor();
}
}
@ -3605,11 +3530,11 @@ void SMESHGUI::Export_Mesh(QAD_Desktop * parent, int theCommandID)
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();
@ -3642,90 +3567,49 @@ void SMESHGUI::Import_Document(QAD_Desktop * parent, int theCommandID)
{
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);
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("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();
}
}

6
src/SMESHGUI/SMESHGUI.h
View File

@ -88,8 +88,6 @@ private :
// vtkScalarBarActor* myScalarBar;
SMESHDS_Document * myDocument;//NBU
bool myAutomaticUpdate;
public :
@ -303,9 +301,7 @@ 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:

112
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -55,14 +55,7 @@ using namespace std;
#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"
@ -580,11 +573,11 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
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();
@ -1134,47 +1127,22 @@ bool SMESH_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
//**********
//********** 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
}
}
//**********
@ -1735,6 +1703,46 @@ SMESH_topo* SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine,
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

2
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -96,6 +96,8 @@ public:
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

30
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -530,25 +530,6 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
*/
//=============================================================================
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);
@ -625,3 +606,14 @@ CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
{
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);
}

10
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -91,6 +91,9 @@ public:
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);
@ -100,13 +103,6 @@ public:
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);