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;
}

MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(char *nom_ficher,bool export_step,bool import_stl,double precision,double eps)
{
  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,precision);
  if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);  
  return 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:	731
Committed:	Mon Sep 21 22:31:27 2015 UTC (9 years, 7 months ago) by francois
File size:	9647 byte(s)
Log Message:	Correction des periodicites dans opencascade Correction des importation de surface et courbe dans opencascade en respectant tous nos besoins Ajout d'un langage script pour construire des arbres de construction sous opencascade avec un cas test
#	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	francois	731	MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(char *nom_ficher,bool export_step,bool import_stl,double precision,double eps)
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	francois	731	MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
350			if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);
351	francois	690	return mggeo;
352	francois	686	}
353
354
355			MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
356			{
357			return gest;
358			}
359
360			void MG_ARBRE::enregistrer(std::ostream& o)
361			{
362	francois	689	o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<");" << std::endl;
363	francois	686	LISTE_ENTITE::const_iterator i;
364			for (i=lst_entite.begin();i!=lst_entite.end();i++)
365			{
366			MG_IDENTIFICATEUR* entite = *i;
367			entite->enregistrer(o);
368			}
369
370			}