ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/lib/geometrie/src/mg_arbre.cpp
Revision: 763
Committed: Wed Dec 2 19:55:53 2015 UTC (9 years, 5 months ago) by francois
File size: 14961 byte(s)
Log Message: 
Le fichier MAGiC est maintenant versionné. LA version actuelle est 2.0. L'ancienne version est 1.0.
Tout est transparent pour l'utilisateur. Les vieilles versions sont lisibles mais les nouveaux enregistrements sont dans la version la plus récente.
Changement des conditions aux limites : ajout d'un parametre pour dire si la condition numerique est une valeur ou une formule ou un lien vers une autre entité magic.
Les parametres pour saisir sont maintenant -ccf -ccfi -ccff -ccft -ccfit -ccfft

File Contents

# 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 couturad 740 #include "mg_assemblage.h"
34 francois 686 #include "mg_gestionnaire.h"
35 francois 688 #include "occ_import.h"
36 francois 686
37    
38 couturad 687 //include Open_Cascade
39     #include <Standard_TypeDef.hxx>
40     #include <Standard_Macro.hxx>
41     #include <TopoDS_Shape.hxx>
42     #include <BRepTools.hxx>
43 couturad 740 #include <BRep_Builder.hxx>
44 couturad 687 #include <TDocStd_Document.hxx>
45     #include <XCAFApp_Application.hxx>
46     #include <XCAFDoc_ShapeTool.hxx>
47     #include <XCAFDoc_DocumentTool.hxx>
48     #include <STEPCAFControl_Writer.hxx>
49     #include <Handle_TDocStd_Document.hxx>
50     #include <Handle_XCAFApp_Application.hxx>
51     #include <Handle_XCAFDoc_ShapeTool.hxx>
52 francois 686
53 couturad 687
54    
55 francois 686 MG_ARBRE::MG_ARBRE(std::string nm):MG_IDENTIFICATEUR(),nom(nm)
56     {
57     }
58    
59    
60    
61     MG_ARBRE::MG_ARBRE(long unsigned int num,std::string nm): MG_IDENTIFICATEUR(num),nom(nm)
62     {
63     }
64    
65    
66    
67     MG_ARBRE::MG_ARBRE(MG_ARBRE& mdd):MG_IDENTIFICATEUR(mdd),nom(mdd.nom)
68     {
69     }
70    
71    
72    
73    
74     MG_ARBRE::~MG_ARBRE()
75     {
76     supprimer_tout_mg_operateur_boolean();
77     supprimer_tout_mg_primitive();
78     }
79    
80    
81    
82     void MG_ARBRE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
83     {
84     gest=mggest;
85     }
86    
87     // ENTITE MG_PRIMITIVE
88     int MG_ARBRE::ajouter_mg_primitive(MG_PRIMITIVE* mgprim)
89     {
90     gest->recherche_bonid(*mgprim);
91     MG_IDENTIFICATEUR *id=mgprim;
92     std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
93     if (!p.second)
94     {
95     // afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
96     return FAIL;
97     }
98    
99     std::pair<const unsigned long,MG_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
100     lst_mg_primitive.insert(tmp);
101     return OK;
102     }
103    
104    
105    
106    
107     MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
108     {
109     LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
110     if (i==lst_mg_primitive.end())
111     {
112     // afficheur << INEXISTE << enderr;
113     return NULL;
114     }
115     return ((*i).second);
116     }
117    
118    
119    
120     MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
121     {
122     if (!(num<lst_mg_primitive.size()))
123     {
124     // afficheur << INEXISTE << enderr;
125     return NULL;
126     }
127     LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.begin();
128     for (unsigned long j=0;j<num;j++) i++;
129     return ((*i).second);
130     }
131    
132    
133    
134     unsigned int MG_ARBRE::get_nb_mg_primitive(void)
135     {
136     return lst_mg_primitive.size();
137     }
138    
139    
140     int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
141     {
142     MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
143     if (mgprim==NULL)
144     {
145     // afficheur << INEXISTE2 << enderr;
146     return FAIL;
147     }
148     MG_IDENTIFICATEUR* id=mgprim;
149     LISTE_ENTITE::iterator i=lst_entite.find(id);
150     lst_entite.erase(i);
151     LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
152     lst_mg_primitive.erase(j);
153     delete mgprim;
154     return OK;
155     }
156    
157    
158     int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
159     {
160     MG_PRIMITIVE* mgprim=get_mg_primitive(num);
161     if (mgprim==NULL)
162     {
163     // afficheur << INEXISTE2 << enderr;
164     return FAIL;
165     }
166     MG_IDENTIFICATEUR* id=mgprim;
167     LISTE_ENTITE::iterator i=lst_entite.find(id);
168     lst_entite.erase(i);
169     LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
170     for (unsigned int k=0;k<num;k++) j++;
171     lst_mg_primitive.erase(j);
172     delete mgprim;
173     return OK;
174     }
175    
176    
177     void MG_ARBRE::supprimer_tout_mg_primitive(void)
178     {
179     while (get_nb_mg_primitive()!=0)
180     {
181     LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
182     MG_PRIMITIVE* mgprim=(*j).second;
183     MG_IDENTIFICATEUR* id=mgprim;
184     LISTE_ENTITE::iterator i=lst_entite.find(id);
185     lst_entite.erase(i);
186     lst_mg_primitive.erase(j);
187     delete mgprim;
188     }
189     }
190    
191    
192     MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
193     {
194     it = lst_mg_primitive.begin();
195     if (it == lst_mg_primitive.end())
196     return NULL;
197     return it->second;
198     }
199    
200     MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
201     {
202     it++;
203     if (it == lst_mg_primitive.end())
204     return NULL;
205     return it->second;
206     }
207    
208     // ENTITE MG_OPERATEUR_BOOLEAN
209     int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
210     {
211     gest->recherche_bonid(*mgop);
212     MG_IDENTIFICATEUR *id=mgop;
213     std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
214     if (!p.second)
215     {
216     // afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
217     return FAIL;
218     }
219    
220     std::pair<const unsigned long,MG_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
221     lst_mg_operateur_boolean.insert(tmp);
222     return OK;
223     }
224    
225    
226    
227    
228     MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
229     {
230     LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
231     if (i==lst_mg_operateur_boolean.end())
232     {
233     // afficheur << INEXISTE << enderr;
234     return NULL;
235     }
236     return ((*i).second);
237     }
238    
239    
240    
241     MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
242     {
243     if (!(num<lst_mg_operateur_boolean.size()))
244     {
245     // afficheur << INEXISTE << enderr;
246     return NULL;
247     }
248     LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.begin();
249     for (unsigned long j=0;j<num;j++) i++;
250     return ((*i).second);
251     }
252    
253    
254    
255     unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
256     {
257     return lst_mg_operateur_boolean.size();
258     }
259    
260    
261     int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
262     {
263     MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
264     if (mgop==NULL)
265     {
266     // afficheur << INEXISTE2 << enderr;
267     return FAIL;
268     }
269     MG_IDENTIFICATEUR* id=mgop;
270     LISTE_ENTITE::iterator i=lst_entite.find(id);
271     lst_entite.erase(i);
272     LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
273     lst_mg_operateur_boolean.erase(j);
274     delete mgop;
275     return OK;
276     }
277    
278    
279     int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
280     {
281     MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
282     if (mgop==NULL)
283     {
284     // afficheur << INEXISTE2 << enderr;
285     return FAIL;
286     }
287     MG_IDENTIFICATEUR* id=mgop;
288     LISTE_ENTITE::iterator i=lst_entite.find(id);
289     lst_entite.erase(i);
290     LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
291     for (unsigned int k=0;k<num;k++) j++;
292     lst_mg_operateur_boolean.erase(j);
293     delete mgop;
294     return OK;
295     }
296    
297    
298     void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
299     {
300     while (get_nb_mg_operateur_boolean()!=0)
301     {
302     LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
303     MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
304     MG_IDENTIFICATEUR* id=mgop;
305     LISTE_ENTITE::iterator i=lst_entite.find(id);
306     lst_entite.erase(i);
307     lst_mg_operateur_boolean.erase(j);
308     delete mgop;
309     }
310     }
311    
312    
313     MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
314     {
315     it = lst_mg_operateur_boolean.begin();
316     if (it == lst_mg_operateur_boolean.end())
317     return NULL;
318     return it->second;
319     }
320    
321     MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
322     {
323     it++;
324     if (it == lst_mg_operateur_boolean.end())
325     return NULL;
326     return it->second;
327     }
328    
329 couturad 740 int MG_ARBRE::ajouter_mg_assemblage(MG_ASSEMBLAGE* mgassembl)
330 francois 686 {
331 couturad 740 gest->recherche_bonid(*mgassembl);
332     MG_IDENTIFICATEUR *id=mgassembl;
333     std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
334     if (!p.second)
335     {
336     // afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
337     return FAIL;
338     }
339    
340     std::pair<const unsigned long,MG_ASSEMBLAGE*> tmp(mgassembl->get_id(),mgassembl);
341     lst_mg_assemblage.insert(tmp);
342     return OK;
343     }
344    
345     MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblage(unsigned int num)
346     {
347     LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
348     if (i==lst_mg_assemblage.end())
349     {
350     // afficheur << INEXISTE << enderr;
351     return NULL;
352     }
353     return ((*i).second);
354     }
355    
356     MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblageid(long unsigned int num)
357     {
358     LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
359     if (i==lst_mg_assemblage.end())
360     {
361     // afficheur << INEXISTE << enderr;
362     return NULL;
363     }
364     return ((*i).second);
365     }
366    
367     unsigned int MG_ARBRE::get_nb_mg_assemblage(void)
368     {
369     return lst_mg_assemblage.size();
370     }
371    
372     MG_ASSEMBLAGE* MG_ARBRE::get_premier_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
373     {
374     it = lst_mg_assemblage.begin();
375     if (it == lst_mg_assemblage.end())
376     return NULL;
377     return it->second;
378     }
379    
380     MG_ASSEMBLAGE* MG_ARBRE::get_suivant_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
381     {
382     it++;
383     if (it == lst_mg_assemblage.end())
384     return NULL;
385     return it->second;
386     }
387    
388     int MG_ARBRE::supprimer_mg_assemblage(unsigned int num)
389     {
390     MG_ASSEMBLAGE* mgassembl=get_mg_assemblage(num);
391     if (mgassembl==NULL)
392     {
393     // afficheur << INEXISTE2 << enderr;
394     return FAIL;
395     }
396     MG_IDENTIFICATEUR* id=mgassembl;
397     LISTE_ENTITE::iterator i=lst_entite.find(id);
398     lst_entite.erase(i);
399     LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
400     lst_mg_assemblage.erase(j);
401     delete mgassembl;
402     return OK;
403     }
404    
405     int MG_ARBRE::supprimer_mg_assemblageid(long unsigned int num)
406     {
407     MG_ASSEMBLAGE* mgassembl=get_mg_assemblageid(num);
408     if (mgassembl==NULL)
409     {
410     // afficheur << INEXISTE2 << enderr;
411     return FAIL;
412     }
413     MG_IDENTIFICATEUR* id=mgassembl;
414     LISTE_ENTITE::iterator i=lst_entite.find(id);
415     lst_entite.erase(i);
416     LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
417     lst_mg_assemblage.erase(j);
418     delete mgassembl;
419     return OK;
420     }
421    
422     void MG_ARBRE::supprimer_tout_mg_assemblage(void)
423     {
424     while (get_nb_mg_assemblage()!=0)
425     {
426     LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.begin();
427     MG_ASSEMBLAGE* mgassembl=(*j).second;
428     MG_IDENTIFICATEUR* id=mgassembl;
429     LISTE_ENTITE::iterator i=lst_entite.find(id);
430     lst_entite.erase(i);
431     lst_mg_assemblage.erase(j);
432     delete mgassembl;
433     }
434     }
435    
436     MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(char *nom_fichier,bool export_step,bool import_stl,double precision,double eps)
437     {
438 couturad 687 int nb_primitive = get_nb_mg_primitive();
439     char nom_fichier_brep[500];
440 couturad 740 strcpy(nom_fichier_brep,nom_fichier);
441 couturad 687 strcat(nom_fichier_brep,".brep");
442     BRepTools::Write(get_mg_primitive(nb_primitive-1)->get_forme(),nom_fichier_brep);
443     if(export_step==true)
444     {
445     char nom_fichier_step[500];
446 couturad 740 strcpy(nom_fichier_step,nom_fichier);
447 couturad 687 strcat(nom_fichier_step,".step");
448     Handle(TDocStd_Document) Doc;
449     Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
450     App->NewDocument("MDTV-XCAF",Doc);
451     Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
452     STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
453     TDF_Label Label_shape = myShapeTool->NewShape();
454     myShapeTool->SetShape(Label_shape, get_mg_primitive(nb_primitive-1)->get_forme());
455     myWriter->Perform(Doc,nom_fichier_step);
456     }
457     OCC_IMPORT occimport;
458 francois 731 MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
459     if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);
460 francois 690 return mggeo;
461 francois 686 }
462    
463    
464 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)
465 couturad 740 {
466     char nom_fichier_brep[500];
467     char nom_fichier_step[500];
468     strcpy(nom_fichier_brep,nom_fichier);
469     strcat(nom_fichier_brep,".brep");
470     long nb_primitive = mgassembl->get_nb_mg_primitive();
471     if(nb_primitive==1)
472     {
473     BRepTools::Write(mgassembl->get_mg_primitive(0)->get_forme(),nom_fichier_brep);
474     if(export_step==true)
475     {
476     strcpy(nom_fichier_step,nom_fichier);
477     strcat(nom_fichier_step,".step");
478     Handle(TDocStd_Document) Doc;
479     Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
480     App->NewDocument("MDTV-XCAF",Doc);
481     Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
482     STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
483     TDF_Label Label_shape = myShapeTool->NewShape();
484     myShapeTool->SetShape(Label_shape, get_mg_primitive(nb_primitive-1)->get_forme());
485     myWriter->Perform(Doc,nom_fichier_step);
486     }
487     }
488     if(nb_primitive>1)
489     {
490     BRep_Builder constructeur_brep;
491     TopoDS_Compound groupe_primitive;
492     constructeur_brep.MakeCompound(groupe_primitive);
493     for(long i=0;i<nb_primitive;i++)
494     {
495     constructeur_brep.Add(groupe_primitive,mgassembl->get_mg_primitive(i)->get_forme());
496     }
497     BRepTools::Write(groupe_primitive,nom_fichier_brep);
498     if(export_step==true)
499     {
500     strcpy(nom_fichier_step,nom_fichier);
501     strcat(nom_fichier_step,".step");
502     Handle(TDocStd_Document) Doc;
503     Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
504     App->NewDocument("MDTV-XCAF",Doc);
505     Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
506     STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
507     TDF_Label Label_shape = myShapeTool->NewShape();
508     myShapeTool->SetShape(Label_shape, groupe_primitive);
509     myWriter->Perform(Doc,nom_fichier_step);
510     }
511     }
512     OCC_IMPORT occimport;
513     MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
514     //MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_step,FICHIERSTEP,precision);
515 francois 747 if (avecfusion) occimport.fusionne(mggeo);
516 couturad 740 if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);
517     return mggeo;
518     }
519    
520    
521    
522    
523 francois 686 MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
524     {
525     return gest;
526     }
527    
528 francois 763 void MG_ARBRE::enregistrer(std::ostream& o,double version)
529 francois 686 {
530 francois 689 o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<");" << std::endl;
531 francois 686 LISTE_ENTITE::const_iterator i;
532     for (i=lst_entite.begin();i!=lst_entite.end();i++)
533     {
534     MG_IDENTIFICATEUR* entite = *i;
535 francois 763 entite->enregistrer(o,version);
536 francois 686 }
537    
538     }