Skip to content
Snippets Groups Projects
Commit 5f1aa98d authored by Christophe Geuzaine's avatar Christophe Geuzaine
Browse files 

- new version of MED IO (Pascale Noyret)
- moved OCCInternals class into separate header for Salome plugin (Pascale Noyret)
parent 0227eed9
Branches
Tags
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Geo/GModelIO_MED.cpp
+ 34
− 56
View file @ 5f1aa98d
// $Id: GModelIO_MED.cpp,v 1.3 2007-02-03 11:21:40 geuzaine Exp $ // $Id: GModelIO_MED.cpp,v 1.4 2007-04-23 07:59:25 geuzaine Exp $
// //
// Copyright (C) 1997-2006 C. Geuzaine, J.-F. Remacle // Copyright (C) 1997-2006 C. Geuzaine, J.-F. Remacle
// //
...@@ -18,24 +18,21 @@ ...@@ -18,24 +18,21 @@
// USA. // USA.
// //
// Please report all bugs and problems to <gmsh@geuz.org>. // Please report all bugs and problems to <gmsh@geuz.org>.
//
// Contributor(s):
// Pascale Noyret
#include <map>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include "GModel.h" #include "GModel.h"
#include "GModelIO_MED.h"
#include "MVertex.h" #include "MVertex.h"
#include "MEdge.h" #include "MEdge.h"
#include "Message.h" #include "Message.h"
#if defined(HAVE_MED) #if defined(HAVE_MED)
#include <map>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include "GModelIO_MED.h"
extern "C" { extern "C" {
#include "med.h" #include "med.h"
} }
...@@ -44,6 +41,11 @@ ConversionData Data::MyConversionData; ...@@ -44,6 +41,11 @@ ConversionData Data::MyConversionData;
typedef std::list<int>::const_iterator listIter; typedef std::list<int>::const_iterator listIter;
// _____________________________________________ //
// //
// Implementation de la classe ConversionData //
// ____________________________________________ //
ConversionData::ConversionData() ConversionData::ConversionData()
{ {
// Correspondance des types GMSH et MEd // Correspondance des types GMSH et MEd
...@@ -60,18 +62,6 @@ ConversionData::ConversionData() ...@@ -60,18 +62,6 @@ ConversionData::ConversionData()
++i; ++i;
} }
// *****************************************************
// elements GMSH avec un nb de noeuds differents en Med
// *****************************************************
static const int secondOrderElts[] = { 10, 12, 13, 14 , 0};
static const int NbNodesInMed[] = { 8, 20, 15, 13 , 0};
i=0;
while (secondOrderElts[i] != 0)
{
maxEltInMed[secondOrderElts[i]]=NbNodesInMed[i];
++i;
}
// ************************** // **************************
// Numrotation des Noeuds // Numrotation des Noeuds
// ************************** // **************************
...@@ -185,17 +175,11 @@ ConversionData::ConversionData() ...@@ -185,17 +175,11 @@ ConversionData::ConversionData()
} }
}; };
int ConversionData::inMaxEltInMed(int clef)
{
std::map<int,int>::const_iterator MyIter;
MyIter = maxEltInMed.find(clef);
if ( MyIter != maxEltInMed.end() )
return 1;
return 0;
};
// ____________________________________ //
// //
// Implementation de la classe MedIO //
// ___________________________________ //
MedIO::MedIO() : _numOfNode(1), _boolOpen(0), _meshName("monMaillage") MedIO::MedIO() : _numOfNode(1), _boolOpen(0), _meshName("monMaillage")
{ {
...@@ -236,10 +220,12 @@ int MedIO::SetFile(const std::string &FileName) ...@@ -236,10 +220,12 @@ int MedIO::SetFile(const std::string &FileName)
} }
// ------------------------------------------------- // -------------------------------------------------
int MedIO::AddVertex(MVertex* v, const int famille) int MedIO::AddNode(MVertex* v, const int famille)
// ------------------------------------------------- // -------------------------------------------------
{ {
// Msg(INFO, "Creation "); //Msg(INFO, "Creation %d", v->getNum());
if ( elements.find(v->getNum()) != elements.end() ) return 1;
coordonnees.push_back((med_float)v->x()); coordonnees.push_back((med_float)v->x());
coordonnees.push_back((med_float)v->y()); coordonnees.push_back((med_float)v->y());
coordonnees.push_back((med_float)v->z()); coordonnees.push_back((med_float)v->z());
...@@ -254,7 +240,7 @@ int MedIO::AddVertex(MVertex* v, const int famille) ...@@ -254,7 +240,7 @@ int MedIO::AddVertex(MVertex* v, const int famille)
} }
// ------------------------------- // -------------------------------
int MedIO::CreateNodeFam( ) int MedIO::CreateFamilles( )
// ------------------------------- // -------------------------------
{ {
numFamilles.insert(0); numFamilles.insert(0);
...@@ -264,8 +250,8 @@ int MedIO::CreateNodeFam( ) ...@@ -264,8 +250,8 @@ int MedIO::CreateNodeFam( )
if (*itFam != 0 ) if (*itFam != 0 )
{ std::ostringstream oss; { std::ostringstream oss;
oss << *itFam; oss << *itFam;
std::string fam = "Famille" + oss.str(); std::string fam = "F_" + oss.str();
std::string group = "Groupe" + oss.str(); std::string group = "G_" + oss.str();
while (group.size() < 80) group = group + " "; while (group.size() < 80) group = group + " ";
CR = MEDfamCr (_fid, (char *) _meshName.c_str(),(char *)fam.c_str(),*itFam, 0,0,0,0,(char *)group.c_str(),1); CR = MEDfamCr (_fid, (char *) _meshName.c_str(),(char *)fam.c_str(),*itFam, 0,0,0,0,(char *)group.c_str(),1);
CR=0; CR=0;
...@@ -284,9 +270,6 @@ int MedIO::CreateNodeFam( ) ...@@ -284,9 +270,6 @@ int MedIO::CreateNodeFam( )
return 1; return 1;
} }
int MedIO::CreateElemtFam( )
{}
// ------------------------------- // -------------------------------
int MedIO::CreateElemt() int MedIO::CreateElemt()
...@@ -297,10 +280,10 @@ int MedIO::CreateElemt() ...@@ -297,10 +280,10 @@ int MedIO::CreateElemt()
med_geometrie_element typemed =(*eltIter).second; med_geometrie_element typemed =(*eltIter).second;
if (typemed == MED_POINT1) continue; if (typemed == MED_POINT1) continue;
int nbNoeudElt = typemed % 100 ; int nbNoeudElt = typemed % 100 ;
int nbElements = connectivities[typemed].size() / nbNoeudElt; int nbElements = LesConn[typemed].size() / nbNoeudElt;
if (nbElements != 0 ) if (nbElements != 0 )
med_err CR = MEDelementsEcr (_fid, (char*) _meshName.c_str(),(med_int) 3, med_err CR = MEDelementsEcr (_fid, (char*) _meshName.c_str(),(med_int) 3,
&connectivities[typemed][0], MED_FULL_INTERLACE, &LesConn[typemed][0], MED_FULL_INTERLACE,
NULL, MED_FAUX, NULL, MED_FAUX, NULL, MED_FAUX, NULL, MED_FAUX,
&famElts[typemed][0],nbElements, &famElts[typemed][0],nbElements,
MED_MAILLE,typemed,MED_NOD); MED_MAILLE,typemed,MED_NOD);
...@@ -327,20 +310,13 @@ int MedIO::Ecrit() ...@@ -327,20 +310,13 @@ int MedIO::Ecrit()
// ********************* // *********************
// Creation des Familles // Creation des Familles
// ********************* // *********************
int CRFam = CreateNodeFam(); int CRFam = CreateFamilles();
if ( CRFam < 0 ) if ( CRFam < 0 )
{ {
Msg(GERROR, "Error in Nodes Families Creation "); Msg(GERROR, "Error in Nodes Families Creation ");
return 0; return 0;
} }
int CRFamElt = CreateElemtFam();
if ( CRFamElt < 0 )
{
Msg(GERROR, "Error in Elements Families Creation ");
return 0;
}
// ************************* // *************************
// Creation des Coordonnees // Creation des Coordonnees
// ************************* // *************************
...@@ -389,10 +365,11 @@ int GModel::writeMED(const std::string &name) ...@@ -389,10 +365,11 @@ int GModel::writeMED(const std::string &name)
MedIO MedDriver=MedIO(); MedIO MedDriver=MedIO();
int CR1 =MedDriver.SetFile(name); int CR1 =MedDriver.SetFile(name);
MedDriver.WriteNodes(vertices); renumberMeshVertices();
MedDriver.WriteNodes(edges); MedDriver.TraiteMed(vertices);
MedDriver.WriteNodes(faces); MedDriver.TraiteMed(edges);
MedDriver.WriteNodes(regions); MedDriver.TraiteMed(faces);
MedDriver.TraiteMed(regions);
int CR2 = MedDriver.Ecrit(); int CR2 = MedDriver.Ecrit();
int CR3 = MedDriver.CloseFile(); int CR3 = MedDriver.CloseFile();
...@@ -409,4 +386,5 @@ int GModel::writeMED(const std::string &name) ...@@ -409,4 +386,5 @@ int GModel::writeMED(const std::string &name)
return 0; return 0;
} }
#endif #endif // du HAVE_LIBMED
Geo/GModelIO_MED.h
+ 144
− 162
View file @ 5f1aa98d
#ifndef _GMODELIO_MED_H_ #ifndef _GMODELIO_MED_H_
#define _GMODELIO_MED_H_ #define _GMODELIO_MED_H_
// Copyright (C) 1997-2007 C. Geuzaine, J.-F. Remacle
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA.
//
// Please report all bugs and problems to <gmsh@geuz.org>.
//
// Contributor(s):
// Pascale Noyret
#include <string> #include <string>
#include <map> #include <map>
#include <vector> #include <vector>
...@@ -43,19 +21,23 @@ extern "C" ...@@ -43,19 +21,23 @@ extern "C"
} }
typedef std::map<med_geometrie_element,std::vector<int> > connectivities; typedef std::map<med_geometrie_element,std::vector<int> > connectivities;
typedef std::list<int>::const_iterator listIter; typedef std::set<int> setFamille;
typedef std::map<int,int>numero;
typedef std::set<int>setFamille;
class MedIO ;
// _________________________________________ //
// //
// Declaration de la classe ConversionData //
// (implementation ds le cpp) //
// ________________________________________ //
//
class ConversionData class ConversionData
{ {
public : public :
ConversionData(); ConversionData();
int inMaxEltInMed(int clef);
std::map<int,med_geometrie_element> typesOfElts; std::map<int,med_geometrie_element> typesOfElts;
std::map<int,int> maxEltInMed;
std::map<int,std::list<int> > medVertexOrder; std::map<int,std::list<int> > medVertexOrder;
std::map<int,int> familleParDimension; std::map<int,int> familleParDimension;
...@@ -63,6 +45,12 @@ class ConversionData ...@@ -63,6 +45,12 @@ class ConversionData
}; };
// _________________________________________________ //
// //
// Declaration de la classe TraiteMailledeBase //
// (implementations en fin de fichier) //
// ________________________________________________ //
class Data class Data
{ {
public : public :
...@@ -70,120 +58,69 @@ class Data ...@@ -70,120 +58,69 @@ class Data
}; };
template<class T> template<class T>
class MontraitementDeBase : Data class TraiteMailledeBase : Data
{ {
protected: protected:
static inline int RecupereFamille(const T &ele, setFamille & numFamilles, const int dimension)
{
int famille = 0;
if (ele.physicals.size() != 0)
famille=ele.physicals[0];
if (famille == 0) return 0;
if (famille > 0) famille = -1 * famille; static inline int RecupereFamille(const T &ele, const int dimension, MedIO & monDriver);
template<class G> static void RecupereElement(const std::vector<G*> &ele, const int famille, MedIO& monDriver);
// On verifie qu il s agit de la bonne dimension };
int familleInitiale=famille;
while (MyConversionData.familleParDimension[famille] != dimension)
{
if (numFamilles.find(famille) == numFamilles.end())
{
numFamilles.insert(famille);
MyConversionData.familleParDimension[famille]=dimension;
}
else
{
famille=famille-1000;
}
//Msg(INFO, "famille %d", famille);
}
MyConversionData.famillefamille[familleInitiale]=famille;
return famille;
}
template < class G>
static void RecupereElement(const std::vector<G*> &ele , connectivities &maMap, connectivities &mesFamilles,
numero& elements , const int famille) {
if (ele.size() == 0) return;
const int type=ele[0]->getTypeForMSH();
const med_geometrie_element medType= Data::MyConversionData.typesOfElts[type];
for (unsigned int elt = 0; elt < ele.size(); ++elt) {
const int monNum=ele[elt]->getNum();
for (listIter monIter = Data::MyConversionData.medVertexOrder[type].begin();
monIter != Data::MyConversionData.medVertexOrder[type].end();
++monIter) {
const int NoeudATraiter = *monIter - 1;
const int Noeud = ele[elt]->getVertex(NoeudATraiter)->getNum();
maMap[medType].push_back(elements[Noeud]);
}
mesFamilles[medType].push_back(famille); // _________________________________________________ //
} // //
} // Specialisations de la classe TraiteMailledeBase //
}; // selon le type de maille //
// ________________________________________________ //
template <class T> template <class T>
struct MonTraitement : public MontraitementDeBase<T>{ struct TraiteMaille : public TraiteMailledeBase<T> {
static inline void AddElement(const T & ele,connectivities & maMap, connectivities &mesFamilles, numero& elements ,setFamille& numFamilles) static inline void AddElement(const T& ele, MedIO & monDriver)
{ { Msg(GERROR, "Wrong Call : basic Method AddElt"); };
Msg(GERROR, "Wrong Call : basic Method AddElt");
}
}; };
template <> template <>
struct MonTraitement<GVertex> : public MontraitementDeBase<GVertex>{ struct TraiteMaille<GVertex> : public TraiteMailledeBase<GVertex> {
static inline void AddElement(const GVertex & ele, connectivities & maMap, connectivities &mesFamilles, numero& elements ,setFamille & numFamilles) { static inline void AddElement(const GVertex & ele, MedIO& monDriver) ;
// Pour les Noeuds on ne fait rien ni sur la connectivite ni sur les familles // l'implementation est en fin de fichier pour pouvoir utiliser la methode AddNode de MedIO
}
}; };
template <> template <>
struct MonTraitement<GEdge> : public MontraitementDeBase<GEdge>{ struct TraiteMaille<GEdge> : public TraiteMailledeBase<GEdge> {
static inline void AddElement(const GEdge & ele, connectivities & maMap, connectivities &mesFamilles, numero& elements, setFamille & numFamilles) { static inline void AddElement(const GEdge & ele, MedIO& monDriver)
RecupereElement (ele.lines, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 1)); {
} RecupereElement (ele.lines, RecupereFamille(ele, 1, monDriver), monDriver);
}
}; };
template <> template <>
struct MonTraitement<GFace> : public MontraitementDeBase<GFace>{ struct TraiteMaille<GFace> : public TraiteMailledeBase<GFace> {
static inline void AddElement(const GFace & ele, connectivities & maMap, connectivities &mesFamilles, numero& elements , setFamille & numFamilles) { static inline void AddElement(const GFace & ele, MedIO& monDriver)
RecupereElement (ele.triangles, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 2)); {
RecupereElement (ele.quadrangles, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 2)); RecupereElement (ele.triangles, RecupereFamille(ele, 2, monDriver), monDriver);
} RecupereElement (ele.quadrangles, RecupereFamille(ele, 2, monDriver), monDriver);
}
}; };
template <> template <>
struct MonTraitement<GRegion> : public MontraitementDeBase<GRegion>{ struct TraiteMaille<GRegion> : public TraiteMailledeBase<GRegion>{
static inline void AddElement(const GRegion & ele, connectivities & maMap, connectivities &mesFamilles, numero& elements, setFamille & numFamilles) { static inline void AddElement(const GRegion & ele, MedIO & monDriver)
RecupereElement (ele.tetrahedra, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 3)); {
RecupereElement (ele.hexahedra, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 3)); RecupereElement (ele.tetrahedra, RecupereFamille(ele, 3, monDriver), monDriver );
RecupereElement (ele.prisms, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 3)); RecupereElement (ele.hexahedra, RecupereFamille(ele, 3, monDriver), monDriver);
RecupereElement (ele.pyramids, maMap, mesFamilles, elements, RecupereFamille(ele, numFamilles, 3)); RecupereElement (ele.prisms, RecupereFamille(ele, 3, monDriver), monDriver);
RecupereElement (ele.pyramids, RecupereFamille(ele, 3, monDriver), monDriver);
} }
}; };
template<class T> struct TraiteFamille // ______________________________________ //
{ // //
static inline int GetFamille (const T& element) // Declaration de la classe MedIO //
{ // (implementation ds le cpp) //
// On ne traite pas les familles d 'elements a ce stade // _____________________________________ //
return 0;
}
};
template<>
struct TraiteFamille<GVertex>
{
static inline int GetFamille (const GVertex& element)
{
int famille = 0;
if (element.physicals.size() != 0 ) famille = element.physicals[0];
return famille;
}
};
class MVertex; class MVertex;
class MEdge; class MEdge;
...@@ -191,73 +128,118 @@ class MedIO ...@@ -191,73 +128,118 @@ class MedIO
{ {
public: public:
MedIO(); MedIO();
int SetFile (const std::string& theFileName); int SetFile (const std::string& theFileName);
int AddVertex (MVertex* const v, const int famille ); int AddNode (MVertex* const v, const int famille );
int AddEdge (MEdge* const e ); int Ecrit ();
int Ecrit (); int CloseFile ();
int CloseFile ();
private : private :
int CreateNodeFam(); int CreateFamilles();
int CreateElemtFam();
int CreateElemt(); int CreateElemt();
private : public :
std::string _FileName; connectivities LesConn;
std::map<med_geometrie_element,std::vector<int> > connectivities; setFamille numFamilles;
std::vector<int> families;
std::map<int,int> elements;
std::map<med_geometrie_element,std::vector<int> > famElts; std::map<med_geometrie_element,std::vector<int> > famElts;
private :
std::vector<med_float> coordonnees; std::vector<med_float> coordonnees;
std::vector<int> families; std::vector<med_int> numOpt;
std::vector<med_int> numOpt;
std::map<int,int> elements;
std::set<int> numFamilles;
int _numOfNode; int _numOfNode;
int _boolOpen; int _boolOpen;
med_idt _fid; med_idt _fid;
std::string _meshName; std::string _FileName;
std::string _meshName;
public : public :
static ConversionData MyConversionData ; static ConversionData MyConversionData ;
template<class T> template<class T>
void WriteNodes(const std::set<T*,GEntityLessThan> & seq) void TraiteMed(const std::set<T*,GEntityLessThan> & seq)
{ {
typename std::set<T*,GEntityLessThan>::const_iterator iter=seq.begin(); typename std::set<T*,GEntityLessThan>::const_iterator iter=seq.begin();
for ( ; iter != seq.end() ; ++iter) for ( ; iter != seq.end() ; ++iter)
{ {
const T& element= *(*iter); const T& element= *(*iter);
TraiteMaille<T>::AddElement(element, *this);
}
}
};
//Msg(INFO," Type d element %s", typeid(element).name()); // _______________________________________________________________ //
// //
// Implementation des Methodes des classes de type TraiteElement //
// qui utilisent MedIO //
// _______________________________________________________________ //
void TraiteMaille<GVertex>::AddElement(const GVertex & ele, MedIO& monDriver)
{
int famille = 0;
if (ele.physicals.size() != 0 ) famille = ele.physicals[0];
monDriver.AddNode(ele.mesh_vertices[0],famille);
}
// Traitement des Noeuds // *-*-*-*-*-*-*-*-*-*
// Calcul du nombre de noeuds a stocker dans Med
unsigned int thisSize=element.mesh_vertices.size();
if (Data::MyConversionData.inMaxEltInMed(element.tag()) == 1)
{
const unsigned int maxSize = Data::MyConversionData.maxEltInMed[element.tag()];
if (maxSize < thisSize) thisSize = maxSize ;
};
// stockage du Noeud template<class T> int TraiteMailledeBase<T>::RecupereFamille(const T &ele, const int dimension, MedIO & monDriver)
int famille=TraiteFamille<T>::GetFamille(element); //
for (unsigned int i = 0; i < thisSize; ++i) // Dans le format MED, Les familles de mailles sont negatives (contrairement au physical group de GMSH)
{ // Les familles ne contiennent des mailles de la meme dimension
AddVertex (element.mesh_vertices[i], famille); {
}; int famille = 0;
if (ele.physicals.size() != 0) famille=ele.physicals[0];
if (famille == 0) return 0;
// Stockage des Egdes if (famille > 0) famille = -1 * famille;
MonTraitement<T>::AddElement(element,connectivities,famElts,elements,numFamilles);
} int familleInitiale=famille;
while (MyConversionData.familleParDimension[famille] != dimension)
{
if (monDriver.numFamilles.find(famille) == monDriver.numFamilles.end())
{ monDriver.numFamilles.insert(famille);
MyConversionData.familleParDimension[famille]=dimension;
}
else famille=famille-1000;
}
MyConversionData.famillefamille[familleInitiale]=famille;
return famille;
} }
};
// *-*-*-*-*-*-*-*-*-*
template<class T>
template<class G> void TraiteMailledeBase<T>::RecupereElement(const std::vector<G*> &ele, const int famille, MedIO& monDriver)
// l'implementation aurait pu etre laissee avec la declaration (ok pour GCC 3.3.5)
// mais pour eviter des eventuels pb de portage il semble preferable de la separer
{
typedef std::list<int>::const_iterator listIter;
# endif if (ele.size() == 0) return;
const int type=ele[0]->getTypeForMSH();
const med_geometrie_element medType= Data::MyConversionData.typesOfElts[type];
for (unsigned int elt = 0; elt < ele.size(); ++elt) {
const int monNum=ele[elt]->getNum();
for (listIter monIter = Data::MyConversionData.medVertexOrder[type].begin();
monIter != Data::MyConversionData.medVertexOrder[type].end();
++monIter) {
const int NoeudATraiter = *monIter - 1;
const int Noeud = ele[elt]->getVertex(NoeudATraiter)->getNum();
monDriver.AddNode(ele[elt]->getVertex(NoeudATraiter),0);
monDriver.LesConn[medType].push_back(monDriver.elements[Noeud]);
}
monDriver.famElts[medType].push_back(famille);
}
}
#endif #endif // du HAVE_LIBMED
#endif // du define de _GMODELIO_MED_H_
Geo/GModelIO_OCC.cpp
+ 2
− 37
View file @ 5f1aa98d
// $Id: GModelIO_OCC.cpp,v 1.19 2007-02-27 22:09:44 geuzaine Exp $ // $Id: GModelIO_OCC.cpp,v 1.20 2007-04-23 07:59:25 geuzaine Exp $
// //
// Copyright (C) 1997-2007 C. Geuzaine, J.-F. Remacle // Copyright (C) 1997-2007 C. Geuzaine, J.-F. Remacle
// //
...@@ -19,10 +19,9 @@ ...@@ -19,10 +19,9 @@
// //
// Please report all bugs and problems to <gmsh@geuz.org>. // Please report all bugs and problems to <gmsh@geuz.org>.
#include "GModel.h" #include "GModelIO_OCC.h"
#include "Message.h" #include "Message.h"
#include "Context.h" #include "Context.h"
#include "OCCIncludes.h"
#include "OCCVertex.h" #include "OCCVertex.h"
#include "OCCEdge.h" #include "OCCEdge.h"
#include "OCCFace.h" #include "OCCFace.h"
...@@ -32,40 +31,6 @@ extern Context_T CTX; ...@@ -32,40 +31,6 @@ extern Context_T CTX;
#if defined(HAVE_OCC) #if defined(HAVE_OCC)
#include "ShapeAnalysis_ShapeTolerance.hxx"
#include "ShapeAnalysis_ShapeContents.hxx"
#include "ShapeAnalysis_CheckSmallFace.hxx"
#include "ShapeAnalysis_DataMapOfShapeListOfReal.hxx"
#include "BRepAlgoAPI_Fuse.hxx"
#include "BRepCheck_Analyzer.hxx"
#include "BRepLib.hxx"
#include "ShapeBuild_ReShape.hxx"
#include "ShapeFix.hxx"
#include "ShapeFix_FixSmallFace.hxx"
class OCC_Internals {
TopoDS_Shape shape;
TopTools_IndexedMapOfShape fmap, emap, vmap, somap, shmap, wmap;
public:
OCC_Internals()
{
somap.Clear();
shmap.Clear();
fmap.Clear();
wmap.Clear();
emap.Clear();
vmap.Clear();
}
void HealGeometry(double tolerance, bool fixsmalledges,
bool fixspotstripfaces, bool sewfaces,
bool makesolids=false);
void loadSTEP(const char *);
void loadIGES(const char *);
void loadBREP(const char *);
void buildGModel(GModel *gm);
void buildLists();
};
void OCC_Internals::buildLists() void OCC_Internals::buildLists()
{ {
TopExp_Explorer exp0, exp1, exp2, exp3, exp4, exp5; TopExp_Explorer exp0, exp1, exp2, exp3, exp4, exp5;
......
Geo/GModelIO_OCC.h 0 → 100644
+ 66
− 0
View file @ 5f1aa98d
#ifndef _GMODELIO_OCC_H_
#define _GMODELIO_OCC_H_
// $Id: GModelIO_OCC.h,v 1.1 2007-04-23 07:59:25 geuzaine Exp $
//
// Copyright (C) 1997-2007 C. Geuzaine, J.-F. Remacle
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA.
//
// Please report all bugs and problems to <gmsh@geuz.org>.
#include "GModel.h"
#include "OCCIncludes.h"
#if defined(HAVE_OCC)
#include "ShapeAnalysis_ShapeTolerance.hxx"
#include "ShapeAnalysis_ShapeContents.hxx"
#include "ShapeAnalysis_CheckSmallFace.hxx"
#include "ShapeAnalysis_DataMapOfShapeListOfReal.hxx"
#include "BRepAlgoAPI_Fuse.hxx"
#include "BRepCheck_Analyzer.hxx"
#include "BRepLib.hxx"
#include "ShapeBuild_ReShape.hxx"
#include "ShapeFix.hxx"
#include "ShapeFix_FixSmallFace.hxx"
class OCC_Internals {
protected :
TopoDS_Shape shape;
TopTools_IndexedMapOfShape fmap, emap, vmap, somap, shmap, wmap;
public:
OCC_Internals()
{
somap.Clear();
shmap.Clear();
fmap.Clear();
wmap.Clear();
emap.Clear();
vmap.Clear();
}
void HealGeometry(double tolerance, bool fixsmalledges,
bool fixspotstripfaces, bool sewfaces,
bool makesolids=false);
void loadSTEP(const char *);
void loadIGES(const char *);
void loadBREP(const char *);
void buildGModel(GModel *gm);
void buildLists();
};
#endif
#endif
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment