mtu/src/mg_arbre.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_arbre.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


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


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


#include <Standard_TypeDef.hxx>
#include <Standard_Macro.hxx>
#include <TopoDS_Shape.hxx>
#include <BRepTools.hxx>
#include <BRep_Builder.hxx>
#include <TDocStd_Document.hxx>
#include <XCAFApp_Application.hxx>
#include <XCAFDoc_ShapeTool.hxx>
#include <XCAFDoc_DocumentTool.hxx>
#include <STEPCAFControl_Writer.hxx>
#include <TDocStd_Document.hxx>
#include <XCAFApp_Application.hxx>
#include <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;
}

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)
    {
        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())
    {
        return NULL;
    }
    return ((*i).second);
}


MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
{
    if (!(num<lst_mg_primitive.size()))
    {
        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)
    {
        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)
    {
        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;
}

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)
    {
        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())
    {
        return NULL;
    }
    return ((*i).second);
}


MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
{
    if (!(num<lst_mg_operateur_boolean.size()))
    {
        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)
    {
        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)
    {
        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;
}

int MG_ARBRE::ajouter_mg_assemblage(MG_ASSEMBLAGE* mgassembl)
{
    gest->recherche_bonid(*mgassembl);
    MG_IDENTIFICATEUR *id=mgassembl;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }

    std::pair<const unsigned long,MG_ASSEMBLAGE*> tmp(mgassembl->get_id(),mgassembl);
    lst_mg_assemblage.insert(tmp);
    return OK;
}

MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblage(unsigned int num)
{
    LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
    if (i==lst_mg_assemblage.end())
    {
        return NULL;
    }
    return ((*i).second);
}

MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblageid(long unsigned int num)
{
    LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
    if (i==lst_mg_assemblage.end())
    {
        return NULL;
    }
    return ((*i).second);
}

unsigned int MG_ARBRE::get_nb_mg_assemblage(void)
{
    return lst_mg_assemblage.size();
}

MG_ASSEMBLAGE* MG_ARBRE::get_premier_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
{
    it = lst_mg_assemblage.begin();
    if (it == lst_mg_assemblage.end())
        return NULL;
    return it->second;
}

MG_ASSEMBLAGE* MG_ARBRE::get_suivant_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
{
    it++;
    if (it == lst_mg_assemblage.end())
        return NULL;
    return it->second;
}

int MG_ARBRE::supprimer_mg_assemblage(unsigned int num)
{
    MG_ASSEMBLAGE* mgassembl=get_mg_assemblage(num);
    if (mgassembl==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgassembl;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
    lst_mg_assemblage.erase(j);
    delete mgassembl;
    return OK;
}

int MG_ARBRE::supprimer_mg_assemblageid(long unsigned int num)
{
    MG_ASSEMBLAGE* mgassembl=get_mg_assemblageid(num);
    if (mgassembl==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgassembl;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
    lst_mg_assemblage.erase(j);
    delete mgassembl;
    return OK;
}

void MG_ARBRE::supprimer_tout_mg_assemblage(void)
{
    while (get_nb_mg_assemblage()!=0)
    {
        LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.begin();
        MG_ASSEMBLAGE* mgassembl=(*j).second;
        MG_IDENTIFICATEUR* id=mgassembl;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_assemblage.erase(j);
        delete mgassembl;
    }
}

MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(char *nom_fichier,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_fichier);
  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_fichier);
    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_GEOMETRIE* MG_ARBRE::evaluer_geometrie(MG_ASSEMBLAGE* mgassembl, char* nom_fichier, bool avecfusion,bool export_step, bool import_stl, double precision, double eps)
{  
  char nom_fichier_brep[500];
  char nom_fichier_step[500];
  strcpy(nom_fichier_brep,nom_fichier);
  strcat(nom_fichier_brep,".brep");
  long nb_primitive = mgassembl->get_nb_mg_primitive();
  if(nb_primitive==1)
  {
    BRepTools::Write(mgassembl->get_mg_primitive(0)->get_forme(),nom_fichier_brep);
    if(export_step==true)
    {      
      strcpy(nom_fichier_step,nom_fichier);
      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, mgassembl->get_mg_primitive(nb_primitive-1)->get_forme());
      myWriter->Perform(Doc,nom_fichier_step);
    }
  }
  if(nb_primitive>1)
  {
    BRep_Builder constructeur_brep;
    TopoDS_Compound groupe_primitive;
    constructeur_brep.MakeCompound(groupe_primitive);
    for(long i=0;i<nb_primitive;i++)
    {
      constructeur_brep.Add(groupe_primitive,mgassembl->get_mg_primitive(i)->get_forme());
    }
    BRepTools::Write(groupe_primitive,nom_fichier_brep);
    if(export_step==true)
    {
      strcpy(nom_fichier_step,nom_fichier);
      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, groupe_primitive);
      myWriter->Perform(Doc,nom_fichier_step);
    }
  }
  OCC_IMPORT occimport;
  MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
  //MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_step,FICHIERSTEP,precision);
  if (avecfusion) occimport.fusionne(mggeo);
  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,double version)
{
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,version);
    }
 
}

void MG_ARBRE::get_fichier_dependant(std::vector<std::string> &liste_fichier)
{
    LISTE_ENTITE::const_iterator i;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->get_fichier_dependant(liste_fichier);
}
Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	14451 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// mg_arbre.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:53 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	686
23
24			#include "gestionversion.h"
25			#include <fstream>
26			#include <iostream>
27
28
29			#include "mg_arbre.h"
30			#include "mg_primitive.h"
31			#include "mg_operateur_boolean.h"
32	couturad	740	#include "mg_assemblage.h"
33	francois	686	#include "mg_gestionnaire.h"
34	francois	688	#include "occ_import.h"
35	francois	686
36
37	couturad	687	#include <Standard_TypeDef.hxx>
38			#include <Standard_Macro.hxx>
39			#include <TopoDS_Shape.hxx>
40			#include <BRepTools.hxx>
41	couturad	740	#include <BRep_Builder.hxx>
42	couturad	687	#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	francois	897	#include <TDocStd_Document.hxx>
48			#include <XCAFApp_Application.hxx>
49			#include <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			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			return FAIL;
93			}
94
95			std::pair<const unsigned long,MG_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
96			lst_mg_primitive.insert(tmp);
97			return OK;
98			}
99
100
101
102
103			MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
104			{
105			LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
106			if (i==lst_mg_primitive.end())
107			{
108			return NULL;
109			}
110			return ((*i).second);
111			}
112
113
114
115			MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
116			{
117			if (!(num<lst_mg_primitive.size()))
118			{
119			return NULL;
120			}
121			LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.begin();
122			for (unsigned long j=0;j<num;j++) i++;
123			return ((*i).second);
124			}
125
126
127
128			unsigned int MG_ARBRE::get_nb_mg_primitive(void)
129			{
130			return lst_mg_primitive.size();
131			}
132
133
134			int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
135			{
136			MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
137			if (mgprim==NULL)
138			{
139			return FAIL;
140			}
141			MG_IDENTIFICATEUR* id=mgprim;
142			LISTE_ENTITE::iterator i=lst_entite.find(id);
143			lst_entite.erase(i);
144			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
145			lst_mg_primitive.erase(j);
146			delete mgprim;
147			return OK;
148			}
149
150
151			int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
152			{
153			MG_PRIMITIVE* mgprim=get_mg_primitive(num);
154			if (mgprim==NULL)
155			{
156			return FAIL;
157			}
158			MG_IDENTIFICATEUR* id=mgprim;
159			LISTE_ENTITE::iterator i=lst_entite.find(id);
160			lst_entite.erase(i);
161			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
162			for (unsigned int k=0;k<num;k++) j++;
163			lst_mg_primitive.erase(j);
164			delete mgprim;
165			return OK;
166			}
167
168
169			void MG_ARBRE::supprimer_tout_mg_primitive(void)
170			{
171			while (get_nb_mg_primitive()!=0)
172			{
173			LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
174			MG_PRIMITIVE* mgprim=(*j).second;
175			MG_IDENTIFICATEUR* id=mgprim;
176			LISTE_ENTITE::iterator i=lst_entite.find(id);
177			lst_entite.erase(i);
178			lst_mg_primitive.erase(j);
179			delete mgprim;
180			}
181			}
182
183
184			MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
185			{
186			it = lst_mg_primitive.begin();
187			if (it == lst_mg_primitive.end())
188			return NULL;
189			return it->second;
190			}
191
192			MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
193			{
194			it++;
195			if (it == lst_mg_primitive.end())
196			return NULL;
197			return it->second;
198			}
199
200			int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
201			{
202			gest->recherche_bonid(*mgop);
203			MG_IDENTIFICATEUR *id=mgop;
204			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
205			if (!p.second)
206			{
207			return FAIL;
208			}
209
210			std::pair<const unsigned long,MG_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
211			lst_mg_operateur_boolean.insert(tmp);
212			return OK;
213			}
214
215
216
217
218			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
219			{
220			LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
221			if (i==lst_mg_operateur_boolean.end())
222			{
223			return NULL;
224			}
225			return ((*i).second);
226			}
227
228
229
230			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
231			{
232			if (!(num<lst_mg_operateur_boolean.size()))
233			{
234			return NULL;
235			}
236			LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.begin();
237			for (unsigned long j=0;j<num;j++) i++;
238			return ((*i).second);
239			}
240
241
242
243			unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
244			{
245			return lst_mg_operateur_boolean.size();
246			}
247
248
249			int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
250			{
251			MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
252			if (mgop==NULL)
253			{
254			return FAIL;
255			}
256			MG_IDENTIFICATEUR* id=mgop;
257			LISTE_ENTITE::iterator i=lst_entite.find(id);
258			lst_entite.erase(i);
259			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
260			lst_mg_operateur_boolean.erase(j);
261			delete mgop;
262			return OK;
263			}
264
265
266			int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
267			{
268			MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
269			if (mgop==NULL)
270			{
271			return FAIL;
272			}
273			MG_IDENTIFICATEUR* id=mgop;
274			LISTE_ENTITE::iterator i=lst_entite.find(id);
275			lst_entite.erase(i);
276			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
277			for (unsigned int k=0;k<num;k++) j++;
278			lst_mg_operateur_boolean.erase(j);
279			delete mgop;
280			return OK;
281			}
282
283
284			void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
285			{
286			while (get_nb_mg_operateur_boolean()!=0)
287			{
288			LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
289			MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
290			MG_IDENTIFICATEUR* id=mgop;
291			LISTE_ENTITE::iterator i=lst_entite.find(id);
292			lst_entite.erase(i);
293			lst_mg_operateur_boolean.erase(j);
294			delete mgop;
295			}
296			}
297
298
299			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
300			{
301			it = lst_mg_operateur_boolean.begin();
302			if (it == lst_mg_operateur_boolean.end())
303			return NULL;
304			return it->second;
305			}
306
307			MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
308			{
309			it++;
310			if (it == lst_mg_operateur_boolean.end())
311			return NULL;
312			return it->second;
313			}
314
315	couturad	740	int MG_ARBRE::ajouter_mg_assemblage(MG_ASSEMBLAGE* mgassembl)
316	francois	686	{
317	couturad	740	gest->recherche_bonid(*mgassembl);
318			MG_IDENTIFICATEUR *id=mgassembl;
319			std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
320			if (!p.second)
321			{
322			return FAIL;
323			}
324
325			std::pair<const unsigned long,MG_ASSEMBLAGE*> tmp(mgassembl->get_id(),mgassembl);
326			lst_mg_assemblage.insert(tmp);
327			return OK;
328			}
329
330			MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblage(unsigned int num)
331			{
332			LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
333			if (i==lst_mg_assemblage.end())
334			{
335			return NULL;
336			}
337			return ((*i).second);
338			}
339
340			MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblageid(long unsigned int num)
341			{
342			LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
343			if (i==lst_mg_assemblage.end())
344			{
345			return NULL;
346			}
347			return ((*i).second);
348			}
349
350			unsigned int MG_ARBRE::get_nb_mg_assemblage(void)
351			{
352			return lst_mg_assemblage.size();
353			}
354
355			MG_ASSEMBLAGE* MG_ARBRE::get_premier_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
356			{
357			it = lst_mg_assemblage.begin();
358			if (it == lst_mg_assemblage.end())
359			return NULL;
360			return it->second;
361			}
362
363			MG_ASSEMBLAGE* MG_ARBRE::get_suivant_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
364			{
365			it++;
366			if (it == lst_mg_assemblage.end())
367			return NULL;
368			return it->second;
369			}
370
371			int MG_ARBRE::supprimer_mg_assemblage(unsigned int num)
372			{
373			MG_ASSEMBLAGE* mgassembl=get_mg_assemblage(num);
374			if (mgassembl==NULL)
375			{
376			return FAIL;
377			}
378			MG_IDENTIFICATEUR* id=mgassembl;
379			LISTE_ENTITE::iterator i=lst_entite.find(id);
380			lst_entite.erase(i);
381			LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
382			lst_mg_assemblage.erase(j);
383			delete mgassembl;
384			return OK;
385			}
386
387			int MG_ARBRE::supprimer_mg_assemblageid(long unsigned int num)
388			{
389			MG_ASSEMBLAGE* mgassembl=get_mg_assemblageid(num);
390			if (mgassembl==NULL)
391			{
392			return FAIL;
393			}
394			MG_IDENTIFICATEUR* id=mgassembl;
395			LISTE_ENTITE::iterator i=lst_entite.find(id);
396			lst_entite.erase(i);
397			LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
398			lst_mg_assemblage.erase(j);
399			delete mgassembl;
400			return OK;
401			}
402
403			void MG_ARBRE::supprimer_tout_mg_assemblage(void)
404			{
405			while (get_nb_mg_assemblage()!=0)
406			{
407			LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.begin();
408			MG_ASSEMBLAGE* mgassembl=(*j).second;
409			MG_IDENTIFICATEUR* id=mgassembl;
410			LISTE_ENTITE::iterator i=lst_entite.find(id);
411			lst_entite.erase(i);
412			lst_mg_assemblage.erase(j);
413			delete mgassembl;
414			}
415			}
416
417			MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(char *nom_fichier,bool export_step,bool import_stl,double precision,double eps)
418			{
419	couturad	687	int nb_primitive = get_nb_mg_primitive();
420			char nom_fichier_brep[500];
421	couturad	740	strcpy(nom_fichier_brep,nom_fichier);
422	couturad	687	strcat(nom_fichier_brep,".brep");
423			BRepTools::Write(get_mg_primitive(nb_primitive-1)->get_forme(),nom_fichier_brep);
424			if(export_step==true)
425			{
426			char nom_fichier_step[500];
427	couturad	740	strcpy(nom_fichier_step,nom_fichier);
428	couturad	687	strcat(nom_fichier_step,".step");
429			Handle(TDocStd_Document) Doc;
430			Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
431			App->NewDocument("MDTV-XCAF",Doc);
432			Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
433			STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
434			TDF_Label Label_shape = myShapeTool->NewShape();
435			myShapeTool->SetShape(Label_shape, get_mg_primitive(nb_primitive-1)->get_forme());
436			myWriter->Perform(Doc,nom_fichier_step);
437			}
438			OCC_IMPORT occimport;
439	francois	731	MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
440			if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);
441	francois	690	return mggeo;
442	francois	686	}
443
444
445	francois	747	MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(MG_ASSEMBLAGE* mgassembl, char* nom_fichier, bool avecfusion,bool export_step, bool import_stl, double precision, double eps)
446	couturad	740	{
447			char nom_fichier_brep[500];
448			char nom_fichier_step[500];
449			strcpy(nom_fichier_brep,nom_fichier);
450			strcat(nom_fichier_brep,".brep");
451			long nb_primitive = mgassembl->get_nb_mg_primitive();
452			if(nb_primitive==1)
453			{
454			BRepTools::Write(mgassembl->get_mg_primitive(0)->get_forme(),nom_fichier_brep);
455			if(export_step==true)
456			{
457			strcpy(nom_fichier_step,nom_fichier);
458			strcat(nom_fichier_step,".step");
459			Handle(TDocStd_Document) Doc;
460			Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
461			App->NewDocument("MDTV-XCAF",Doc);
462			Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
463			STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
464			TDF_Label Label_shape = myShapeTool->NewShape();
465	francois	785	myShapeTool->SetShape(Label_shape, mgassembl->get_mg_primitive(nb_primitive-1)->get_forme());
466	couturad	740	myWriter->Perform(Doc,nom_fichier_step);
467			}
468			}
469			if(nb_primitive>1)
470			{
471			BRep_Builder constructeur_brep;
472			TopoDS_Compound groupe_primitive;
473			constructeur_brep.MakeCompound(groupe_primitive);
474			for(long i=0;i<nb_primitive;i++)
475			{
476			constructeur_brep.Add(groupe_primitive,mgassembl->get_mg_primitive(i)->get_forme());
477			}
478			BRepTools::Write(groupe_primitive,nom_fichier_brep);
479			if(export_step==true)
480			{
481			strcpy(nom_fichier_step,nom_fichier);
482			strcat(nom_fichier_step,".step");
483			Handle(TDocStd_Document) Doc;
484			Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
485			App->NewDocument("MDTV-XCAF",Doc);
486			Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
487			STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
488			TDF_Label Label_shape = myShapeTool->NewShape();
489			myShapeTool->SetShape(Label_shape, groupe_primitive);
490			myWriter->Perform(Doc,nom_fichier_step);
491			}
492			}
493			OCC_IMPORT occimport;
494			MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
495			//MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_step,FICHIERSTEP,precision);
496	francois	747	if (avecfusion) occimport.fusionne(mggeo);
497	couturad	740	if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);
498			return mggeo;
499			}
500
501
502
503
504	francois	686	MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
505			{
506			return gest;
507			}
508
509	francois	763	void MG_ARBRE::enregistrer(std::ostream& o,double version)
510	francois	686	{
511	francois	689	o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<");" << std::endl;
512	francois	686	LISTE_ENTITE::const_iterator i;
513			for (i=lst_entite.begin();i!=lst_entite.end();i++)
514			{
515			MG_IDENTIFICATEUR* entite = *i;
516	francois	763	entite->enregistrer(o,version);
517	francois	686	}
518
519			}
520	couturad	906
521	francois	910	void MG_ARBRE::get_fichier_dependant(std::vector<std::string> &liste_fichier)
522			{
523			LISTE_ENTITE::const_iterator i;
524			for (i=lst_entite.begin();i!=lst_entite.end();i++)
525			(*i)->get_fichier_dependant(liste_fichier);
526	francois	1158	}