geometrie/src/mg_arbre.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       mg_maillage.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include <fstream>
#include <iostream>


#include "mg_arbre.h"
#include "mg_primitive.h"
#include "mg_operateur_boolean.h"
#include "mg_gestionnaire.h"


//include Open_Cascade
#include <Standard_TypeDef.hxx>
#include <Standard_Macro.hxx>
#include <TopoDS_Shape.hxx>
#include <BRepTools.hxx>
#include <TDocStd_Document.hxx>
#include <XCAFApp_Application.hxx>
#include <XCAFDoc_ShapeTool.hxx>
#include <XCAFDoc_DocumentTool.hxx>
#include <STEPCAFControl_Writer.hxx>
#include <Handle_TDocStd_Document.hxx>
#include <Handle_XCAFApp_Application.hxx>
#include <Handle_XCAFDoc_ShapeTool.hxx>


MG_ARBRE::MG_ARBRE(std::string nm):MG_IDENTIFICATEUR(),nom(nm)
{
}


MG_ARBRE::MG_ARBRE(long unsigned int num,std::string nm): MG_IDENTIFICATEUR(num),nom(nm)
{
}


MG_ARBRE::MG_ARBRE(MG_ARBRE& mdd):MG_IDENTIFICATEUR(mdd),nom(mdd.nom)
{
}


MG_ARBRE::~MG_ARBRE()
{
supprimer_tout_mg_operateur_boolean();
supprimer_tout_mg_primitive();
}


void MG_ARBRE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
{
    gest=mggest;
}

// ENTITE MG_PRIMITIVE
int MG_ARBRE::ajouter_mg_primitive(MG_PRIMITIVE* mgprim)
{
    gest->recherche_bonid(*mgprim);
    MG_IDENTIFICATEUR *id=mgprim;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
    lst_mg_primitive.insert(tmp);
    return OK;
}


MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
{
    LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
    if (i==lst_mg_primitive.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
{
    if (!(num<lst_mg_primitive.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_ARBRE::get_nb_mg_primitive(void)
{
    return lst_mg_primitive.size();
}


int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
{
    MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
    if (mgprim==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgprim;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
    lst_mg_primitive.erase(j);
    delete mgprim;
    return OK;
}


int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
{
    MG_PRIMITIVE* mgprim=get_mg_primitive(num);
    if (mgprim==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgprim;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_primitive.erase(j);
    delete mgprim;
    return OK;
}


void MG_ARBRE::supprimer_tout_mg_primitive(void)
{
    while (get_nb_mg_primitive()!=0)
    {
        LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
        MG_PRIMITIVE* mgprim=(*j).second;
        MG_IDENTIFICATEUR* id=mgprim;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_primitive.erase(j);
        delete mgprim;
    }
}


MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
{
    it = lst_mg_primitive.begin();
    if (it == lst_mg_primitive.end())
        return NULL;
    return it->second;
}

MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
{
    it++;
    if (it == lst_mg_primitive.end())
        return NULL;
    return it->second;
}

// ENTITE MG_OPERATEUR_BOOLEAN
int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
{
    gest->recherche_bonid(*mgop);
    MG_IDENTIFICATEUR *id=mgop;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
    lst_mg_operateur_boolean.insert(tmp);
    return OK;
}


MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
{
    LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
    if (i==lst_mg_operateur_boolean.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
{
    if (!(num<lst_mg_operateur_boolean.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
{
    return lst_mg_operateur_boolean.size();
}


int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
{
    MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
    if (mgop==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgop;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
    lst_mg_operateur_boolean.erase(j);
    delete mgop;
    return OK;
}


int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
{
    MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
    if (mgop==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgop;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_operateur_boolean.erase(j);
    delete mgop;
    return OK;
}


void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
{
    while (get_nb_mg_operateur_boolean()!=0)
    {
        LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
        MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
        MG_IDENTIFICATEUR* id=mgop;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_operateur_boolean.erase(j);
        delete mgop;
    }
}


MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
{
    it = lst_mg_operateur_boolean.begin();
    if (it == lst_mg_operateur_boolean.end())
        return NULL;
    return it->second;
}

MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
{
    it++;
    if (it == lst_mg_operateur_boolean.end())
        return NULL;
    return it->second;
}

void MG_ARBRE::evaluer_geometrie(char *nom_ficher,bool export_step,bool import_stl)
{
  int nb_primitive = get_nb_mg_primitive();
  char nom_fichier_brep[500];
  strcpy(nom_fichier_brep,nom_ficher);
  strcat(nom_fichier_brep,".brep");
  BRepTools::Write(get_mg_primitive(nb_primitive-1)->get_forme(),nom_fichier_brep);
  if(export_step==true)
  {
    char nom_fichier_step[500];
    strcpy(nom_fichier_step,nom_ficher);
    strcat(nom_fichier_step,".step");
    Handle(TDocStd_Document) Doc;
    Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
    App->NewDocument("MDTV-XCAF",Doc);  
    Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
    STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
    TDF_Label Label_shape = myShapeTool->NewShape();
    myShapeTool->SetShape(Label_shape, get_mg_primitive(nb_primitive-1)->get_forme());
    myWriter->Perform(Doc,nom_fichier_step);
  }
  OCC_IMPORT occimport;
  MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC);
  if(import_stl==true) occimport.importer(*gest,mggeo);  
}
 

MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
{
    return gest;
}

void MG_ARBRE::enregistrer(std::ostream& o)
{
o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<")" << std::endl;  
LISTE_ENTITE::const_iterator i;
for (i=lst_entite.begin();i!=lst_entite.end();i++)
    {
        MG_IDENTIFICATEUR* entite = *i;
        entite->enregistrer(o);
    }
 
}
Revision:	687
Committed:	Tue Jul 7 19:54:23 2015 UTC (9 years, 10 months ago) by couturad
File size:	9553 byte(s)
Log Message:	Modification de l'arbre caractéristique : - Ajout d'une fonction de création de boite - Ajout d'un opérateur boolean d'union - Enregistrement du modèle brep et step
#	User	Rev	Content
1	francois	686	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuilli�re et Vincent FRANCOIS
5			// D�partement de G�nie M�canique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du d�partement
8			// de g�nie m�canique de l'Universit� du Qu�bec �
9			// Trois Rivi�res
10			// Les librairies ne peuvent �tre utilis�es sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// mg_maillage.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 � 11H22
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26			#include <fstream>
27			#include <iostream>
28
29
30			#include "mg_arbre.h"
31			#include "mg_primitive.h"
32			#include "mg_operateur_boolean.h"
33			#include "mg_gestionnaire.h"
34
35
36	couturad	687	//include Open_Cascade
37			#include <Standard_TypeDef.hxx>
38			#include <Standard_Macro.hxx>
39			#include <TopoDS_Shape.hxx>
40			#include <BRepTools.hxx>
41			#include <TDocStd_Document.hxx>
42			#include <XCAFApp_Application.hxx>
43			#include <XCAFDoc_ShapeTool.hxx>
44			#include <XCAFDoc_DocumentTool.hxx>
45			#include <STEPCAFControl_Writer.hxx>
46			#include <Handle_TDocStd_Document.hxx>
47			#include <Handle_XCAFApp_Application.hxx>
48			#include <Handle_XCAFDoc_ShapeTool.hxx>
49	francois	686
50	couturad	687
51
52	francois	686	MG_ARBRE::MG_ARBRE(std::string nm):MG_IDENTIFICATEUR(),nom(nm)
53			{
54			}
55
56
57
58			MG_ARBRE::MG_ARBRE(long unsigned int num,std::string nm): MG_IDENTIFICATEUR(num),nom(nm)
59			{
60			}
61
62
63
64			MG_ARBRE::MG_ARBRE(MG_ARBRE& mdd):MG_IDENTIFICATEUR(mdd),nom(mdd.nom)
65			{
66			}
67
68
69
70
71			MG_ARBRE::~MG_ARBRE()
72			{
73			supprimer_tout_mg_operateur_boolean();
74			supprimer_tout_mg_primitive();
75			}
76
77
78
79			void MG_ARBRE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
80			{
81			gest=mggest;
82			}
83
84			// ENTITE MG_PRIMITIVE
85			int MG_ARBRE::ajouter_mg_primitive(MG_PRIMITIVE* mgprim)
86			{
87			gest->recherche_bonid(*mgprim);
88			MG_IDENTIFICATEUR *id=mgprim;
89			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
90			if (!p.second)
91			{
92			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
93			return FAIL;
94			}
95
96			std::pair<const unsigned long,MG_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
97			lst_mg_primitive.insert(tmp);
98			return OK;
99			}
100
101
102
103
104			MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
105			{
106			LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
107			if (i==lst_mg_primitive.end())
108			{
109			// afficheur << INEXISTE << enderr;
110			return NULL;
111			}
112			return ((*i).second);
113			}
114
115
116
117			MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
118			{
119			if (!(num<lst_mg_primitive.size()))
120			{
121			// afficheur << INEXISTE << enderr;
122			return NULL;
123			}
124			LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.begin();
125			for (unsigned long j=0;j<num;j++) i++;
126			return ((*i).second);
127			}
128
129
130
131			unsigned int MG_ARBRE::get_nb_mg_primitive(void)
132			{
133			return lst_mg_primitive.size();
134			}
135
136
137			int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
138			{
139			MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
140			if (mgprim==NULL)
141			{
142			// afficheur << INEXISTE2 << enderr;
143			return FAIL;
144			}
145			MG_IDENTIFICATEUR* id=mgprim;
146			LISTE_ENTITE::iterator i=lst_entite.find(id);
147			lst_entite.erase(i);
148			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
149			lst_mg_primitive.erase(j);
150			delete mgprim;
151			return OK;
152			}
153
154
155			int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
156			{
157			MG_PRIMITIVE* mgprim=get_mg_primitive(num);
158			if (mgprim==NULL)
159			{
160			// afficheur << INEXISTE2 << enderr;
161			return FAIL;
162			}
163			MG_IDENTIFICATEUR* id=mgprim;
164			LISTE_ENTITE::iterator i=lst_entite.find(id);
165			lst_entite.erase(i);
166			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
167			for (unsigned int k=0;k<num;k++) j++;
168			lst_mg_primitive.erase(j);
169			delete mgprim;
170			return OK;
171			}
172
173
174			void MG_ARBRE::supprimer_tout_mg_primitive(void)
175			{
176			while (get_nb_mg_primitive()!=0)
177			{
178			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
179			MG_PRIMITIVE* mgprim=(*j).second;
180			MG_IDENTIFICATEUR* id=mgprim;
181			LISTE_ENTITE::iterator i=lst_entite.find(id);
182			lst_entite.erase(i);
183			lst_mg_primitive.erase(j);
184			delete mgprim;
185			}
186			}
187
188
189			MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
190			{
191			it = lst_mg_primitive.begin();
192			if (it == lst_mg_primitive.end())
193			return NULL;
194			return it->second;
195			}
196
197			MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
198			{
199			it++;
200			if (it == lst_mg_primitive.end())
201			return NULL;
202			return it->second;
203			}
204
205			// ENTITE MG_OPERATEUR_BOOLEAN
206			int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
207			{
208			gest->recherche_bonid(*mgop);
209			MG_IDENTIFICATEUR *id=mgop;
210			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
211			if (!p.second)
212			{
213			// afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
214			return FAIL;
215			}
216
217			std::pair<const unsigned long,MG_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
218			lst_mg_operateur_boolean.insert(tmp);
219			return OK;
220			}
221
222
223
224
225			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
226			{
227			LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
228			if (i==lst_mg_operateur_boolean.end())
229			{
230			// afficheur << INEXISTE << enderr;
231			return NULL;
232			}
233			return ((*i).second);
234			}
235
236
237
238			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
239			{
240			if (!(num<lst_mg_operateur_boolean.size()))
241			{
242			// afficheur << INEXISTE << enderr;
243			return NULL;
244			}
245			LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.begin();
246			for (unsigned long j=0;j<num;j++) i++;
247			return ((*i).second);
248			}
249
250
251
252			unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
253			{
254			return lst_mg_operateur_boolean.size();
255			}
256
257
258			int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
259			{
260			MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
261			if (mgop==NULL)
262			{
263			// afficheur << INEXISTE2 << enderr;
264			return FAIL;
265			}
266			MG_IDENTIFICATEUR* id=mgop;
267			LISTE_ENTITE::iterator i=lst_entite.find(id);
268			lst_entite.erase(i);
269			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
270			lst_mg_operateur_boolean.erase(j);
271			delete mgop;
272			return OK;
273			}
274
275
276			int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
277			{
278			MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
279			if (mgop==NULL)
280			{
281			// afficheur << INEXISTE2 << enderr;
282			return FAIL;
283			}
284			MG_IDENTIFICATEUR* id=mgop;
285			LISTE_ENTITE::iterator i=lst_entite.find(id);
286			lst_entite.erase(i);
287			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
288			for (unsigned int k=0;k<num;k++) j++;
289			lst_mg_operateur_boolean.erase(j);
290			delete mgop;
291			return OK;
292			}
293
294
295			void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
296			{
297			while (get_nb_mg_operateur_boolean()!=0)
298			{
299			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
300			MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
301			MG_IDENTIFICATEUR* id=mgop;
302			LISTE_ENTITE::iterator i=lst_entite.find(id);
303			lst_entite.erase(i);
304			lst_mg_operateur_boolean.erase(j);
305			delete mgop;
306			}
307			}
308
309
310			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
311			{
312			it = lst_mg_operateur_boolean.begin();
313			if (it == lst_mg_operateur_boolean.end())
314			return NULL;
315			return it->second;
316			}
317
318			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
319			{
320			it++;
321			if (it == lst_mg_operateur_boolean.end())
322			return NULL;
323			return it->second;
324			}
325
326	couturad	687	void MG_ARBRE::evaluer_geometrie(char *nom_ficher,bool export_step,bool import_stl)
327	francois	686	{
328	couturad	687	int nb_primitive = get_nb_mg_primitive();
329			char nom_fichier_brep[500];
330			strcpy(nom_fichier_brep,nom_ficher);
331			strcat(nom_fichier_brep,".brep");
332			BRepTools::Write(get_mg_primitive(nb_primitive-1)->get_forme(),nom_fichier_brep);
333			if(export_step==true)
334			{
335			char nom_fichier_step[500];
336			strcpy(nom_fichier_step,nom_ficher);
337			strcat(nom_fichier_step,".step");
338			Handle(TDocStd_Document) Doc;
339			Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
340			App->NewDocument("MDTV-XCAF",Doc);
341			Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
342			STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
343			TDF_Label Label_shape = myShapeTool->NewShape();
344			myShapeTool->SetShape(Label_shape, get_mg_primitive(nb_primitive-1)->get_forme());
345			myWriter->Perform(Doc,nom_fichier_step);
346			}
347			OCC_IMPORT occimport;
348			MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC);
349			if(import_stl==true) occimport.importer(*gest,mggeo);
350	francois	686	}
351
352
353			MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
354			{
355			return gest;
356			}
357
358			void MG_ARBRE::enregistrer(std::ostream& o)
359			{
360			o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<")" << std::endl;
361			LISTE_ENTITE::const_iterator i;
362			for (i=lst_entite.begin();i!=lst_entite.end();i++)
363			{
364			MG_IDENTIFICATEUR* entite = *i;
365			entite->enregistrer(o);
366			}
367
368			}