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