ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/lib/fichier/src/mg_file.cpp
Revision: 926
Committed: Tue May 1 20:38:42 2018 UTC (7 years ago) by couturad
File size: 149378 byte(s)
Log Message: 
Ajout de nouvelles fonctionnalités de representation et d'analyse des VES
*Modification du CMakeLists.txt de microstructure

File Contents

# User Rev Content
1 francois 283 //------------------------------------------------------------
2     //------------------------------------------------------------
3     // MAGiC
4     // Jean Christophe Cuilli�e et Vincent FRANCOIS
5     // D�artement de G�ie M�anique - UQTR
6     //------------------------------------------------------------
7     // Le projet MAGIC est un projet de recherche du d�artement
8     // de g�ie m�anique de l'Universit�du Qu�ec �
9     // Trois Rivi�es
10     // Les librairies ne peuvent �re utilis�s sans l'accord
11     // des auteurs (contact : francois@uqtr.ca)
12     //------------------------------------------------------------
13     //------------------------------------------------------------
14     //
15     // mg_file.cpp
16     //
17     //------------------------------------------------------------
18     //------------------------------------------------------------
19     // COPYRIGHT 2000
20     // Version du 02/03/2006 �11H22
21     //------------------------------------------------------------
22     //------------------------------------------------------------
23    
24    
25     #include "gestionversion.h"
26    
27     #pragma hdrstop
28    
29     #include <string.h>
30     #include "mg_file.h"
31 francois 526 #include "mg_sommet_noeud.h"
32 francois 576 #include "mg_arete_element.h"
33     #include "mg_face_element.h"
34     #include "mg_volume_element.h"
35 francois 685 #include "mg_coque_element.h"
36 francois 753 #include "mg_poutre_element.h"
37 francois 283 #include "pars_argument.h"
38     #include "parse.h"
39 francois 763 #include "ot_chaine.h"
40 francois 283 #ifdef BREP_STEP
41     #include "step_surface.h"
42     #include "step_courbe.h"
43     #include "step_point.h"
44     #endif
45     #ifdef BREP_SAT
46     #include "acis_surface.h"
47     #include "acis_courbe.h"
48     #include "acis_point.h"
49     #endif
50     #include "lc_point.h"
51 francois 310 #include "fem_segment2.h"
52 francois 767 #include "fem_mini_segment2.h"
53 francois 310 #include "fem_segment3.h"
54     #include "fem_triangle3.h"
55     #include "fem_triangle6.h"
56     #include "fem_quadrangle4.h"
57     #include "fem_quadrangle8.h"
58     #include "fem_tetra4.h"
59 francois 380 #include "xfem_segment2.h"
60 francois 410 #include "xfem_triangle3.h"
61 francois 339 #include "xfem_tetra4.h"
62 francois 310 #include "fem_tetra10.h"
63     #include "fem_hexa8.h"
64     #include "fem_hexa20.h"
65 francois 876 #include "fem_penta6.h"
66     #include "fem_penta15.h"
67 francois 283 //OCC
68     #ifdef BREP_OCC
69     #include "occ_surface.h"
70     #include "occ_point.h"
71     #include "occ_courbe.h"
72 couturad 740 #include "occ_fonction.h"
73 francois 283 #include "TopoDS_Shape.hxx"
74     #include "TopoDS.hxx"
75 couturad 906 #include "occ_sommet.h"
76 francois 283 #endif
77 francois 689 #ifdef CSG_OCC
78 couturad 740 #include "mg_assemblage.h"
79 francois 689 #include "mg_primitive_boite.h"
80 couturad 723 #include "mg_primitive_sphere.h"
81 couturad 823 #include "mg_primitive_ellipsoide_revolution.h"
82 couturad 723 #include "mg_primitive_cylindre.h"
83 couturad 724 #include "mg_primitive_cone.h"
84     #include "mg_primitive_tore.h"
85 francois 689 #include "mg_primitive_complexe.h"
86     #include "mg_operateur_boolean_union.h"
87 couturad 723 #include "mg_operateur_boolean_difference.h"
88     #include "mg_operateur_boolean_intersection.h"
89 couturad 906
90 francois 689 #endif
91 couturad 906 #include "occ_fonction_v2017.h"
92     #include "mg_cg_forme.h"
93     #include "mg_cg_forme_arete_droite.h"
94     #include "mg_cg_forme_volume_boite.h"
95     #include "mg_cg_forme_volume_sphere.h"
96     #include "mg_cg_forme_volume_ellipsoide.h"
97     #include "mg_cg_forme_volume_cylindre.h"
98     #include "mg_cg_forme_volume_cone.h"
99     #include "mg_cg_forme_volume_tore.h"
100     #include "mg_cg_forme_multiple.h"
101     #include "mg_cg_forme_multi_volume.h"
102     #include "mg_cg_op_bool_union.h"
103     #include "mg_cg_op_bool_difference.h"
104     #include "mg_cg_op_bool_intersection.h"
105     #include "mg_cg_op_bool_fragment.h"
106     #include "mg_cg_op_inclusion_matrice.h"
107     #include "mg_cg_op_transf_rotation.h"
108     #include "mg_cg_op_transf_translation.h"
109     #include "mg_cg_op_transf_echelle.h"
110     #include "mg_cg_modele.h"
111     #include "mg_cg_assemblage.h"
112     #include "mg_cg_op_bool_union.h"
113     #include "mg_cg.h"
114     #include "mg_sous_geometrie.h"
115 couturad 926 #include "mg_cg_info.h"
116     #include "mg_cg_groupe_forme.h"
117 couturad 906
118 francois 283 //---------------------------------------------------------------------------
119     // CAD4FE Headers
120     #ifdef WINDOWS_VERSION
121     #include "CAD4FE_MCEdge.h"
122     #include "CAD4FE_MCFace.h"
123     #include "CAD4FE_MCVertex.h"
124     #include "CAD4FE_PolySurface.h"
125     #include "CAD4FE_PolyCurve.h"
126     #include "CAD4FE_MCNode.h"
127     #include "CAD4FE_MCSegment.h"
128     #include "CAD4FE_MCTriangle.h"
129     #include "CAD4FE_m3d_MCTriangle.h"
130     #endif
131     //---------------------------------------------------------------------------
132    
133    
134     //---------------------------------------------------------------------------
135     #pragma package(smart_init)
136    
137    
138     MG_FILE::MG_FILE(char* chemin):MG_GESTIONNAIRE()
139     {
140 couturad 919 // std::string str_chemin=chemin;
141     // std::size_t found = str_chemin.rfind((char*)"/");
142     // if (found!=std::string::npos)
143     // {
144     // str_dossier=str_chemin.substr(0,found+1);
145     // }
146     // else str_dossier ="";
147     str_dossier ="";
148     code_de_lecture=lire(chemin);
149 francois 283 }
150    
151 francois 551 MG_FILE::MG_FILE():MG_GESTIONNAIRE()
152     {
153     }
154    
155 francois 283 MG_FILE::~MG_FILE()
156     {
157     }
158    
159     int MG_FILE::get_code_de_lecture(void)
160     {
161     return code_de_lecture;
162     }
163    
164     long MG_FILE::cid(std::string str)
165     {
166     const char *p=str.c_str();
167     if (*p=='$') return atol(p+1);
168     return -1;
169     }
170    
171 francois 551
172 francois 763 void MG_FILE::lire_ccf(double version,int nb,int numparam,class PARSE& parse,class PARS_ARGUMENT (&param)[100],MG_ELEMENT_TOPOLOGIQUE *ele)
173     {
174     if (version<2.0)
175     {
176     for (int i=0;i<nb;i++)
177     {
178     parse.decode(param[numparam].argument[i].c_str(),"(@,@)",param+numparam+1);
179     char nom[3];
180     strcpy(nom,param[numparam+1].argument[0].c_str());
181     if (strcmp(nom,"CM")==0)
182     {
183     unsigned long val;
184     val=atol(param[numparam+2].argument[0].c_str());
185     ele->ajouter_ccf(nom,val);
186     }
187     else
188     {
189     double val;
190     val=atof(param[numparam+2].argument[0].c_str());
191     ele->ajouter_ccf(nom,val);
192     }
193     }
194     }
195 francois 788 else if (version<2.1)
196 francois 763 {
197     for (int i=0;i<nb;i++)
198     {
199     char test[500];
200     strcpy(test,param[numparam].argument[i].c_str());
201     parse.decode(param[numparam].argument[i].c_str(),"(@,@,@)",param+numparam+1);
202     char formulation[10];
203     strcpy(formulation,param[numparam+1].argument[0].c_str());
204     char nom[3];
205     strcpy(nom,param[numparam+2].argument[0].c_str());
206     if (formulation[0]=='N')
207     {
208     double val;
209     val=atof(param[numparam+3].argument[0].c_str());
210     ele->ajouter_ccf(nom,val);
211     }
212     if (formulation[0]=='I')
213     {
214     unsigned long val;
215     val=atol(param[numparam+3].argument[0].c_str());
216     ele->ajouter_ccf(nom,val);
217     }
218     if (formulation[0]=='F')
219     {
220     parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@,(@))",param+numparam+1);
221     char formule[500];
222     strcpy(formule,param[numparam+3].argument[0].c_str());
223     char variable[500];
224     strcpy(variable,param[numparam+5].argument[0].c_str());
225     OT_CHAINE ot;
226     std::vector<std::string> listvariable=ot.split(variable,',');
227     ele->ajouter_ccf(nom,formule,listvariable);
228     }
229     }
230     }
231 francois 788 else
232     {
233     for (int i=0;i<nb;i++)
234     {
235     char test[500];
236     strcpy(test,param[numparam].argument[i].c_str());
237     parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@)",param+numparam+1);
238     char formulation[10];
239     strcpy(formulation,param[numparam+1].argument[0].c_str());
240     char nom[3];
241     strcpy(nom,param[numparam+2].argument[0].c_str());
242     char suiv[10];
243     strcpy(suiv,param[numparam+3].argument[0].c_str());
244     if (formulation[0]=='N')
245     {
246     double val;
247     val=atof(param[numparam+4].argument[0].c_str());
248     ele->ajouter_ccf(nom,val,suiv);
249     }
250     if (formulation[0]=='I')
251     {
252     unsigned long val;
253     val=atol(param[numparam+4].argument[0].c_str());
254     ele->ajouter_ccf(nom,val,suiv);
255     }
256     if (formulation[0]=='F')
257     {
258 couturad 919 parse.decode(param[numparam].argument[i].c_str(),"(@,@,@,@,@,(@))",param+numparam+1);
259 francois 788 char formule[500];
260     strcpy(formule,param[numparam+4].argument[0].c_str());
261     char variable[500];
262     strcpy(variable,param[numparam+6].argument[0].c_str());
263     OT_CHAINE ot;
264     std::vector<std::string> listvariable=ot.split(variable,',');
265     ele->ajouter_ccf(nom,formule,listvariable,suiv);
266     }
267     }
268 francois 763 }
269 francois 788 }
270 francois 551
271     void MG_FILE::lire_NOEUD(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
272     {
273     parse.decode(data.c_str(),"@,@,@,@,@",param+2);
274     long idtopo=cid(param[2].argument[0]);
275     double x=atof(param[3].argument[0].c_str());
276     double y=atof(param[4].argument[0].c_str());
277     double z=atof(param[5].argument[0].c_str());
278     int ori=atoi(param[6].argument[0].c_str());
279     MG_ELEMENT_TOPOLOGIQUE* topo;
280     if (idtopo>-1)
281     {
282     topo=mggeo->get_mg_sommetid(idtopo);
283     if (topo==NULL) topo=mggeo->get_mg_areteid(idtopo);
284     if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
285     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
286     }
287     else topo=NULL;
288     MG_NOEUD* noeud=new MG_NOEUD(id,topo,x,y,z,ori);
289     mgmai->ajouter_mg_noeud(noeud);
290     }
291    
292     void MG_FILE::lire_SEGMENT(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
293     {
294     parse.decode(data.c_str(),"@,@,@,@",param+2);
295     long idtopo=cid(param[2].argument[0]);
296     long idn1=cid(param[3].argument[0]);
297     long idn2=cid(param[4].argument[0]);
298     int ori=atoi(param[5].argument[0].c_str());
299     MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
300     MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
301     MG_ELEMENT_TOPOLOGIQUE* topo;
302     if (idtopo>-1)
303     {
304     topo=mggeo->get_mg_areteid(idtopo);
305     if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
306     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
307 francois 767 if (topo==NULL) topo=mggeo->get_mg_poutreid(idtopo);
308 francois 551 }
309     else topo=NULL;
310     MG_SEGMENT* seg=new MG_SEGMENT(id,topo,noeud1,noeud2,ori);
311     mgmai->ajouter_mg_segment(seg);
312     }
313    
314    
315     void MG_FILE::lire_TRIANGLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
316     {
317     parse.decode(data.c_str(),"@,@,@,@,@",param+2);
318     long idtopo=cid(param[2].argument[0]);
319     long idn1=cid(param[3].argument[0]);
320     long idn2=cid(param[4].argument[0]);
321     long idn3=cid(param[5].argument[0]);
322     int ori=atoi(param[6].argument[0].c_str());
323     MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
324     MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
325     MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
326     MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
327     if (idtopo>-1)
328     {
329     topo=mggeo->get_mg_faceid(idtopo);
330     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
331     }
332     mgmai->ajouter_mg_triangle(topo,noeud1,noeud2,noeud3,ori,id);
333     }
334    
335     void MG_FILE::lire_QUADRANGLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
336     {
337     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
338     long idtopo=cid(param[2].argument[0]);
339     long idn1=cid(param[3].argument[0]);
340     long idn2=cid(param[4].argument[0]);
341     long idn3=cid(param[5].argument[0]);
342     long idn4=cid(param[6].argument[0]);
343     int ori=atoi(param[7].argument[0].c_str());
344     MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
345     MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
346     MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
347     MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
348     MG_ELEMENT_TOPOLOGIQUE* topo;
349     if (idtopo>-1)
350     {
351     topo=mggeo->get_mg_faceid(idtopo);
352     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
353     }
354     else topo=NULL;
355     mgmai->ajouter_mg_quadrangle(topo,noeud1,noeud2,noeud3,noeud4,ori,id);
356     }
357    
358    
359     void MG_FILE::lire_TETRA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
360     {
361     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
362     long idtopo=cid(param[2].argument[0]);
363     long idn1=cid(param[3].argument[0]);
364     long idn2=cid(param[4].argument[0]);
365     long idn3=cid(param[5].argument[0]);
366     long idn4=cid(param[6].argument[0]);
367     int ori=atoi(param[7].argument[0].c_str());
368     MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
369     MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
370     MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
371     MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
372     MG_ELEMENT_TOPOLOGIQUE* topo;
373     if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
374     else topo=NULL;
375     if (noeud1&&noeud2&&noeud3&&noeud4) mgmai->ajouter_mg_tetra(topo,noeud1,noeud2,noeud3,noeud4,ori,id);
376     }
377    
378     void MG_FILE::lire_HEXA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
379     {
380     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
381     long idtopo=cid(param[2].argument[0]);
382     long idn1=cid(param[3].argument[0]);
383     long idn2=cid(param[4].argument[0]);
384     long idn3=cid(param[5].argument[0]);
385     long idn4=cid(param[6].argument[0]);
386     long idn5=cid(param[7].argument[0]);
387     long idn6=cid(param[8].argument[0]);
388     long idn7=cid(param[9].argument[0]);
389     long idn8=cid(param[10].argument[0]);
390     int ori=atoi(param[11].argument[0].c_str());
391     MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
392     MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
393     MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
394     MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
395     MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
396     MG_NOEUD* noeud6=mgmai->get_mg_noeudid(idn6);
397     MG_NOEUD* noeud7=mgmai->get_mg_noeudid(idn7);
398     MG_NOEUD* noeud8=mgmai->get_mg_noeudid(idn8);
399     MG_ELEMENT_TOPOLOGIQUE* topo;
400     if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
401     else topo=NULL;
402     mgmai->ajouter_mg_hexa(topo,noeud1,noeud2,noeud3,noeud4,noeud5,noeud6,noeud7,noeud8,ori,id);
403     }
404    
405    
406 francois 876 void MG_FILE::lire_PENTA(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_MAILLAGE *mgmai,MG_GEOMETRIE *mggeo)
407     {
408     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
409     long idtopo=cid(param[2].argument[0]);
410     long idn1=cid(param[3].argument[0]);
411     long idn2=cid(param[4].argument[0]);
412     long idn3=cid(param[5].argument[0]);
413     long idn4=cid(param[6].argument[0]);
414     long idn5=cid(param[7].argument[0]);
415     long idn6=cid(param[8].argument[0]);
416     int ori=atoi(param[9].argument[0].c_str());
417     MG_NOEUD* noeud1=mgmai->get_mg_noeudid(idn1);
418     MG_NOEUD* noeud2=mgmai->get_mg_noeudid(idn2);
419     MG_NOEUD* noeud3=mgmai->get_mg_noeudid(idn3);
420     MG_NOEUD* noeud4=mgmai->get_mg_noeudid(idn4);
421     MG_NOEUD* noeud5=mgmai->get_mg_noeudid(idn5);
422     MG_NOEUD* noeud6=mgmai->get_mg_noeudid(idn6);
423     MG_ELEMENT_TOPOLOGIQUE* topo;
424     if (idtopo>-1) topo=mggeo->get_mg_volumeid(idtopo);
425     else topo=NULL;
426     mgmai->ajouter_mg_penta(topo,noeud1,noeud2,noeud3,noeud4,noeud5,noeud6,ori,id);
427     }
428 francois 551
429    
430 couturad 906 void MG_FILE::lire_MG_SOUS_GEOMETRIE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
431     {
432     // PARAM # 2 3 4 5 6 7
433     parse.decode(data.c_str(),"@,@,@,@,@,@,",param+2);
434     long id_mg_geometrie = cid(param[2].argument[0]);
435     long id_parent = cid(param[3].argument[0]);
436     std::string type_geo = param[4].argument[0];
437     std::string nom_fichier = param[5].argument[0];
438     double precision = atof(param[6].argument[0].c_str());
439     double valeur_unitee = atof(param[7].argument[0].c_str());
440 couturad 919 MG_GEOMETRIE* mg_construction = get_mg_constructionid(id_mg_geometrie);
441 couturad 906 MG_SOUS_GEOMETRIE* mg_sous_geometrie;
442     if(type_geo=="MGCG_ASS")
443     {
444     MG_CG_ASSEMBLAGE* mgcg_assemblage;
445     LISTE_MGCG_MODELE::iterator it_modele;
446     bool trouve=false;
447     it_modele=lst_mgcg_modele.begin();
448     while(trouve==false && it_modele!=lst_mgcg_modele.end())
449     {
450     MG_CG_MODELE* mgcg_modele = it_modele->second;
451     if(mgcg_modele->get_mgcg_assemblageid(id_parent)!=NULL)
452     {
453     mgcg_assemblage = mgcg_modele->get_mgcg_assemblageid(id_parent);
454     trouve=true;
455     }
456     }
457 couturad 919 mg_sous_geometrie=new MG_SOUS_GEOMETRIE(mg_construction,id_parent,(char*)type_geo.c_str(),id,(char*)nom_fichier.c_str(),valeur_unitee,precision);
458 couturad 906 mgcg_assemblage->change_mg_sous_geometrie(mg_sous_geometrie);
459     mgcg_assemblage->actualiser_mg_sous_geometrie();
460     ajouter_mg_geometrie(mg_sous_geometrie);
461     }
462     }
463 francois 551
464    
465    
466 couturad 906 void MG_FILE::lire_MG_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo,std::vector<unsigned long> &volumemince)
467     {
468     if (version_fichier<2)
469     {
470     parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
471     MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
472     mggeo->ajouter_mg_volume(mgvol);
473     int nummat=atoi((char*)param[4].argument[0].c_str());
474     mgvol->change_num_materiau(nummat);
475     int nb=atoi(param[5].argument[0].c_str());
476     if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
477     }
478     else if (version_fichier<2.3)
479     {
480     parse.decode(data.c_str(),"@,@,@,(&)",param+2);
481     MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
482     mggeo->ajouter_mg_volume(mgvol);
483     int nb=atoi(param[4].argument[0].c_str());
484     if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgvol);
485     }
486     else
487     {
488     parse.decode(data.c_str(),"@,@,@,@",param+2);
489     MG_VOLUME* mgvol;
490 couturad 908 #ifdef ALL_OCC
491 couturad 906 if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
492     {
493     TopoDS_Solid topods_solid;
494     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
495     topods_solid=occ_fonction_v2017->get_TopoDS_Solid_id(atol(param[2].argument[0].c_str()));
496     mgvol = new OCC_VOLUME(param[2].argument[0],id,topods_solid,&mggeo->get_occ_fonction());
497     occ_fonction_v2017->ajouter_OCC_VOLUME((OCC_VOLUME*)mgvol);
498     }
499     else mgvol=new MG_VOLUME(param[2].argument[0],id);
500     #else
501     mgvol=new MG_VOLUME(param[2].argument[0],id);
502     #endif
503     mggeo->ajouter_mg_volume(mgvol);
504     int mince=atoi(param[4].argument[0].c_str());
505     if (mince==0)
506     {
507     std::string data2=param[5].argument[0];
508     parse.decode(data2.c_str(),"@,(&)",param+5);
509     int nb=atoi(param[5].argument[0].c_str());
510     if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
511     }
512     else
513     {
514     std::string data2=param[5].argument[0];
515     parse.decode(data2.c_str(),"(&),@,(&)",param+5);
516     int nb_face=param[5].argument.size();
517     for (int i=0;i<nb_face;i=i+2)
518     {
519     unsigned long idn1=cid(param[5].argument[i]);
520     unsigned long idn2=cid(param[5].argument[i+1]);
521     volumemince.push_back(id);
522     volumemince.push_back(idn1);
523     volumemince.push_back(idn2);
524     }
525     int nb=atoi(param[6].argument[0].c_str());
526     if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,mgvol);
527     }
528     }
529     }
530    
531     void MG_FILE::lire_MG_COQUILLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
532     {
533     bool import_occ_2017=false;
534 couturad 908 #ifdef ALL_OCC
535 couturad 906 if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
536     {
537     import_occ_2017=true;
538     parse.decode(data.c_str(),"@,@,@",param+2);
539     long ident=cid(param[2].argument[0]);
540     long idori = stol(param[3].argument[0]);
541     TopoDS_Shell topods_shell;
542     OCC_COQUILLE* occ_coquille;
543     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
544     topods_shell=occ_fonction_v2017->get_TopoDS_Shell_id(idori);
545     if(idori!=-1)
546     {
547     MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
548     MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
549     if (mgvol!=NULL)
550     {
551     OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgvol,topods_shell,&mggeo->get_occ_fonction());
552     mggeo->ajouter_mg_coquille(occ_coquille,mgvol);
553     occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
554     }
555     if (mgcoq!=NULL)
556     {
557     OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgcoq,topods_shell,&mggeo->get_occ_fonction());
558     mggeo->ajouter_mg_coquille(occ_coquille,mgcoq);
559     occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
560     }
561     }
562     else
563     {
564     OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,topods_shell,&mggeo->get_occ_fonction());
565     mggeo->ajouter_mg_coquille(occ_coquille);
566     occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
567     }
568     }
569     #endif
570     if(!import_occ_2017)
571     {
572     parse.decode(data.c_str(),"@,@",param+2);
573     long ident=cid(param[2].argument[0]);
574     MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
575     MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
576     if(mgvol!=NULL)
577     {
578     MG_COQUILLE* mgcoq=new MG_COQUILLE(id,mgvol);
579     mggeo->ajouter_mg_coquille(mgcoq,mgvol);
580     }
581     if(mgcoq!=NULL)
582     {
583     MG_COQUILLE* mgcoquille=new MG_COQUILLE(id,mgcoq);
584     mggeo->ajouter_mg_coquille(mgcoquille,mgcoq);
585     }
586     }
587     }
588    
589     void MG_FILE::lire_MG_FACE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
590     {
591     if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,(@),@,@,(&)",param+2);
592     else parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
593     long idsurf=cid(param[3].argument[0]);
594     int sens=atoi(param[5].argument[0].c_str());
595     MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
596     MG_FACE* mgface;
597 couturad 908 #ifdef ALL_OCC
598 couturad 906 if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
599     {
600     TopoDS_Face topods_face;
601     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
602     topods_face=occ_fonction_v2017->get_TopoDS_Face_id(atol(param[2].argument[0].c_str()));
603     mgface = new OCC_FACE(param[2].argument[0],id,mgsurf,sens,topods_face,&mggeo->get_occ_fonction());
604     occ_fonction_v2017->ajouter_OCC_FACE((OCC_FACE*)mgface);
605     }
606     else mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
607     #else
608     mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
609     #endif
610     mggeo->ajouter_mg_face(mgface);
611     int argccf=7;
612     if (version_fichier>2.1)
613     {
614     argccf=8;
615     int nbpole=atoi(param[6].argument[0].c_str());
616     mgface->change_nb_pole(nbpole);
617     }
618     int nb=atoi(param[argccf-1].argument[0].c_str());
619     if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgface);
620     }
621    
622     void MG_FILE::lire_MG_BOUCLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
623     {
624     bool import_occ_2017=false;
625     MG_BOUCLE* mgbou;
626 couturad 908 #ifdef ALL_OCC
627 couturad 906 if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
628     {
629     import_occ_2017=true;
630     parse.decode(data.c_str(),"@,@,(@)",param+2);
631     long ident=cid(param[2].argument[0]);
632     long idori=stol(param[3].argument[0]);
633     TopoDS_Wire topods_wire;
634     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
635     topods_wire=occ_fonction_v2017->get_TopoDS_Wire_id(idori);
636     if(ident!=-1)
637     {
638     MG_FACE* mgface=mggeo->get_mg_faceid(ident);
639     MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
640     if (mgface!=NULL)
641     {
642     mgbou=new OCC_BOUCLE(param[3].argument[0],id,mgface,topods_wire,&mggeo->get_occ_fonction());
643     mggeo->ajouter_mg_boucle(mgbou,mgface);
644     occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
645     }
646     if (mgpoutre!=NULL)
647     {
648     mgbou=new OCC_BOUCLE(param[3].argument[0],id,mgpoutre,topods_wire,&mggeo->get_occ_fonction());
649     mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
650     occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
651     }
652     }
653     else
654     {
655     mgbou=new OCC_BOUCLE(param[3].argument[0],id,topods_wire,&mggeo->get_occ_fonction());
656     mggeo->ajouter_mg_boucle(mgbou);
657     occ_fonction_v2017->ajouter_OCC_BOUCLE((OCC_BOUCLE*)mgbou);
658     }
659     }
660     #endif
661     if(!import_occ_2017)
662     {
663     parse.decode(data.c_str(),"@,(@)",param+2);
664     long ident=cid(param[2].argument[0]);
665     MG_FACE* mgface=mggeo->get_mg_faceid(ident);
666     MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
667     if (mgface!=NULL)
668     {
669     mgbou=new MG_BOUCLE(id,mgface);
670     mggeo->ajouter_mg_boucle(mgbou,mgface);
671     }
672     if (mgpoutre!=NULL)
673     {
674     mgbou=new MG_BOUCLE(id,mgpoutre);
675     mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
676     }
677     }
678     }
679    
680     void MG_FILE::lire_MG_ARETE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
681     {
682     parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
683     long idcur=cid(param[3].argument[0]);
684     int sens=atol(param[6].argument[0].c_str());
685     long idori = stoi(param[2].argument[0]);
686     MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
687     MG_ARETE* mgarete;
688 couturad 908 #ifdef ALL_OCC
689 couturad 906 if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
690     {
691     TopoDS_Edge topods_edge;
692     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
693     topods_edge=occ_fonction_v2017->get_TopoDS_Edge_id(idori);
694     mgarete= new OCC_ARETE(param[2].argument[0],id,mgcur,sens,topods_edge,&mggeo->get_occ_fonction());
695     occ_fonction_v2017->ajouter_OCC_ARETE((OCC_ARETE*)mgarete);
696     }
697     else mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens);
698     #else
699 couturad 908 mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens);
700 couturad 906 #endif
701     mggeo->ajouter_mg_arete(mgarete);
702     int nb=atoi(param[7].argument[0].c_str());
703     if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,mgarete);
704     }
705    
706     void MG_FILE::lire_MG_SOMMET(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data,MG_GEOMETRIE *mggeo)
707     {
708     if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,@,(&)",param+2);
709     else parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
710     long idpoint=cid(param[3].argument[0]);
711     long idori = stol(param[2].argument[0]);
712     MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
713     MG_SOMMET* mgsom;
714 couturad 908 #ifdef ALL_OCC
715 couturad 906 if(strcmp(mggeo->get_type_geometrie(),"OCCV2017")==0)
716     {
717     TopoDS_Vertex topods_vertex;
718     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
719     topods_vertex=occ_fonction_v2017->get_TopoDS_Vertex_id(idori);
720     mgsom = new OCC_SOMMET(param[2].argument[0],id,mgpt,topods_vertex,&mggeo->get_occ_fonction());
721     mggeo->ajouter_mg_sommet(mgsom);
722     occ_fonction_v2017->ajouter_OCC_SOMMET((OCC_SOMMET*)mgsom);
723     }
724     else mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
725     #else
726     mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
727     #endif
728     mggeo->ajouter_mg_sommet(mgsom);
729     int argccf=5;
730     if (version_fichier>2.1)
731     {
732     argccf=6;
733     int ipole=atoi(param[4].argument[0].c_str());
734     if (ipole==1) mgsom->change_pole(true);
735     }
736     int nb=atoi(param[argccf-1].argument[0].c_str());
737     if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgsom);
738     }
739    
740    
741    
742    
743    
744     void MG_FILE::lire_MG_CG_MODELE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
745     {
746     #ifdef ALL_OCC
747 couturad 912 parse.decode(data.c_str(),"@,@,@,@,@",param+2);
748 couturad 906 std::string nom=param[2].argument[0];
749     long id_mg_geometrie = cid((char*)param[3].argument[0].c_str());
750     int fusionner_entite_similaire = atoi((char*)param[4].argument[0].c_str());
751     int importer_triangulation = atoi((char*)param[5].argument[0].c_str());
752 couturad 912 double epsilon_triangulation = atof((char*)param[6].argument[0].c_str());
753 couturad 919 MG_GEOMETRIE* mg_construction = get_mg_constructionid(id_mg_geometrie);
754     MG_CG_MODELE* mgcg_modele=new MG_CG_MODELE(this,nom,mg_construction,id);
755 couturad 906 mgcg_modele->change_fusionner_entite_similaire(fusionner_entite_similaire);
756     mgcg_modele->change_importer_triangulation(importer_triangulation);
757     mgcg_modele->change_epsilon_triangulation(epsilon_triangulation);
758     ajouter_mgcg_modele(mgcg_modele);
759     #endif
760     }
761    
762     void MG_FILE::lire_MG_CG_ASSEMBLAGE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
763     {
764     #ifdef ALL_OCC
765     parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
766     long id_modele = cid((char*)param[2].argument[0].c_str());
767     std::string nom=param[3].argument[0];
768     long id_mg_sous_geometrie = cid((char*)param[4].argument[0].c_str());
769 couturad 912 long nb_mgcg_forme = atol((char*)param[5].argument[0].c_str());
770 couturad 906 MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
771     MG_SOUS_GEOMETRIE* mg_sous_geometrie;
772     MG_GEOMETRIE* mg_geometrie = get_mg_geometrieid(id_mg_sous_geometrie);
773     if(mg_geometrie!=NULL) mg_sous_geometrie = (MG_SOUS_GEOMETRIE*)mg_geometrie;
774     else mg_sous_geometrie=NULL;
775     MG_CG_ASSEMBLAGE *mgcg_assemblage=new MG_CG_ASSEMBLAGE(mgcg_modele,id,nom.c_str(),mg_sous_geometrie);
776 couturad 912 for(long i=0;i<nb_mgcg_forme;i++)
777 couturad 906 {
778     unsigned long id2 = cid(param[6].argument[i]);
779     mgcg_assemblage->ajouter_mgcg_forme(mgcg_modele->get_mgcg_formeid(id2),false);
780     }
781     mgcg_modele->ajouter_mgcg_assemblage(mgcg_assemblage);
782     #endif
783     }
784    
785 couturad 926 void MG_FILE::lire_MG_CG_GROUPE_FORME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
786     {
787     #ifdef ALL_OCC
788     // PARAM # 2 3 4 5
789     parse.decode(data.c_str(),"@,@,@,(&)",param+2);
790     long id_mgcg_modele = cid(param[2].argument[0]);
791     std::string nom=param[3].argument[0];
792     long nb_forme = atol(param[4].argument[0].c_str());
793     MG_CG_MODELE *mgcg_modele = get_mgcg_modeleid(id_mgcg_modele);
794     MG_CG_GROUPE_FORME* mgcg_groupe_forme = MG_CG::creer_MG_CG_GROUPE_FORME(mgcg_modele,id,nom);
795     for(long i=0;i<nb_forme;i++)
796     {
797     long id_forme = cid(param[5].argument[i]);
798     MG_CG_FORME* mgcg_forme = mgcg_modele->get_mgcg_formeid(id_forme);
799     mgcg_groupe_forme->ajouter_mgcg_forme(mgcg_forme);
800     }
801     #endif
802     }
803    
804 couturad 906 void MG_FILE::lire_MG_CG_FORME_ARETE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
805     {
806     #ifdef ALL_OCC
807     parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
808     long id_modele = cid((char*)param[2].argument[0].c_str());
809     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
810     int provenance_forme = atoi((char*)param[3].argument[0].c_str());
811     int etat_forme = atoi((char*)param[4].argument[0].c_str());
812     MG_ARETE* mg_arete;
813     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_arete = mgcg_modele->get_mg_geometrie()->get_mg_areteid(cid((char*)param[5].argument[0].c_str()));
814     MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[6].argument[0].c_str()));
815 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_ARETE(mgcg_modele,provenance_forme,etat_forme,id,mg_arete);
816 couturad 906 forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
817     mgcg_operateur_parent->ajouter_mgcg_forme_sortie(forme);
818     #endif
819     }
820    
821     void MG_FILE::lire_MG_CG_FORME_ARETE_DROITE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
822     {
823     #ifdef ALL_OCC
824     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
825     long id_modele = cid((char*)param[2].argument[0].c_str());
826     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
827     int etat_forme = atoi((char*)param[3].argument[0].c_str());
828     MG_ARETE* mg_arete;
829     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_arete = mgcg_modele->get_mg_geometrie()->get_mg_areteid(cid((char*)param[4].argument[0].c_str()));
830     double x1 = atof((char*)param[5].argument[0].c_str());
831     double y1 = atof((char*)param[6].argument[0].c_str());
832     double z1 = atof((char*)param[7].argument[0].c_str());
833     double x2 = atof((char*)param[8].argument[0].c_str());
834     double y2 = atof((char*)param[9].argument[0].c_str());
835     double z2 = atof((char*)param[10].argument[0].c_str());
836 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_ARETE_DROITE(mgcg_modele,etat_forme,id,mg_arete,x1,y1,z1,x2,y2,z2);
837 couturad 906 #endif
838     }
839    
840     void MG_FILE::lire_MG_CG_FORME_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
841     {
842     #ifdef ALL_OCC
843     parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
844     long id_modele = cid((char*)param[2].argument[0].c_str());
845     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
846     int provenance_forme = atoi((char*)param[3].argument[0].c_str());
847     int etat_forme = atoi((char*)param[4].argument[0].c_str());
848     MG_VOLUME* mg_volume;
849     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[5].argument[0].c_str()));
850     MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[6].argument[0].c_str()));
851 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME(mgcg_modele,provenance_forme,etat_forme,id,mg_volume);
852 couturad 906 forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
853     mgcg_operateur_parent->ajouter_mgcg_forme_sortie(forme);
854     #endif
855     }
856    
857     void MG_FILE::lire_MG_CG_FORME_VOLUME_BOITE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
858     {
859     #ifdef ALL_OCC
860     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
861     long id_modele = cid((char*)param[2].argument[0].c_str());
862     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
863     int etat_forme = atoi((char*)param[3].argument[0].c_str());
864     MG_VOLUME* mg_volume;
865     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
866     double x1 = atof((char*)param[5].argument[0].c_str());
867     double y1 = atof((char*)param[6].argument[0].c_str());
868     double z1 = atof((char*)param[7].argument[0].c_str());
869     double x2 = atof((char*)param[8].argument[0].c_str());
870     double y2 = atof((char*)param[9].argument[0].c_str());
871     double z2 = atof((char*)param[10].argument[0].c_str());
872 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_BOITE(mgcg_modele,etat_forme,id,mg_volume,x1,y1,z1,x2,y2,z2);
873 couturad 906 #endif
874     }
875    
876     void MG_FILE::lire_MG_CG_FORME_VOLUME_SPHERE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
877     {
878     #ifdef ALL_OCC
879     // PARAM # 2 3 4 5 6 7 8
880     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,(&)",param+2);
881     long id_modele = cid((char*)param[2].argument[0].c_str());
882     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
883     int etat_forme = atoi((char*)param[3].argument[0].c_str());
884     MG_VOLUME* mg_volume;
885     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
886     double centre_x = atof((char*)param[5].argument[0].c_str());
887     double centre_y = atof((char*)param[6].argument[0].c_str());
888     double centre_z = atof((char*)param[7].argument[0].c_str());
889     double rayon = atof((char*)param[8].argument[0].c_str());
890 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_SPHERE(mgcg_modele,etat_forme,id,mg_volume,centre_x,centre_y,centre_z,rayon);
891 couturad 906 #endif
892     }
893    
894     void MG_FILE::lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
895     {
896     #ifdef ALL_OCC
897     // PARAM # 2 3 4 5 6 7 8 9 101112
898     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
899     long id_modele = cid((char*)param[2].argument[0].c_str());
900     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
901     int etat_forme = atoi((char*)param[3].argument[0].c_str());
902     MG_VOLUME* mg_volume;
903     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
904     double centre_x = atof((char*)param[5].argument[0].c_str());
905     double centre_y = atof((char*)param[6].argument[0].c_str());
906     double centre_z = atof((char*)param[7].argument[0].c_str());
907     double direction_x = atof((char*)param[8].argument[0].c_str());
908     double direction_y = atof((char*)param[9].argument[0].c_str());
909     double direction_z = atof((char*)param[10].argument[0].c_str());
910     double rayon_majeur = atof((char*)param[11].argument[0].c_str());
911     double rayon_mineur = atof((char*)param[12].argument[0].c_str());
912 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_ELLIPSOIDE(mgcg_modele,etat_forme,id,mg_volume,centre_x,centre_y,centre_z,direction_x,direction_y,direction_z,rayon_majeur,rayon_mineur);
913 couturad 906 #endif
914     }
915    
916     void MG_FILE::lire_MG_CG_FORME_VOLUME_CYLINDRE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
917     {
918     #ifdef ALL_OCC
919     // PARAM # 2 3 4 5 6 7 8 9 101112
920     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
921     long id_modele = cid((char*)param[2].argument[0].c_str());
922     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
923     int etat_forme = atoi((char*)param[3].argument[0].c_str());
924     MG_VOLUME* mg_volume;
925     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
926     double extremite_x = atof((char*)param[5].argument[0].c_str());
927     double extremite_y = atof((char*)param[6].argument[0].c_str());
928     double extremite_z = atof((char*)param[7].argument[0].c_str());
929     double direction_x = atof((char*)param[8].argument[0].c_str());
930     double direction_y = atof((char*)param[9].argument[0].c_str());
931     double direction_z = atof((char*)param[10].argument[0].c_str());
932     double rayon = atof((char*)param[11].argument[0].c_str());
933     double longueur = atof((char*)param[12].argument[0].c_str());
934 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_CYLINDRE(mgcg_modele,etat_forme,id,mg_volume,extremite_x,extremite_y,extremite_z,direction_x,direction_y,direction_z,rayon,longueur);
935 couturad 906 #endif
936     }
937    
938     void MG_FILE::lire_MG_CG_FORME_VOLUME_CONE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
939     {
940     #ifdef ALL_OCC
941     // PARAM # 2 3 4 5 6 7 8 9 101112
942     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
943     long id_modele = cid((char*)param[2].argument[0].c_str());
944     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
945     int etat_forme = atoi((char*)param[3].argument[0].c_str());
946     MG_VOLUME* mg_volume;
947     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
948     double extremite_x = atof((char*)param[5].argument[0].c_str());
949     double extremite_y = atof((char*)param[6].argument[0].c_str());
950     double extremite_z = atof((char*)param[7].argument[0].c_str());
951     double direction_x = atof((char*)param[8].argument[0].c_str());
952     double direction_y = atof((char*)param[9].argument[0].c_str());
953     double direction_z = atof((char*)param[10].argument[0].c_str());
954     double rayon = atof((char*)param[11].argument[0].c_str());
955     double longueur = atof((char*)param[12].argument[0].c_str());
956 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_CONE(mgcg_modele,etat_forme,id,mg_volume,extremite_x,extremite_y,extremite_z,direction_x,direction_y,direction_z,rayon,longueur);
957 couturad 906 #endif
958     }
959    
960     void MG_FILE::lire_MG_CG_FORME_VOLUME_TORE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
961     {
962     #ifdef ALL_OCC
963     // PARAM # 2 3 4 5 6 7 8 9 101112
964     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,(&)",param+2);
965     long id_modele = cid((char*)param[2].argument[0].c_str());
966     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
967     int etat_forme = atoi((char*)param[3].argument[0].c_str());
968     MG_VOLUME* mg_volume;
969     if(etat_forme==MG_CG_FORME::ETAT_FORME::CONSTRUITE || etat_forme==MG_CG_FORME::ETAT_FORME::ATTENTE_RECONSTRUCTION) mg_volume = mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[4].argument[0].c_str()));
970     double centre_x = atof((char*)param[5].argument[0].c_str());
971     double centre_y = atof((char*)param[6].argument[0].c_str());
972     double centre_z = atof((char*)param[7].argument[0].c_str());
973     double direction_x = atof((char*)param[8].argument[0].c_str());
974     double direction_y = atof((char*)param[9].argument[0].c_str());
975     double direction_z = atof((char*)param[10].argument[0].c_str());
976     double rayon_cercle = atof((char*)param[11].argument[0].c_str());
977     double rayon_tore = atof((char*)param[12].argument[0].c_str());
978 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_VOLUME_TORE(mgcg_modele,etat_forme,id,mg_volume,centre_x,centre_y,centre_z,direction_x,direction_y,direction_z,rayon_cercle,rayon_tore);
979 couturad 906 #endif
980     }
981    
982     void MG_FILE::lire_MG_CG_FORME_MULTIPLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
983     {
984     #ifdef ALL_OCC
985     // PARAM # 2 3 4 5 6 7 8 9
986     parse.decode(data.c_str(),"@,@,@,@,(&),@,(&),@",param+2);
987     long id_modele = cid((char*)param[2].argument[0].c_str());
988     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
989     int provenance_forme = atoi((char*)param[3].argument[0].c_str());
990     int etat_forme = atoi((char*)param[4].argument[0].c_str());
991     std::vector<MG_ELEMENT_TOPOLOGIQUE*> vector_mg_element_topologique;
992     std::vector<MG_ELEMENT_COTOPOLOGIQUE*> vector_mg_element_cotopologique;
993     long nb_mg_element_topologique = atol((char*)param[5].argument[0].c_str());
994     for(long i=0;i<nb_mg_element_topologique;i++)
995     {
996     vector_mg_element_topologique.push_back(mgcg_modele->get_mg_geometrie()->get_mg_element_topologiqueid(cid((char*)param[6].argument[i].c_str())));
997     }
998     long nb_mg_element_cotopologique = atol((char*)param[7].argument[0].c_str());
999     for(long i=0;i<nb_mg_element_cotopologique;i++)
1000     {
1001     vector_mg_element_cotopologique.push_back(mgcg_modele->get_mg_geometrie()->get_mg_element_cotopologiqueid(cid((char*)param[8].argument[i].c_str())));
1002     }
1003     MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[9].argument[0].c_str()));
1004 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_MULTIPLE(mgcg_modele,provenance_forme,etat_forme,id,vector_mg_element_topologique,vector_mg_element_cotopologique);
1005 couturad 906 forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
1006     #endif
1007     }
1008    
1009     void MG_FILE::lire_MG_CG_FORME_MULTI_VOLUME(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1010     {
1011     #ifdef ALL_OCC
1012     // PARAM # 2 3 4 5 6 7
1013     parse.decode(data.c_str(),"@,@,@,@,(&),@",param+2);
1014     long id_modele = cid((char*)param[2].argument[0].c_str());
1015     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1016     int provenance_forme = atoi((char*)param[3].argument[0].c_str());
1017     int etat_forme = atoi((char*)param[4].argument[0].c_str());
1018     std::vector<MG_VOLUME*> vector_mg_volume;
1019     long nb_mg_volume = atol((char*)param[5].argument[0].c_str());
1020     for(long i=0;i<nb_mg_volume;i++)
1021     {
1022     vector_mg_volume.push_back(mgcg_modele->get_mg_geometrie()->get_mg_volumeid(cid((char*)param[6].argument[i].c_str())));
1023     }
1024     MG_CG_OPERATEUR* mgcg_operateur_parent = mgcg_modele->get_mgcg_operateurid(cid((char*)param[7].argument[0].c_str()));
1025 couturad 912 MG_CG_FORME* forme = MG_CG::creer_MG_CG_FORME_MULTI_VOLUME(mgcg_modele,provenance_forme,etat_forme,id,vector_mg_volume);
1026 couturad 906 forme->change_mgcg_operateur_parent(mgcg_operateur_parent);
1027     #endif
1028     }
1029    
1030     void MG_FILE::lire_MG_CG_OP_BOOL_UNION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1031     {
1032     #ifdef ALL_OCC
1033     // PARAM # 2 3 4 5 6 7
1034     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1035     long id_modele = cid((char*)param[2].argument[0].c_str());
1036     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1037     int semantique = atoi((char*)param[3].argument[0].c_str());
1038     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1039     MG_CG_FORME* mgcg_forme_entree_1=NULL;
1040     MG_CG_FORME* mgcg_forme_entree_2=NULL;
1041     long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1042     if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1043     long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1044     if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1045     long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1046 couturad 912 MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_UNION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1047 couturad 906 #endif
1048     }
1049    
1050     void MG_FILE::lire_MG_CG_OP_BOOL_DIFFERENCE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1051     {
1052     #ifdef ALL_OCC
1053     // PARAM # 2 3 4 5 6 7
1054     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1055     long id_modele = cid((char*)param[2].argument[0].c_str());
1056     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1057     int semantique = atoi((char*)param[3].argument[0].c_str());
1058     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1059     MG_CG_FORME* mgcg_forme_entree_1=NULL;
1060     MG_CG_FORME* mgcg_forme_entree_2=NULL;
1061     long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1062     if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1063     long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1064     if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1065     long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1066 couturad 912 MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_DIFFERENCE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1067 couturad 906 #endif
1068     }
1069    
1070     void MG_FILE::lire_MG_CG_OP_BOOL_INTERSECTION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1071     {
1072     #ifdef ALL_OCC
1073     // PARAM # 2 3 4 5 6 7
1074     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1075     long id_modele = cid((char*)param[2].argument[0].c_str());
1076     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1077     int semantique = atoi((char*)param[3].argument[0].c_str());
1078     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1079     MG_CG_FORME* mgcg_forme_entree_1=NULL;
1080     MG_CG_FORME* mgcg_forme_entree_2=NULL;
1081     long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1082     if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1083     long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1084     if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1085     long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1086 couturad 912 MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1087 couturad 906 #endif
1088     }
1089    
1090     void MG_FILE::lire_MG_CG_OP_BOOL_FRAGMENT(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1091     {
1092     #ifdef ALL_OCC
1093     // PARAM # 2 3 4 5 6 7
1094     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1095     long id_modele = cid((char*)param[2].argument[0].c_str());
1096     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1097     int semantique = atoi((char*)param[3].argument[0].c_str());
1098     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1099     MG_CG_FORME* mgcg_forme_entree_1=NULL;
1100     MG_CG_FORME* mgcg_forme_entree_2=NULL;
1101     long id_forme_entree_1 = cid((char*)param[5].argument[0].c_str());
1102     if(id_forme_entree_1!=0) mgcg_forme_entree_1=mgcg_modele->get_mgcg_formeid(id_forme_entree_1);
1103     long id_forme_entree_2 = cid((char*)param[6].argument[0].c_str());
1104     if(id_forme_entree_2!=0) mgcg_forme_entree_2=mgcg_modele->get_mgcg_formeid(id_forme_entree_2);
1105     long id_forme_sortie = cid((char*)param[7].argument[0].c_str());
1106 couturad 912 MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_FRAGMENT(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree_1,mgcg_forme_entree_2,id_forme_sortie);
1107 couturad 906 #endif
1108     }
1109    
1110     void MG_FILE::lire_MG_CG_OP_INCLUSION_MATRICE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1111     {
1112     #ifdef ALL_OCC
1113     // PARAM # 2 3 4 5 6 7 8
1114     parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1115     long id_modele = cid((char*)param[2].argument[0].c_str());
1116     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1117     int semantique = atoi((char*)param[3].argument[0].c_str());
1118     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1119     MG_CG_FORME* mgcg_forme_inclusion_entree=NULL;
1120     MG_CG_FORME* mgcg_forme_matrice_entree=NULL;
1121     long id_forme_inclusion_entree = cid((char*)param[5].argument[0].c_str());
1122     if(id_forme_inclusion_entree!=0) mgcg_forme_inclusion_entree=mgcg_modele->get_mgcg_formeid(id_forme_inclusion_entree);
1123     long id_forme_matrice_entree = cid((char*)param[6].argument[0].c_str());
1124     if(id_forme_matrice_entree!=0) mgcg_forme_matrice_entree=mgcg_modele->get_mgcg_formeid(id_forme_matrice_entree);
1125     long id_forme_inclusion_sortie = cid((char*)param[7].argument[0].c_str());
1126     long id_forme_matrice_sortie = cid((char*)param[8].argument[0].c_str());
1127 couturad 912 MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_inclusion_entree,mgcg_forme_matrice_entree,id_forme_inclusion_sortie,id_forme_matrice_sortie);
1128 couturad 906 #endif
1129     }
1130    
1131     void MG_FILE::lire_MG_CG_OP_TRANSF_ROTATION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1132     {
1133     #ifdef ALL_OCC
1134     // PARAM # 2 3 4 5 6 7 8 9 10 12
1135     // PARAM # 11 13
1136     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
1137     long id_modele = cid((char*)param[2].argument[0].c_str());
1138     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1139     int semantique = atoi((char*)param[3].argument[0].c_str());
1140     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1141     MG_CG_FORME* mgcg_forme_entree=NULL;
1142     long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1143     if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1144     long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1145 couturad 912 MG_CG_OP_TRANSF_ROTATION* mgcg_op_transf_rotation = MG_CG::creer_MG_CG_OP_TRANSF_ROTATION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1146 couturad 906 double x = atof((char*)param[7].argument[0].c_str());
1147     double y = atof((char*)param[8].argument[0].c_str());
1148     double z = atof((char*)param[9].argument[0].c_str());
1149     double w = atof((char*)param[10].argument[0].c_str());
1150     double centre_x = atof((char*)param[11].argument[0].c_str());
1151     double centre_y = atof((char*)param[12].argument[0].c_str());
1152     double centre_z = atof((char*)param[13].argument[0].c_str());
1153     OT_QUATERNION ot_quaternion(x,y,z,w);
1154     mgcg_op_transf_rotation->change_rotation(ot_quaternion);
1155     mgcg_op_transf_rotation->change_centre_rotation(centre_x,centre_y,centre_z);
1156     #endif
1157     }
1158    
1159     void MG_FILE::lire_MG_CG_OP_TRANSF_TRANSLATION(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1160     {
1161     #ifdef ALL_OCC
1162     // PARAM # 2 3 4 5 6 7 8 9
1163     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,",param+2);
1164     long id_modele = cid((char*)param[2].argument[0].c_str());
1165     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1166     int semantique = atoi((char*)param[3].argument[0].c_str());
1167     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1168     MG_CG_FORME* mgcg_forme_entree=NULL;
1169     long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1170     if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1171     long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1172 couturad 912 MG_CG_OP_TRANSF_TRANSLATION* mgcg_op_transf_translation = MG_CG::creer_MG_CG_OP_TRANSF_TRANSLATION(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1173 couturad 906 double x = atof((char*)param[7].argument[0].c_str());
1174     double y = atof((char*)param[8].argument[0].c_str());
1175     double z = atof((char*)param[9].argument[0].c_str());
1176     mgcg_op_transf_translation->change_translation(x,y,z);
1177     #endif
1178     }
1179    
1180     void MG_FILE::lire_MG_CG_OP_TRANSF_ECHELLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1181     {
1182     #ifdef ALL_OCC
1183     // PARAM # 2 3 4 5 6 7 8 9 10
1184     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,",param+2);
1185     long id_modele = cid((char*)param[2].argument[0].c_str());
1186     MG_CG_MODELE* mgcg_modele = get_mgcg_modeleid(id_modele);
1187     int semantique = atoi((char*)param[3].argument[0].c_str());
1188     int etat_operateur = atoi((char*)param[4].argument[0].c_str());
1189     MG_CG_FORME* mgcg_forme_entree=NULL;
1190     long id_forme_entree = cid((char*)param[5].argument[0].c_str());
1191     if(id_forme_entree!=0) mgcg_forme_entree=mgcg_modele->get_mgcg_formeid(id_forme_entree);
1192     long id_forme_sortie = cid((char*)param[6].argument[0].c_str());
1193 couturad 912 MG_CG_OP_TRANSF_ECHELLE* mgcg_op_transf_echelle = MG_CG::creer_MG_CG_OP_TRANSF_ECHELLE(mgcg_modele,semantique,etat_operateur,id,mgcg_forme_entree,id_forme_sortie);
1194 couturad 906 double x = atof((char*)param[7].argument[0].c_str());
1195     double y = atof((char*)param[8].argument[0].c_str());
1196     double z = atof((char*)param[9].argument[0].c_str());
1197     double facteur = atof((char*)param[10].argument[0].c_str());
1198     mgcg_op_transf_echelle->change_centre_echelle(x,y,z);
1199     mgcg_op_transf_echelle->change_facteur_echelle(facteur);
1200     #endif
1201     }
1202    
1203 couturad 926 void MG_FILE::lire_MG_CG_INFO_STRING(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1204     {
1205     #ifdef ALL_OCC
1206     // PARAM # 2 3
1207     parse.decode(data.c_str(),"@,@",param+2);
1208     std::string identifiant = param[2].argument[0];
1209     std::string valeur = param[3].argument[0];
1210     MG_IDENTIFICATEUR *mg_id=NULL;
1211     LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
1212     while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
1213     {
1214     MG_CG_MODELE* modele = it_modele->second;
1215     if(modele->get_id()==id)
1216     {
1217     mg_id=modele;
1218     }
1219     else
1220     {
1221     mg_id=modele->get_mg_identificateur(id);
1222     }
1223     it_modele++;
1224     }
1225     if(mg_id!=NULL)
1226     {
1227     MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
1228     MG_CG_INFO_STRING* info_str = MG_CG::creer_MG_CG_INFO_STRING(mg_constr_geo,id,identifiant,valeur);
1229     }
1230     #endif
1231     }
1232    
1233     void MG_FILE::lire_MG_CG_INFO_DOUBLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1234     {
1235     #ifdef ALL_OCC
1236     // PARAM # 2 3
1237     parse.decode(data.c_str(),"@,@",param+2);
1238     std::string identifiant = param[2].argument[0];
1239     double valeur = atof(param[3].argument[0].c_str());
1240     MG_IDENTIFICATEUR *mg_id=NULL;
1241     LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
1242     while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
1243     {
1244     MG_CG_MODELE* modele = it_modele->second;
1245     if(modele->get_id()==id)
1246     {
1247     mg_id=modele;
1248     }
1249     else
1250     {
1251     mg_id=modele->get_mg_identificateur(id);
1252     }
1253     it_modele++;
1254     }
1255     if(mg_id!=NULL)
1256     {
1257     MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
1258     MG_CG_INFO_DOUBLE* info_dbl = MG_CG::creer_MG_CG_INFO_DOUBLE(mg_constr_geo,id,identifiant,valeur);
1259     }
1260     #endif
1261     }
1262    
1263     void MG_FILE::lire_MG_CG_INFO_VCT_DOUBLE(long id,class PARSE& parse,class PARS_ARGUMENT (&param)[100],std::string& data)
1264     {
1265     #ifdef ALL_OCC
1266     // PARAM # 2 3 4
1267     parse.decode(data.c_str(),"@,@,(&)",param+2);
1268     std::string identifiant = param[2].argument[0];
1269     long nb_valeur = atol(param[3].argument[0].c_str());
1270     std::vector<double> vector_valeur;
1271     for(long i=0;i<nb_valeur;i++)
1272     {
1273     double valeur = atof(param[4].argument[i].c_str());
1274     vector_valeur.push_back(valeur);
1275     }
1276     MG_IDENTIFICATEUR *mg_id=NULL;
1277     LISTE_MGCG_MODELE::iterator it_modele=lst_mgcg_modele.begin();
1278     while(mg_id==NULL && it_modele!=lst_mgcg_modele.end())
1279     {
1280     MG_CG_MODELE* modele = it_modele->second;
1281     if(modele->get_id()==id)
1282     {
1283     mg_id=modele;
1284     }
1285     else
1286     {
1287     mg_id=modele->get_mg_identificateur(id);
1288     }
1289     it_modele++;
1290     }
1291     if(mg_id!=NULL)
1292     {
1293     MG_CONSTRUCTION_GEOMETRIQUE* mg_constr_geo = (MG_CONSTRUCTION_GEOMETRIQUE*)mg_id;
1294     MG_CG_INFO_VCT_DOUBLE* info_dbl = MG_CG::creer_MG_CG_INFO_VCT_DOUBLE(mg_constr_geo,id,identifiant,vector_valeur);
1295     }
1296     #endif
1297     }
1298    
1299    
1300 francois 283 int MG_FILE::lire(char* chemin)
1301     {
1302     FILE *in;
1303 francois 706 //char ligne[3000];
1304 francois 283 in=fopen(chemin,"rt");
1305     if (in==NULL) return 0;
1306     PARS_ARGUMENT param[100];
1307     PARSE parse;
1308    
1309     MG_GEOMETRIE *mggeo;
1310 francois 689 MG_ARBRE* arbre;
1311 francois 283 #ifdef WINDOWS_VERSION
1312     std::multimap<CAD4FE::MCVertex*, unsigned long> mapMergedRefVertices;
1313     #endif
1314     bool updatedMergedRefVertices = false;
1315 francois 763 version_fichier=1.0;
1316 francois 881 std::vector<unsigned long> volumemince;
1317 francois 283 do
1318     {
1319     int ierr;
1320     std::string ligne=parse.lire(in,';',&ierr);
1321     parse.decode(ligne.c_str(),"@;",param);
1322     const char *chaine=param[0].argument[0].c_str();
1323     if ((chaine[0]=='/') && (chaine[1]=='/'))
1324     {
1325     if ((chaine[2]=='*')&&(chaine[3]=='i'))
1326     {
1327     unsigned long id;
1328     sscanf(chaine,"//*i:%lu;",&id);
1329     entiteidmax=id;
1330     }
1331 francois 763 if ((chaine[2]=='*')&&(chaine[3]=='v'))
1332     sscanf(chaine,"//*v:%lf;",&version_fichier);
1333 francois 283 }
1334     else if (param[0].argument[0]!="FIN")
1335     {
1336     parse.decode(ligne.c_str(),"%@=@(@);",param);
1337     std::string entite=param[1].argument[0];
1338     long id=atol(param[0].argument[0].c_str());
1339     std::string data=param[2].argument[0] ;
1340     MG_MAILLAGE *mgmai;
1341     FEM_MAILLAGE *femmai;
1342     if (entite=="GEOMETRIE")
1343     {
1344     parse.decode(data.c_str(),"@,@,@,@",param+2);
1345     double unite=atof(param[2].argument[0].c_str());
1346     std::string typegeo=param[3].argument[0];
1347 couturad 919 std::string chemin_geo=param[4].argument[0];
1348 francois 576 if (typegeo=="VIRTUEL")
1349     {
1350 couturad 919 mggeo=new MG_GEOMETRIE((char*)typegeo.c_str(),id,(char*)chemin_geo.c_str(),unite);
1351 francois 576 ajouter_mg_geometrie(mggeo);
1352     }
1353 francois 283 #ifdef BREP_STEP
1354     if (typegeo=="STEP")
1355     {
1356 couturad 919 mggeo=new MG_GEOMETRIE((char*)"STEP",id,(char *)chemin_geo.c_str(),unite);
1357 francois 283 ajouter_mg_geometrie(mggeo);
1358     }
1359     #endif
1360     #ifdef BREP_SAT
1361     if (typegeo=="ACIS")
1362     {
1363 couturad 919 mggeo=new MG_GEOMETRIE((char*)"ACIS",id,(char *)chemin_geo.c_str(),unite);
1364 francois 283 ajouter_mg_geometrie(mggeo);
1365     }
1366     #endif
1367    
1368     #ifdef BREP_OCC
1369     if (typegeo=="OCC")
1370     {
1371 couturad 919 mggeo=new MG_GEOMETRIE((char*)"OCC",id,chemin_geo.c_str(),unite);
1372 francois 283 ajouter_mg_geometrie(mggeo);
1373     }
1374 couturad 740 if (typegeo=="OCCV2015")
1375     {
1376 couturad 919 mggeo=new MG_GEOMETRIE((char*)"OCCV2015",id,chemin_geo.c_str(),unite);
1377 couturad 740 ajouter_mg_geometrie(mggeo);
1378     }
1379 couturad 908 #endif
1380     #ifdef ALL_OCC
1381 couturad 906 if (typegeo=="OCCV2017")
1382     {
1383 couturad 919 mggeo=new MG_GEOMETRIE((char*)"OCCV2017",id,chemin_geo.c_str(),unite);
1384 couturad 906 ajouter_mg_geometrie(mggeo);
1385     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1386 couturad 919 std::string chemin_caf = str_dossier + chemin_geo + ".ocaf";
1387 couturad 906 char* chemin_caf_char = (char*)chemin_caf.c_str();
1388     occ_fonction_v2017->ouvrir_fichier_OCAF(chemin_caf_char);
1389     }
1390 francois 283 #endif
1391    
1392     std::string nommat="";
1393     if (param[5].argument[0]!="")
1394     nommat=param[5].argument[0];
1395     mggeo->change_gest_materiau((char*)nommat.c_str());
1396     }
1397 couturad 919 if (entite=="CONSTRUCTION")
1398     {
1399     MG_GEOMETRIE * mgconstruction;
1400     parse.decode(data.c_str(),"@,@,@,@",param+2);
1401     double unite=atof(param[2].argument[0].c_str());
1402     std::string typegeo=param[3].argument[0];
1403     std::string chemin_geo=param[4].argument[0];
1404     #ifdef ALL_OCC
1405     if (typegeo=="OCCV2017")
1406     {
1407     mgconstruction=new MG_GEOMETRIE((char*)"OCCV2017",id,chemin_geo.c_str(),unite);
1408     mggeo=mgconstruction;
1409     mgconstruction->change_est_construction(true);
1410     ajouter_mg_construction(mgconstruction);
1411     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mgconstruction->get_occ_fonction();
1412     std::string chemin_caf = str_dossier + chemin_geo + ".ocaf";
1413     char* chemin_caf_char = (char*)chemin_caf.c_str();
1414     occ_fonction_v2017->ouvrir_fichier_OCAF(chemin_caf_char);
1415     }
1416     #endif
1417     std::string nommat="";
1418     if (param[5].argument[0]!="")
1419     nommat=param[5].argument[0];
1420     mgconstruction->change_gest_materiau((char*)nommat.c_str());
1421     }
1422 francois 689 #ifdef CSG_OCC
1423     if (entite=="ARBRE")
1424     {
1425     parse.decode(data.c_str(),"@",param+2);
1426     std::string nom=param[2].argument[0];
1427     arbre=new MG_ARBRE(id,nom.c_str());
1428     ajouter_mg_arbre(arbre);
1429     }
1430 couturad 740 if (entite == "ASSEMBLAGE")
1431     {
1432     parse.decode(data.c_str(),"@,@,(&)",param+2);
1433     std::string nom=param[2].argument[0];
1434     int nb_primitive = atoi((char*)param[3].argument[0].c_str());
1435     MG_ASSEMBLAGE *mgassembl=new MG_ASSEMBLAGE(id,nom.c_str());
1436     for(int i=0;i<nb_primitive;i++)
1437     {
1438     unsigned long id2 = cid(param[4].argument[i]);
1439 francois 741 mgassembl->ajouter_mg_primitive(id2);
1440 couturad 740 }
1441     arbre->ajouter_mg_assemblage(mgassembl);
1442     }
1443 francois 689 if (entite=="BOITE")
1444     {
1445     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
1446     double x1=atof((char*)param[2].argument[0].c_str());
1447     double y1=atof((char*)param[3].argument[0].c_str());
1448     double z1=atof((char*)param[4].argument[0].c_str());
1449     double x2=atof((char*)param[5].argument[0].c_str());
1450     double y2=atof((char*)param[6].argument[0].c_str());
1451     double z2=atof((char*)param[7].argument[0].c_str());
1452     MG_PRIMITIVE_BOITE *b=new MG_PRIMITIVE_BOITE(id,x1,y1,z1,x2,y2,z2);
1453     b->construit();
1454     arbre->ajouter_mg_primitive(b);
1455     }
1456 couturad 723 if (entite=="SPHERE")
1457 francois 689 {
1458 couturad 723 parse.decode(data.c_str(),"@,@,@,@",param+2);
1459     double centre_x=atof((char*)param[2].argument[0].c_str());
1460     double centre_y=atof((char*)param[3].argument[0].c_str());
1461     double centre_z=atof((char*)param[4].argument[0].c_str());
1462     double rayon=atof((char*)param[5].argument[0].c_str());
1463     MG_PRIMITIVE_SPHERE *b=new MG_PRIMITIVE_SPHERE(id,centre_x,centre_y,centre_z,rayon);
1464     b->construit();
1465     arbre->ajouter_mg_primitive(b);
1466     }
1467 couturad 823 if (entite=="ELLIPSOIDE_REVOLUTION")
1468     {
1469     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
1470     double centre_x=atof((char*)param[2].argument[0].c_str());
1471     double centre_y=atof((char*)param[3].argument[0].c_str());
1472     double centre_z=atof((char*)param[4].argument[0].c_str());
1473     double axe_x=atof((char*)param[5].argument[0].c_str());
1474     double axe_y=atof((char*)param[6].argument[0].c_str());
1475     double axe_z=atof((char*)param[7].argument[0].c_str());
1476     double rayon_majeur=atof((char*)param[8].argument[0].c_str());
1477     double rayon_mineur=atof((char*)param[9].argument[0].c_str());
1478     MG_PRIMITIVE_ELLIPSOIDE_REVOLUTION *b=new MG_PRIMITIVE_ELLIPSOIDE_REVOLUTION(id,centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon_majeur,rayon_mineur);
1479     b->construit();
1480     arbre->ajouter_mg_primitive(b);
1481     }
1482 couturad 723 if (entite=="CYLINDRE")
1483     {
1484     parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1485     double extremite_x=atof((char*)param[2].argument[0].c_str());
1486     double extremite_y=atof((char*)param[3].argument[0].c_str());
1487     double extremite_z=atof((char*)param[4].argument[0].c_str());
1488     double longitude=atof((char*)param[5].argument[0].c_str());
1489     double latitude=atof((char*)param[6].argument[0].c_str());
1490     double rayon=atof((char*)param[7].argument[0].c_str());
1491     double longueur=atof((char*)param[8].argument[0].c_str());
1492     MG_PRIMITIVE_CYLINDRE *b=new MG_PRIMITIVE_CYLINDRE(id,extremite_x,extremite_y,extremite_z,longitude,latitude,rayon,longueur);
1493     b->construit();
1494     arbre->ajouter_mg_primitive(b);
1495     }
1496 couturad 724 if (entite=="TORE")
1497     {
1498     parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1499     double centre_x=atof((char*)param[2].argument[0].c_str());
1500     double centre_y=atof((char*)param[3].argument[0].c_str());
1501     double centre_z=atof((char*)param[4].argument[0].c_str());
1502     double longitude=atof((char*)param[5].argument[0].c_str());
1503     double latitude=atof((char*)param[6].argument[0].c_str());
1504     double rayon_cercle=atof((char*)param[7].argument[0].c_str());
1505     double rayon_tore=atof((char*)param[8].argument[0].c_str());
1506     MG_PRIMITIVE_TORE *b=new MG_PRIMITIVE_TORE(id,centre_x,centre_y,centre_z,longitude,latitude,rayon_cercle,rayon_tore);
1507     b->construit();
1508     arbre->ajouter_mg_primitive(b);
1509     }
1510     if (entite=="CONE")
1511     {
1512     parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
1513     double base_x=atof((char*)param[2].argument[0].c_str());
1514     double base_y=atof((char*)param[3].argument[0].c_str());
1515     double base_z=atof((char*)param[4].argument[0].c_str());
1516     double longitude=atof((char*)param[5].argument[0].c_str());
1517     double latitude=atof((char*)param[6].argument[0].c_str());
1518     double rayon=atof((char*)param[7].argument[0].c_str());
1519     double hauteur=atof((char*)param[8].argument[0].c_str());
1520     MG_PRIMITIVE_CONE *b=new MG_PRIMITIVE_CONE(id,base_x,base_y,base_z,longitude,latitude,rayon,hauteur);
1521     b->construit();
1522     arbre->ajouter_mg_primitive(b);
1523     }
1524 couturad 723 if (entite=="UNION")
1525     {
1526 francois 689 parse.decode(data.c_str(),"@,@,@",param+2);
1527     int sem=atoi((char*)param[2].argument[0].c_str());
1528     long id1=cid((char*)param[3].argument[0].c_str());
1529     long id2=cid((char*)param[4].argument[0].c_str());
1530     MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
1531     MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
1532     MG_OPERATEUR_BOOLEAN_UNION *op=new MG_OPERATEUR_BOOLEAN_UNION(id,sem,p1,p2);
1533     arbre->ajouter_mg_operateur_boolean(op);
1534     }
1535 couturad 723 if (entite=="DIFFERENCE")
1536     {
1537     parse.decode(data.c_str(),"@,@,@",param+2);
1538     int sem=atoi((char*)param[2].argument[0].c_str());
1539     long id1=cid((char*)param[3].argument[0].c_str());
1540     long id2=cid((char*)param[4].argument[0].c_str());
1541     MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
1542     MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
1543     MG_OPERATEUR_BOOLEAN_DIFFERENCE *op=new MG_OPERATEUR_BOOLEAN_DIFFERENCE(id,sem,p1,p2);
1544     arbre->ajouter_mg_operateur_boolean(op);
1545     }
1546     if (entite=="INTERSECTION")
1547     {
1548     parse.decode(data.c_str(),"@,@,@",param+2);
1549     int sem=atoi((char*)param[2].argument[0].c_str());
1550     long id1=cid((char*)param[3].argument[0].c_str());
1551     long id2=cid((char*)param[4].argument[0].c_str());
1552     MG_PRIMITIVE *p1=arbre->get_mg_primitiveid(id1);
1553     MG_PRIMITIVE *p2=arbre->get_mg_primitiveid(id2);
1554     MG_OPERATEUR_BOOLEAN_INTERSECTION *op=new MG_OPERATEUR_BOOLEAN_INTERSECTION(id,sem,p1,p2);
1555     arbre->ajouter_mg_operateur_boolean(op);
1556     }
1557 francois 689 if (entite=="PRIM_COMPLEXE")
1558     {
1559     parse.decode(data.c_str(),"@",param+2);
1560     long id1=cid((char*)param[2].argument[0].c_str());
1561     MG_OPERATEUR_BOOLEAN *op=arbre->get_mg_operateur_booleanid(id1);
1562     MG_PRIMITIVE* p=op->construit(id);
1563     arbre->ajouter_mg_primitive(p);
1564     }
1565    
1566 couturad 906 if (entite=="MG_CG_MODELE")
1567     {
1568     lire_MG_CG_MODELE(id,parse,param,data);
1569     }
1570     if (entite =="MG_CG_ASSEMBLAGE")
1571     {
1572     lire_MG_CG_ASSEMBLAGE(id,parse,param,data);
1573     }
1574 couturad 926 if (entite =="MG_CG_INFO_DOUBLE")
1575     {
1576     lire_MG_CG_INFO_DOUBLE(id,parse,param,data);
1577     }
1578     if (entite =="MG_CG_INFO_STRING")
1579     {
1580     lire_MG_CG_INFO_STRING(id,parse,param,data);
1581     }
1582     if (entite =="MG_CG_INFO_VCT_DOUBLE")
1583     {
1584     lire_MG_CG_INFO_VCT_DOUBLE(id,parse,param,data);
1585     }
1586     if (entite =="MG_CG_GROUPE_FORME")
1587     {
1588     lire_MG_CG_GROUPE_FORME(id,parse,param,data);
1589     }
1590 couturad 906 if (entite =="MG_CG_FORME_ARETE")
1591     {
1592     lire_MG_CG_FORME_ARETE(id,parse,param,data);
1593     }
1594     if (entite =="MG_CG_FORME_ARETE_DROITE")
1595     {
1596     lire_MG_CG_FORME_ARETE_DROITE(id,parse,param,data);
1597     }
1598     if (entite =="MG_CG_FORME_VOLUME")
1599     {
1600     lire_MG_CG_FORME_VOLUME(id,parse,param,data);
1601     }
1602     if (entite =="MG_CG_FORME_VOLUME_BOITE")
1603     {
1604     lire_MG_CG_FORME_VOLUME_BOITE(id,parse,param,data);
1605     }
1606     if (entite =="MG_CG_FORME_VOLUME_SPHERE")
1607     {
1608     lire_MG_CG_FORME_VOLUME_SPHERE(id,parse,param,data);
1609     }
1610     if (entite =="MG_CG_FORME_VOLUME_ELLIPSOIDE")
1611     {
1612     lire_MG_CG_FORME_VOLUME_ELLIPSOIDE(id,parse,param,data);
1613     }
1614     if (entite =="MG_CG_FORME_VOLUME_CYLINDRE")
1615     {
1616     lire_MG_CG_FORME_VOLUME_CYLINDRE(id,parse,param,data);
1617     }
1618     if (entite =="MG_CG_FORME_VOLUME_CONE")
1619     {
1620     lire_MG_CG_FORME_VOLUME_CONE(id,parse,param,data);
1621     }
1622     if (entite =="MG_CG_FORME_VOLUME_TORE")
1623     {
1624     lire_MG_CG_FORME_VOLUME_TORE(id,parse,param,data);
1625     }
1626     if (entite =="MG_CG_FORME_MULTIPLE")
1627     {
1628     lire_MG_CG_FORME_MULTIPLE(id,parse,param,data);
1629     }
1630     if (entite =="MG_CG_FORME_MULTI_VOLUME")
1631     {
1632     lire_MG_CG_FORME_MULTI_VOLUME(id,parse,param,data);
1633     }
1634     if (entite =="MG_CG_OP_BOOL_UNION")
1635     {
1636     lire_MG_CG_OP_BOOL_UNION(id,parse,param,data);
1637     }
1638     if (entite =="MG_CG_OP_BOOL_DIFFERENCE")
1639     {
1640     lire_MG_CG_OP_BOOL_DIFFERENCE(id,parse,param,data);
1641     }
1642     if (entite =="MG_CG_OP_BOOL_INTERSECTION")
1643     {
1644     lire_MG_CG_OP_BOOL_INTERSECTION(id,parse,param,data);
1645     }
1646     if (entite =="MG_CG_OP_BOOL_FRAGMENT")
1647     {
1648     lire_MG_CG_OP_BOOL_FRAGMENT(id,parse,param,data);
1649     }
1650     if (entite =="MG_CG_OP_INCLUSION_MATRICE")
1651     {
1652     lire_MG_CG_OP_INCLUSION_MATRICE(id,parse,param,data);
1653     }
1654     if (entite =="MG_CG_OP_TRANSF_ROTATION")
1655     {
1656     lire_MG_CG_OP_TRANSF_ROTATION(id,parse,param,data);
1657     }
1658     if (entite =="MG_CG_OP_TRANSF_TRANSLATION")
1659     {
1660     lire_MG_CG_OP_TRANSF_TRANSLATION(id,parse,param,data);
1661     }
1662     if (entite =="MG_CG_OP_TRANSF_ECHELLE")
1663     {
1664     lire_MG_CG_OP_TRANSF_ECHELLE(id,parse,param,data);
1665     }
1666 francois 689
1667     #endif
1668 couturad 906 if (entite =="MG_SOUS_GEOMETRIE")
1669     {
1670     lire_MG_SOUS_GEOMETRIE(id,parse,param,data);
1671     }
1672 francois 283 if (entite=="GEOMETRIE_EPS")
1673     {
1674     parse.decode(data.c_str(),"@",param+2);
1675     double val=atof((char*)param[2].argument[0].c_str());
1676     mggeo->change_valeur_precision(val);
1677     }
1678     if (entite=="GROUPE_TOPOLOGIQUE")
1679     {
1680     parse.decode(data.c_str(),"@,(&)",param+2);
1681     MG_GROUPE_TOPOLOGIQUE* mggt=new MG_GROUPE_TOPOLOGIQUE(id);
1682     mggeo->ajouter_mg_groupe_topologique(mggt);
1683     int nb=atoi(param[2].argument[0].c_str());
1684     for (int i=0;i<nb;i++)
1685     {
1686     unsigned long id2=cid(param[3].argument[i].c_str());
1687     MG_ELEMENT_TOPOLOGIQUE* ele;
1688     ele=mggeo->get_mg_sommetid(id2);
1689     if (ele==NULL) ele=mggeo->get_mg_areteid(id2);
1690     if (ele==NULL) ele=mggeo->get_mg_faceid(id2);
1691     if (ele==NULL) ele=mggeo->get_mg_volumeid(id2);
1692     if (ele!=NULL) mggt->ajouter(ele);
1693     }
1694    
1695     }
1696 francois 711 if (entite=="GEOM_FONCTION")
1697     {
1698     parse.decode(data.c_str(),"@,@,(&)",param+2);
1699     int dim=atoi((char*)param[2].argument[0].c_str());
1700     MG_GEOM_FONCTION *gf=new MG_GEOM_FONCTION(id,dim);
1701     mggeo->ajouter_mg_geom_fonction(gf);
1702     int nb=atoi(param[3].argument[0].c_str());
1703     for (int i=0;i<nb;i++)
1704     {
1705     parse.decode(param[4].argument[i].c_str(),"(&)",param+5);
1706     double *coo=new double[dim];
1707     for (int j=0;j<dim;j++)
1708     coo[j]=atof(param[5].argument[j].c_str());
1709     gf->ajouter_point(coo);
1710     delete [] coo;
1711     }
1712    
1713     }
1714    
1715 francois 283 if (entite=="VOLUME")
1716     {
1717 couturad 906 lire_MG_VOLUME(id,parse,param,data,mggeo,volumemince);
1718    
1719     // if (version_fichier<2)
1720     // {
1721     // parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
1722     // MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
1723     // mggeo->ajouter_mg_volume(mgvol);
1724     // int nummat=atoi((char*)param[4].argument[0].c_str());
1725     // mgvol->change_num_materiau(nummat);
1726     // int nb=atoi(param[5].argument[0].c_str());
1727     // if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
1728     // }
1729     // else if (version_fichier<2.3)
1730     // {
1731     // parse.decode(data.c_str(),"@,@,@,(&)",param+2);
1732     // MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
1733     // mggeo->ajouter_mg_volume(mgvol);
1734     // int nb=atoi(param[4].argument[0].c_str());
1735     // if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgvol);
1736     // }
1737     // else
1738     // {
1739     // parse.decode(data.c_str(),"@,@,@,@",param+2);
1740     // MG_VOLUME* mgvol=new MG_VOLUME(param[2].argument[0],id);
1741     // mggeo->ajouter_mg_volume(mgvol);
1742     // int mince=atoi(param[4].argument[0].c_str());
1743     // if (mince==0)
1744     // {
1745     // std::string data2=param[5].argument[0];
1746     // parse.decode(data2.c_str(),"@,(&)",param+5);
1747     // int nb=atoi(param[5].argument[0].c_str());
1748     // if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgvol);
1749     // }
1750     // else
1751     // {
1752     // std::string data2=param[5].argument[0];
1753     // parse.decode(data2.c_str(),"(&),@,(&)",param+5);
1754     // int nb_face=param[5].argument.size();
1755     // for (int i=0;i<nb_face;i=i+2)
1756     // {
1757     // unsigned long idn1=cid(param[5].argument[i]);
1758     // unsigned long idn2=cid(param[5].argument[i+1]);
1759     // volumemince.push_back(id);
1760     // volumemince.push_back(idn1);
1761     // volumemince.push_back(idn2);
1762     // }
1763     // int nb=atoi(param[6].argument[0].c_str());
1764     // if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,mgvol);
1765     // }
1766     // }
1767 francois 763 /*{
1768 francois 283 for (int i=0;i<nb;i++)
1769     {
1770     parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
1771     char nom[3];
1772     double val;
1773     strcpy(nom,param[7].argument[0].c_str());
1774     val=atof(param[8].argument[0].c_str());
1775     mgvol->ajouter_ccf(nom,val);
1776     }
1777 francois 763 }*/
1778 francois 283 }
1779     if (entite=="COQUE")
1780     {
1781 francois 794 if (version_fichier<2)
1782     {
1783     parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
1784 francois 283 MG_COQUE* mgcoq=new MG_COQUE(param[2].argument[0],id);
1785     mggeo->ajouter_mg_coque(mgcoq);
1786     int nummat=atoi((char*)param[4].argument[0].c_str());
1787     mgcoq->change_num_materiau(nummat);
1788     int nb=atoi(param[5].argument[0].c_str());
1789 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgcoq);
1790 francois 794 }
1791     else
1792     {
1793     parse.decode(data.c_str(),"@,@,@,(&)",param+2);
1794     MG_COQUE* mgcoq=new MG_COQUE(param[2].argument[0],id);
1795     mggeo->ajouter_mg_coque(mgcoq);
1796     int nb=atoi(param[4].argument[0].c_str());
1797     if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgcoq);
1798     }
1799 francois 763 /*if (nb!=0)
1800 francois 283 {
1801     for (int i=0;i<nb;i++)
1802     {
1803     parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
1804     char nom[3];
1805     double val;
1806     strcpy(nom,param[7].argument[0].c_str());
1807     val=atof(param[8].argument[0].c_str());
1808     mgcoq->ajouter_ccf(nom,val);
1809     }
1810 francois 763 }*/
1811 francois 283 }
1812     if (entite=="POUTRE")
1813     {
1814 francois 794 if (version_fichier<2)
1815     {
1816     parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
1817 francois 283 MG_POUTRE* mgpoutre=new MG_POUTRE(param[2].argument[0],id);
1818     mggeo->ajouter_mg_poutre(mgpoutre);
1819     int nummat=atoi((char*)param[4].argument[0].c_str());
1820     mgpoutre->change_num_materiau(nummat);
1821     int nb=atoi(param[5].argument[0].c_str());
1822 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,mgpoutre);
1823 francois 794 }
1824     else
1825     {
1826     parse.decode(data.c_str(),"@,@,@,(&)",param+2);
1827     MG_POUTRE* mgpou=new MG_POUTRE(param[2].argument[0],id);
1828     mggeo->ajouter_mg_poutre(mgpou);
1829     int nb=atoi(param[4].argument[0].c_str());
1830     if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,mgpou);
1831     }
1832    
1833 francois 763 /*if (nb!=0)
1834 francois 283 {
1835     for (int i=0;i<nb;i++)
1836     {
1837     parse.decode(param[6].argument[i].c_str(),"(@,@)",param+7);
1838     char nom[3];
1839     double val;
1840     strcpy(nom,param[7].argument[0].c_str());
1841     val=atof(param[8].argument[0].c_str());
1842     mgpoutre->ajouter_ccf(nom,val);
1843     }
1844 francois 763 }*/
1845 francois 283 }
1846     if (entite=="COQUILLE")
1847     {
1848 couturad 906 lire_MG_COQUILLE(id,parse,param,data,mggeo);
1849     // parse.decode(data.c_str(),"@,@",param+2);
1850     // long ident=cid(param[2].argument[0]);
1851     // MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
1852     // MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
1853     // if (mgvol!=NULL)
1854     // {
1855     // MG_COQUILLE* mgcoq=new MG_COQUILLE(id,mgvol);
1856     // mggeo->ajouter_mg_coquille(mgcoq,mgvol);
1857     // }
1858     // if (mgcoq!=NULL)
1859     // {
1860     // MG_COQUILLE* mgcoquille=new MG_COQUILLE(id,mgcoq);
1861     // mggeo->ajouter_mg_coquille(mgcoquille,mgcoq);
1862     // }
1863 francois 283 }
1864 francois 881
1865 francois 283 #ifdef BREP_STEP
1866     if (entite=="SURFACE_STEP")
1867     {
1868     parse.decode(data.c_str(),"@",param+2);
1869     long idstepsuf=atol(param[2].argument[0].c_str());
1870 couturad 740 ST_SURFACE *stsurf=mggeo->get_gest_step().lst_surface.getid(idstepsuf);
1871 francois 283 STEP_SURFACE* stepsurf=new STEP_SURFACE(id,stsurf);
1872     mggeo->ajouter_mg_surface(stepsurf);
1873     }
1874     if (entite=="COURBE_STEP")
1875     {
1876     parse.decode(data.c_str(),"@",param+2);
1877     long idstepcur=atol(param[2].argument[0].c_str());
1878 couturad 740 ST_COURBE *stcur=mggeo->get_gest_step().lst_courbe.getid(idstepcur);
1879 francois 283 STEP_COURBE* stepcur=new STEP_COURBE(id,stcur);
1880     mggeo->ajouter_mg_courbe(stepcur);
1881     }
1882    
1883     if (entite=="POINT_STEP")
1884     {
1885     parse.decode(data.c_str(),"@",param+2);
1886     long idsteppt=atol(param[2].argument[0].c_str());
1887 couturad 740 ST_POINT *stpt=mggeo->get_gest_step().lst_point.getid(idsteppt);
1888 francois 283 STEP_POINT* steppt=new STEP_POINT(id,stpt);
1889     mggeo->ajouter_mg_point(steppt);
1890     }
1891    
1892     #endif
1893     #ifdef BREP_SAT
1894     if (entite=="SURFACE_SAT")
1895     {
1896     parse.decode(data.c_str(),"@",param+2);
1897     long idsatsuf=atol(param[2].argument[0].c_str());
1898 couturad 740 SAT_SURFACE *satsurf=mggeo->get_gest_sat().lst_surface.getid(idsatsuf);
1899 francois 283 ACIS_SURFACE* acissurf=new ACIS_SURFACE(id,satsurf);
1900     mggeo->ajouter_mg_surface(acissurf);
1901     }
1902     if (entite=="COURBE_SAT")
1903     {
1904     parse.decode(data.c_str(),"@",param+2);
1905     long idsatcur=atol(param[2].argument[0].c_str());
1906 couturad 740 SAT_COURBE *satcur=mggeo->get_gest_sat().lst_courbe.getid(idsatcur);
1907 francois 283 ACIS_COURBE* aciscur=new ACIS_COURBE(id,satcur);
1908     mggeo->ajouter_mg_courbe(aciscur);
1909     }
1910    
1911     if (entite=="POINT_SAT")
1912     {
1913     parse.decode(data.c_str(),"@",param+2);
1914     long idsatpt=atol(param[2].argument[0].c_str());
1915 couturad 740 SAT_POINT *satpt=mggeo->get_gest_sat().lst_point.getid(idsatpt);
1916 francois 283 ACIS_POINT* acispt=new ACIS_POINT(id,satpt);
1917     mggeo->ajouter_mg_point(acispt);
1918     }
1919    
1920     #endif
1921    
1922 couturad 908 #ifdef ALL_OCC
1923 francois 283
1924     if (entite=="SURFACE_OCC")
1925     {
1926     parse.decode(data.c_str(),"@",param+2);
1927     long idocc=atol(param[2].argument[0].c_str());
1928 couturad 906 TopoDS_Face occface;
1929     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
1930     {
1931     OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1932     occface=occ_fonction_2017->get_TopoDS_Face_id(idocc);
1933     }
1934     else
1935     {
1936     const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
1937     occface=TopoDS::Face(occshape);
1938     }
1939     OCC_SURFACE* occsurf=new OCC_SURFACE(id,occface,&mggeo->get_occ_fonction());
1940     occsurf->change_idoriginal(std::to_string(idocc));
1941 francois 283 mggeo->ajouter_mg_surface(occsurf);
1942     }
1943     if (entite=="COURBE_OCC")
1944     {
1945     parse.decode(data.c_str(),"@",param+2);
1946     long idocc=atol(param[2].argument[0].c_str());
1947 couturad 906 TopoDS_Edge occedge;
1948     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
1949     {
1950     OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1951     occedge=occ_fonction_2017->get_TopoDS_Edge_id(idocc);
1952     }
1953     else
1954     {
1955     const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
1956     occedge=TopoDS::Edge(occshape);
1957     }
1958     OCC_COURBE* occcrb=new OCC_COURBE(id,occedge, &mggeo->get_occ_fonction());
1959 francois 283 mggeo->ajouter_mg_courbe(occcrb);
1960 couturad 906 occcrb->change_idoriginal(std::to_string(idocc));
1961 francois 283 }
1962     if (entite=="POINT_OCC")
1963     {
1964     parse.decode(data.c_str(),"@",param+2);
1965     long idocc=atol(param[2].argument[0].c_str());
1966 couturad 906 TopoDS_Vertex occvertex;
1967     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
1968     {
1969     OCC_FONCTION_V2017* occ_fonction_2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
1970     occvertex = occ_fonction_2017->get_TopoDS_Vertex_id(idocc);
1971     }
1972     else
1973     {
1974     const TopoDS_Shape& occshape=mggeo->get_occ_fonction().GetShape(idocc);
1975     occvertex=TopoDS::Vertex(occshape);
1976     }
1977    
1978     OCC_POINT* occpoint=new OCC_POINT(id,occvertex, &mggeo->get_occ_fonction());
1979 francois 283 mggeo->ajouter_mg_point(occpoint);
1980 couturad 906 occpoint->change_idoriginal((std::to_string(idocc)));
1981 francois 283 }
1982     #endif
1983     #ifdef WINDOWS_VERSION
1984     if (entite=="CAD4FE_POLYCURVE")
1985     {
1986     CAD4FE::PolyCurve * polycurve = NULL;
1987     parse.decode(data.c_str(),"@,(&)",param+2);
1988     int nb = atoi(param[2].argument[0].c_str());
1989    
1990     if (nb == 0)
1991     {
1992     printf("PolyCurve %d is formed with reference vertex : ", id);
1993     parse.decode(param[3].argument[0].c_str(),"@",param+4);
1994     int idRefVertex;
1995     idRefVertex=cid(param[4].argument[0].c_str());
1996     printf("%d ;\n ", idRefVertex);
1997     MG_SOMMET * refVertex = mggeo->get_mg_sommetid(idRefVertex);
1998     polycurve = new CAD4FE::PolyCurve(refVertex);
1999     }
2000     else
2001     {
2002     printf("PolyCurve %d is formed with reference edges : ", id);
2003     polycurve = new CAD4FE::PolyCurve;
2004     for (int i=0;i<nb;i++)
2005     {
2006     parse.decode(param[3].argument[i].c_str(),"@",param+4);
2007     int idRefEdge;
2008     idRefEdge=cid(param[4].argument[0].c_str());
2009     printf("%d ; ", idRefEdge);
2010     MG_ARETE * refEdge = mggeo->get_mg_areteid(idRefEdge);
2011     CAD4FE::PolyCurve tmpPC(refEdge);
2012     polycurve->Merge(tmpPC);
2013     }
2014     printf("\n");
2015     }
2016    
2017     polycurve->change_id(id);
2018     mggeo->ajouter_mg_courbe(polycurve);
2019     }
2020    
2021    
2022     if (entite=="CAD4FE_POLYSURFACE")
2023     {
2024     CAD4FE::PolySurface * polysurface = new CAD4FE::PolySurface;
2025     polysurface->change_id(id);
2026     mggeo->ajouter_mg_surface(polysurface);
2027    
2028     parse.decode(data.c_str(),"@,(&)",param+2);
2029    
2030     int nb = atoi(param[2].argument[0].c_str());
2031     printf("PolySurface %d is formed with reference faces : ", id);
2032     for (int i=0;i<nb;i++)
2033     {
2034     parse.decode(param[3].argument[i].c_str(),"@",param+4);
2035     int idRefFace;
2036     idRefFace=cid(param[4].argument[0].c_str());
2037     printf("%d ; ", idRefFace);
2038    
2039     MG_FACE * refFace = mggeo->get_mg_faceid(idRefFace);
2040     CAD4FE::PolySurface tmpSF(refFace);
2041     polysurface->Merge(tmpSF);
2042     }
2043    
2044     printf("\n");
2045     }
2046     if (entite=="CAD4FE_MCEDGE")
2047     {
2048     parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
2049    
2050     std::string idOriginal = param[2].argument[0];
2051     long idPolyCurve=cid(param[3].argument[0]);
2052     CAD4FE::PolyCurve * polycurve = (CAD4FE::PolyCurve *) mggeo->get_mg_courbeid(idPolyCurve);
2053    
2054     // sense is not used because a MCEdge always has
2055     // a sense = 1 !
2056     // (because polycurve domain is equal to mcEdge domain)
2057     CAD4FE::MCEdge * mcEdge = new CAD4FE::MCEdge(idOriginal, polycurve);
2058     mcEdge->change_id(id);
2059     mggeo->ajouter_mg_arete(mcEdge);
2060    
2061     int nb=atoi(param[7].argument[0].c_str());
2062     if (nb!=0)
2063     {
2064     for (int i=0;i<nb;i++)
2065     {
2066     parse.decode(param[8].argument[i].c_str(),"(@,@)",param+9);
2067     char nom[3];
2068     double val;
2069     strcpy(nom,param[9].argument[0].c_str());
2070     val=atof(param[10].argument[0].c_str());
2071     mcEdge->ajouter_ccf(nom,val);
2072     }
2073     }
2074     }
2075     if (entite=="CAD4FE_MCFACE")
2076     {
2077     parse.decode(data.c_str(),"@,@,@,@,@,(&)",param+2);
2078    
2079     std::string idOriginal = param[2].argument[0];
2080     long idPolySurface=cid(param[3].argument[0]);
2081     CAD4FE::PolySurface * polysurface = (CAD4FE::PolySurface *) mggeo->get_mg_surfaceid(idPolySurface);
2082    
2083     CAD4FE::MCFace * mcFace = new CAD4FE::MCFace(idOriginal, polysurface);
2084     mcFace->change_id(id);
2085     mggeo->ajouter_mg_face(mcFace);
2086    
2087     int nb=atoi(param[6].argument[0].c_str());
2088     if (nb!=0)
2089     {
2090     for (int i=0;i<nb;i++)
2091     {
2092     parse.decode(param[7].argument[i].c_str(),"(@,@)",param+8);
2093     char nom[3];
2094     double val;
2095     strcpy(nom,param[8].argument[0].c_str());
2096     val=atof(param[9].argument[0].c_str());
2097     mcFace->ajouter_ccf(nom,val);
2098     }
2099     }
2100     }
2101     if (entite=="CAD4FE_MCVERTEX")
2102     {
2103     parse.decode(data.c_str(),"@,@,@,(&),@,(&)",param+2);
2104     std::string idOriginal = param[2].argument[0];
2105     long idsom=cid(param[3].argument[0]);
2106     MG_SOMMET * mgsom = mggeo->get_mg_sommetid(idsom);
2107     CAD4FE::MCVertex * mcVertex = new CAD4FE::MCVertex(mgsom);
2108     mcVertex->change_id(id);
2109     mggeo->ajouter_mg_sommet(mcVertex);
2110     int nb_ref_vertex=atoi(param[4].argument[0].c_str());
2111     if (nb_ref_vertex!=0)
2112     {
2113     for (int i=0;i<nb_ref_vertex;i++)
2114     {
2115     unsigned long idRefVertex=cid(param[5].argument[i]);
2116     mcVertex->GetMergedRefVertices()[idRefVertex] = NULL;
2117     mapMergedRefVertices.insert(std::make_pair(mcVertex,idRefVertex));
2118     }
2119     }
2120     int nb_ccf=atoi(param[4+2].argument[0].c_str());
2121     if (nb_ccf!=0)
2122     {
2123     for (int i=0;i<nb_ccf;i++)
2124     {
2125     parse.decode(param[5+2].argument[i].c_str(),"(@,@)",param+6+2);
2126     char nom_ccf[3];
2127     double val_ccf;
2128     strcpy(nom_ccf,param[6+2].argument[0].c_str());
2129     val_ccf=atof(param[7+2].argument[0].c_str());
2130     mgsom->ajouter_ccf(nom_ccf,val_ccf);
2131     }
2132     }
2133     }
2134     #endif
2135     if (entite=="FACE")
2136     {
2137 couturad 906 lire_MG_FACE(id,parse,param,data,mggeo);
2138     // if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,(@),@,@,(&)",param+2);
2139     // else parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
2140     // long idsurf=cid(param[3].argument[0]);
2141     // int sens=atoi(param[5].argument[0].c_str());
2142     // MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
2143     // MG_FACE* mgface=new MG_FACE(param[2].argument[0],id,mgsurf,sens);
2144     // mggeo->ajouter_mg_face(mgface);
2145     // int argccf=7;
2146     // if (version_fichier>2.1)
2147     // {
2148     // argccf=8;
2149     // int nbpole=atoi(param[6].argument[0].c_str());
2150     // mgface->change_nb_pole(nbpole);
2151     // }
2152     // int nb=atoi(param[argccf-1].argument[0].c_str());
2153     // if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgface);
2154 francois 763 /*if (nb!=0)
2155 francois 283 {
2156     for (int i=0;i<nb;i++)
2157     {
2158     parse.decode(param[7].argument[i].c_str(),"(@,@)",param+8);
2159     char nom[3];
2160     double val;
2161     strcpy(nom,param[8].argument[0].c_str());
2162     val=atof(param[9].argument[0].c_str());
2163     mgface->ajouter_ccf(nom,val);
2164     }
2165 francois 763 }*/
2166 francois 283 }
2167     if (entite=="COFACE")
2168     {
2169     parse.decode(data.c_str(),"@,@,@",param+2);
2170     long idface=cid(param[2].argument[0]);
2171     long idcoq=cid(param[3].argument[0]);
2172     int sens=atoi(param[4].argument[0].c_str());
2173     MG_FACE* mgface=mggeo->get_mg_faceid(idface);
2174     MG_COQUILLE* mgcoq=mggeo->get_mg_coquilleid(idcoq);
2175     MG_COFACE* mgcoface=mggeo->ajouter_mg_coface(id,mgface,mgcoq,sens);
2176     mgcoq->ajouter_mg_coface(mgcoface);
2177     }
2178     if (entite=="BOUCLE")
2179     {
2180 couturad 906 lire_MG_BOUCLE(id,parse,param,data,mggeo);
2181     // parse.decode(data.c_str(),"@,(@)",param+2);
2182     // long ident=cid(param[2].argument[0]);
2183     // MG_FACE* mgface=mggeo->get_mg_faceid(ident);
2184     // MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
2185     // if (mgface!=NULL)
2186     // {
2187     // MG_BOUCLE* mgbou=new MG_BOUCLE(id,mgface);
2188     // mggeo->ajouter_mg_boucle(mgbou,mgface);
2189     // }
2190     // if (mgpoutre!=NULL)
2191     // {
2192     // MG_BOUCLE* mgbou=new MG_BOUCLE(id,mgpoutre);
2193     // mggeo->ajouter_mg_boucle(mgbou,mgpoutre);
2194     // }
2195 francois 283 }
2196     if (entite=="POINT")
2197     {
2198     parse.decode(data.c_str(),"@,@,@",param+2);
2199     double xyz[3];
2200     xyz[0]=atof(param[2].argument[0].c_str());
2201     xyz[1]=atof(param[3].argument[0].c_str());
2202     xyz[2]=atof(param[4].argument[0].c_str());
2203     LC_POINT* point=new LC_POINT(id,xyz);
2204     mggeo->ajouter_mg_point(point);
2205     }
2206     if (entite=="SOMMET")
2207     {
2208 couturad 906 lire_MG_SOMMET(id,parse,param,data,mggeo);
2209     // if (version_fichier<2.2) parse.decode(data.c_str(),"@,@,@,(&)",param+2);
2210     // else parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
2211     // long idpoint=cid(param[3].argument[0]);
2212     // MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
2213     // MG_SOMMET* mgsom=new MG_SOMMET(param[2].argument[0],id,mgpt);
2214     // mggeo->ajouter_mg_sommet(mgsom);
2215     // int argccf=5;
2216     // if (version_fichier>2.1)
2217     // {
2218     // argccf=6;
2219     // int ipole=atoi(param[4].argument[0].c_str());
2220     // if (ipole==1) mgsom->change_pole(true);
2221     // }
2222     // int nb=atoi(param[argccf-1].argument[0].c_str());
2223     // if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,mgsom);
2224     // /*if (nb!=0)
2225     // {
2226     // for (int i=0;i<nb;i++)
2227     // {
2228     // parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2229     // char nom[3];
2230     // double val;
2231     // strcpy(nom,param[6].argument[0].c_str());
2232     // val=atof(param[7].argument[0].c_str());
2233     // mgsom->ajouter_ccf(nom,val);
2234     // }
2235     // }*/
2236     }
2237 couturad 908 #ifdef ALL_OCC
2238 couturad 906 if (entite=="OCC_SOMMET")
2239     {
2240     parse.decode(data.c_str(),"@,@,@,@,(&)",param+2);
2241 francois 283 long idpoint=cid(param[3].argument[0]);
2242     MG_POINT* mgpt=mggeo->get_mg_pointid(idpoint);
2243 couturad 906 TopoDS_Vertex topods_vertex;
2244     long idori = stol(param[2].argument[0]);
2245     OCC_SOMMET* occ_sommet;
2246     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2247     {
2248     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2249     topods_vertex=occ_fonction_v2017->get_TopoDS_Vertex_id(idori);
2250     occ_sommet = new OCC_SOMMET(param[2].argument[0],id,mgpt,topods_vertex,&mggeo->get_occ_fonction());
2251     mggeo->ajouter_mg_sommet(occ_sommet);
2252     occ_fonction_v2017->ajouter_OCC_SOMMET(occ_sommet);
2253     }
2254     else
2255     {
2256     std::cout << "*** MG_FILE : ERREUR lecture OCC_SOMMET : Mauvaise OCC_FONCTION ! ***" << std::endl;
2257     }
2258     int argccf=5;
2259 couturad 814 if (version_fichier>2.1)
2260     {
2261     argccf=6;
2262     int ipole=atoi(param[4].argument[0].c_str());
2263 couturad 906 if (ipole==1) occ_sommet->change_pole(true);
2264 couturad 814 }
2265     int nb=atoi(param[argccf-1].argument[0].c_str());
2266 couturad 906 if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,occ_sommet);
2267 francois 283 }
2268 couturad 906 if (entite=="OCC_ARETE")
2269     {
2270     parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
2271     long idcur=cid(param[3].argument[0]);
2272     int sens=atol(param[6].argument[0].c_str());
2273     long idori = stoi(param[2].argument[0]);
2274     TopoDS_Edge topods_edge;
2275     OCC_ARETE* occ_arete;
2276     MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
2277     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2278     {
2279     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2280     topods_edge=occ_fonction_v2017->get_TopoDS_Edge_id(idori);
2281     occ_arete= new OCC_ARETE(param[2].argument[0],id,mgcur,sens,topods_edge,&mggeo->get_occ_fonction());
2282     mggeo->ajouter_mg_arete(occ_arete);
2283     occ_fonction_v2017->ajouter_OCC_ARETE(occ_arete);
2284     }
2285     else
2286     {
2287     std::cout << "*** MG_FILE : ERREUR lecture OCC_ARETE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2288     }
2289     int nb=atoi(param[7].argument[0].c_str());
2290     if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,occ_arete);
2291     }
2292     if (entite=="OCC_BOUCLE")
2293     {
2294     parse.decode(data.c_str(),"@,@,(@)",param+2);
2295     long ident=cid(param[2].argument[0]);
2296     long idori=stol(param[3].argument[0]);
2297     TopoDS_Wire topods_wire;
2298     OCC_BOUCLE* occ_boucle;
2299     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2300     {
2301     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2302     topods_wire=occ_fonction_v2017->get_TopoDS_Wire_id(idori);
2303     if(ident!=-1)
2304     {
2305     MG_FACE* mgface=mggeo->get_mg_faceid(ident);
2306     MG_POUTRE* mgpoutre=mggeo->get_mg_poutreid(ident);
2307     if (mgface!=NULL)
2308     {
2309     OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,mgface,topods_wire,&mggeo->get_occ_fonction());
2310     mggeo->ajouter_mg_boucle(occ_boucle,mgface);
2311     occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
2312     }
2313     if (mgpoutre!=NULL)
2314     {
2315     OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,mgpoutre,topods_wire,&mggeo->get_occ_fonction());
2316     mggeo->ajouter_mg_boucle(occ_boucle,mgpoutre);
2317     occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
2318     }
2319     }
2320     else
2321     {
2322     OCC_BOUCLE* occ_boucle=new OCC_BOUCLE(param[3].argument[0],id,topods_wire,&mggeo->get_occ_fonction());
2323     mggeo->ajouter_mg_boucle(occ_boucle);
2324     occ_fonction_v2017->ajouter_OCC_BOUCLE(occ_boucle);
2325     }
2326     }
2327     else
2328     {
2329     std::cout << "*** MG_FILE : ERREUR lecture OCC_BOUCLE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2330     }
2331    
2332     }
2333     if (entite=="OCC_FACE")
2334     {
2335     parse.decode(data.c_str(),"@,@,(@),@,@,@,(&)",param+2);
2336     long idsurf=cid(param[3].argument[0]);
2337     int sens=atoi(param[5].argument[0].c_str());
2338     long idori = stol(param[2].argument[0]);
2339     TopoDS_Face topods_face;
2340     OCC_FACE* occ_face;
2341     MG_SURFACE* mgsurf=mggeo->get_mg_surfaceid(idsurf);
2342     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2343     {
2344     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2345     topods_face=occ_fonction_v2017->get_TopoDS_Face_id(idori);
2346     occ_face = new OCC_FACE(param[2].argument[0],id,mgsurf,sens,topods_face,&mggeo->get_occ_fonction());
2347     mggeo->ajouter_mg_face(occ_face);
2348     occ_fonction_v2017->ajouter_OCC_FACE(occ_face);
2349     }
2350     else
2351     {
2352     std::cout << "*** MG_FILE : ERREUR lecture OCC_FACE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2353     }
2354     int argccf=7;
2355     if (version_fichier>2.1)
2356     {
2357     argccf=8;
2358     int nbpole=atoi(param[6].argument[0].c_str());
2359     occ_face->change_nb_pole(nbpole);
2360     }
2361     int nb=atoi(param[argccf-1].argument[0].c_str());
2362     if (nb!=0) lire_ccf(version_fichier,nb,argccf,parse,param,occ_face);
2363     }
2364     if (entite=="OCC_COQUILLE")
2365     {
2366     parse.decode(data.c_str(),"@,@,@",param+2);
2367     long ident=cid(param[2].argument[0]);
2368     long idori = stol(param[3].argument[0]);
2369     TopoDS_Shell topods_shell;
2370     OCC_COQUILLE* occ_coquille;
2371     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2372     {
2373     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2374     topods_shell=occ_fonction_v2017->get_TopoDS_Shell_id(idori);
2375     if(idori!=-1)
2376     {
2377     MG_VOLUME* mgvol=mggeo->get_mg_volumeid(ident);
2378     MG_COQUE* mgcoq=mggeo->get_mg_coqueid(ident);
2379     if (mgvol!=NULL)
2380     {
2381     OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgvol,topods_shell,&mggeo->get_occ_fonction());
2382     mggeo->ajouter_mg_coquille(occ_coquille,mgvol);
2383     occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
2384     }
2385     if (mgcoq!=NULL)
2386     {
2387     OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,mgcoq,topods_shell,&mggeo->get_occ_fonction());
2388     mggeo->ajouter_mg_coquille(occ_coquille,mgcoq);
2389     occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
2390     }
2391     }
2392     else
2393     {
2394     OCC_COQUILLE* occ_coquille = new OCC_COQUILLE(param[3].argument[0],id,topods_shell,&mggeo->get_occ_fonction());
2395     mggeo->ajouter_mg_coquille(occ_coquille);
2396     occ_fonction_v2017->ajouter_OCC_COQUILLE(occ_coquille);
2397     }
2398     }
2399     else
2400     {
2401     std::cout << "*** MG_FILE : ERREUR lecture OCC_COQUILLE : Mauvaise OCC_FONCTION ! ***" << std::endl;
2402     }
2403     }
2404     if (entite=="OCC_VOLUME")
2405     {
2406    
2407     parse.decode(data.c_str(),"@,@,@,@",param+2);
2408     long idori = stol(param[2].argument[0]);
2409     TopoDS_Solid topods_solid;
2410     OCC_VOLUME* occ_volume;
2411     if(mggeo->get_occ_fonction().get_version()=="OCCV2017")
2412     {
2413     OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)&mggeo->get_occ_fonction();
2414     topods_solid=occ_fonction_v2017->get_TopoDS_Solid_id(idori);
2415     occ_volume = new OCC_VOLUME(param[2].argument[0],id,topods_solid,&mggeo->get_occ_fonction());
2416     mggeo->ajouter_mg_volume(occ_volume);
2417     occ_fonction_v2017->ajouter_OCC_VOLUME(occ_volume);
2418     }
2419     else
2420     {
2421     std::cout << "*** MG_FILE : ERREUR lecture OCC_VOLUME : Mauvaise OCC_FONCTION ! ***" << std::endl;
2422     }
2423     int mince=atoi(param[4].argument[0].c_str());
2424     if (mince==0)
2425     {
2426     std::string data2=param[5].argument[0];
2427     parse.decode(data2.c_str(),"@,(&)",param+5);
2428     int nb=atoi(param[5].argument[0].c_str());
2429     if (nb!=0) lire_ccf(version_fichier,nb,6,parse,param,occ_volume);
2430     }
2431     else
2432     {
2433     std::string data2=param[5].argument[0];
2434     parse.decode(data2.c_str(),"(&),@,(&)",param+5);
2435     int nb_face=param[5].argument.size();
2436     for (int i=0;i<nb_face;i=i+2)
2437     {
2438     unsigned long idn1=cid(param[5].argument[i]);
2439     unsigned long idn2=cid(param[5].argument[i+1]);
2440     volumemince.push_back(id);
2441     volumemince.push_back(idn1);
2442     volumemince.push_back(idn2);
2443     }
2444     int nb=atoi(param[6].argument[0].c_str());
2445     if (nb!=0) lire_ccf(version_fichier,nb,7,parse,param,occ_volume);
2446     }
2447     }
2448    
2449    
2450     #endif
2451 francois 576 if (entite=="ARETE_ELEMENT")
2452     {
2453     parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2454     MG_ARETE_ELEMENT* are=new MG_ARETE_ELEMENT(id);
2455     mggeo->ajouter_mg_arete(are);
2456     int nb=atoi(param[4].argument[0].c_str());
2457 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,are);
2458     /* if (nb!=0)
2459 francois 576 {
2460     for (int i=0;i<nb;i++)
2461     {
2462     parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2463     char nom[3];
2464     double val;
2465     strcpy(nom,param[6].argument[0].c_str());
2466     val=atof(param[7].argument[0].c_str());
2467     are->ajouter_ccf(nom,val);
2468     }
2469 francois 763 }*/
2470 francois 576 }
2471     if (entite=="FACE_ELEMENT")
2472     {
2473     parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2474     MG_FACE_ELEMENT* face=new MG_FACE_ELEMENT(id);
2475     mggeo->ajouter_mg_face(face);
2476     int nb=atoi(param[4].argument[0].c_str());
2477 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,face);
2478     /*if (nb!=0)
2479 francois 576 {
2480     for (int i=0;i<nb;i++)
2481     {
2482     parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2483     char nom[3];
2484     double val;
2485     strcpy(nom,param[6].argument[0].c_str());
2486     val=atof(param[7].argument[0].c_str());
2487     face->ajouter_ccf(nom,val);
2488     }
2489 francois 763 }*/
2490 francois 576 }
2491 francois 685 if (entite=="COQUE_ELEMENT")
2492     {
2493     parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2494     MG_COQUE_ELEMENT* coq=new MG_COQUE_ELEMENT(id);
2495     mggeo->ajouter_mg_coque(coq);
2496     int nbele=atoi(param[2].argument[0].c_str());
2497     for (int i=0;i<nbele;i++)
2498     {
2499     unsigned long idele=cid(param[3].argument[i].c_str());
2500     coq->ajouter_element(idele);
2501     }
2502     int nb=atoi(param[4].argument[0].c_str());
2503 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,coq);
2504     /* if (nb!=0)
2505 francois 685 {
2506     for (int i=0;i<nb;i++)
2507     {
2508     parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2509     char nom[3];
2510     double val;
2511     strcpy(nom,param[6].argument[0].c_str());
2512     val=atof(param[7].argument[0].c_str());
2513     coq->ajouter_ccf(nom,val);
2514     }
2515 francois 763 }*/
2516 francois 685 }
2517 francois 753 if (entite=="POUTRE_ELEMENT")
2518 francois 576 {
2519     parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2520 francois 753 MG_POUTRE_ELEMENT* pou=new MG_POUTRE_ELEMENT(id);
2521     mggeo->ajouter_mg_poutre(pou);
2522     int nbele=atoi(param[2].argument[0].c_str());
2523     for (int i=0;i<nbele;i++)
2524     {
2525     unsigned long idele=cid(param[3].argument[i].c_str());
2526     pou->ajouter_element(idele);
2527     }
2528     int nb=atoi(param[4].argument[0].c_str());
2529 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,pou);
2530     /*if (nb!=0)
2531 francois 753 {
2532     for (int i=0;i<nb;i++)
2533     {
2534     parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2535     char nom[3];
2536     double val;
2537     strcpy(nom,param[6].argument[0].c_str());
2538     val=atof(param[7].argument[0].c_str());
2539     pou->ajouter_ccf(nom,val);
2540     }
2541 francois 763 }*/
2542 francois 753 }
2543     if (entite=="VOLUME_ELEMENT")
2544     {
2545     parse.decode(data.c_str(),"@,(&),@,(&)",param+2);
2546 francois 576 MG_VOLUME_ELEMENT* vol=new MG_VOLUME_ELEMENT(id);
2547     mggeo->ajouter_mg_volume(vol);
2548     int nb=atoi(param[4].argument[0].c_str());
2549 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,5,parse,param,vol);
2550     /* if (nb!=0)
2551 francois 576 {
2552     for (int i=0;i<nb;i++)
2553     {
2554     parse.decode(param[5].argument[i].c_str(),"(@,@)",param+6);
2555     char nom[3];
2556     double val;
2557     strcpy(nom,param[6].argument[0].c_str());
2558     val=atof(param[7].argument[0].c_str());
2559     vol->ajouter_ccf(nom,val);
2560     }
2561 francois 763 }*/
2562 francois 576 }
2563 francois 526 if (entite=="SOMMET_NOEUD")
2564     {
2565     parse.decode(data.c_str(),"@,@,(&)",param+2);
2566     long idnoeud=cid(param[2].argument[0]);
2567     MG_SOMMET_NOEUD* mgsom=new MG_SOMMET_NOEUD(id,idnoeud);
2568     mggeo->ajouter_mg_sommet(mgsom);
2569     int nb=atoi(param[3].argument[0].c_str());
2570 francois 763 if (nb!=0) lire_ccf(version_fichier,nb,4,parse,param,mgsom);
2571     /*if (nb!=0)
2572 francois 526 {
2573     for (int i=0;i<nb;i++)
2574     {
2575     parse.decode(param[4].argument[i].c_str(),"(@,@)",param+5);
2576     char nom[3];
2577     double val;
2578     strcpy(nom,param[5].argument[0].c_str());
2579     val=atof(param[6].argument[0].c_str());
2580     mgsom->ajouter_ccf(nom,val);
2581     }
2582 francois 763 }*/
2583 francois 526 }
2584 francois 283 if (entite=="ARETE")
2585     {
2586 couturad 906 lire_MG_ARETE(id,parse,param,data,mggeo);
2587     // parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
2588     // long idcur=cid(param[3].argument[0]);
2589     // int sens=atoi(param[6].argument[0].c_str());
2590     // MG_COURBE* mgcur=mggeo->get_mg_courbeid(idcur);
2591     // MG_ARETE* mgarete=new MG_ARETE(param[2].argument[0],id,mgcur,sens);
2592     // mggeo->ajouter_mg_arete(mgarete);
2593     // int nb=atoi(param[7].argument[0].c_str());
2594     // if (nb!=0) lire_ccf(version_fichier,nb,8,parse,param,mgarete);
2595     // /*if (nb!=0)
2596     // {
2597     // for (int i=0;i<nb;i++)
2598     // {
2599     // parse.decode(param[8].argument[i].c_str(),"(@,@)",param+9);
2600     // char nom[3];
2601     // double val;
2602     // strcpy(nom,param[9].argument[0].c_str());
2603     // val=atof(param[10].argument[0].c_str());
2604     // mgarete->ajouter_ccf(nom,val);
2605     // }
2606     // }*/
2607 francois 283 }
2608     if (entite=="COSOMMET")
2609     {
2610     parse.decode(data.c_str(),"@,@,@",param+2);
2611     long idsom=cid(param[2].argument[0]);
2612     long idarete=cid(param[3].argument[0]);
2613     int num=atoi(param[4].argument[0].c_str());
2614     MG_SOMMET* mgsom=mggeo->get_mg_sommetid(idsom);
2615     MG_ARETE* mgarete=mggeo->get_mg_areteid(idarete);
2616     MG_COSOMMET* mgcosom=mggeo->ajouter_mg_cosommet(id,mgarete,mgsom);
2617     if (num==1) mgarete->changer_cosommet1(mgcosom);
2618     if (num==2) mgarete->changer_cosommet2(mgcosom);
2619     }
2620     if (entite=="COARETE")
2621     {
2622     parse.decode(data.c_str(),"@,@,@",param+2);
2623     long idarete=cid(param[2].argument[0]);
2624     long idboucle=cid(param[3].argument[0]);
2625     int sens=atoi(param[4].argument[0].c_str());
2626     MG_ARETE* mgarete=mggeo->get_mg_areteid(idarete);
2627     MG_BOUCLE* mgboucle=mggeo->get_mg_boucleid(idboucle);
2628     MG_COARETE* mgcoarete=mggeo->ajouter_mg_coarete(id,mgarete,mgboucle,sens);
2629     mgboucle->ajouter_mg_coarete(mgcoarete);
2630     }
2631     if (entite=="VISU_COURBE")
2632     {
2633     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
2634     double xyz1[3];
2635     double xyz2[3];
2636     xyz1[0]=atof(param[2].argument[0].c_str());
2637     xyz1[1]=atof(param[3].argument[0].c_str());
2638     xyz1[2]=atof(param[4].argument[0].c_str());
2639     xyz2[0]=atof(param[5].argument[0].c_str());
2640     xyz2[1]=atof(param[6].argument[0].c_str());
2641     xyz2[2]=atof(param[7].argument[0].c_str());
2642     MG_VISU_COURBE* mgcrb=new MG_VISU_COURBE(id,xyz1,xyz2);
2643     mggeo->ajouter_mg_visu_courbe(mgcrb);
2644     }
2645     if (entite=="MAILLAGE")
2646     {
2647     parse.decode(data.c_str(),"@",param+2);
2648     long idgeo=cid(param[2].argument[0]);
2649 francois 626 mggeo=get_mg_geometrieid(idgeo);
2650 couturad 920 if(mggeo==NULL) mggeo=get_mg_constructionid(idgeo);
2651 francois 283 mgmai=new MG_MAILLAGE(id,mggeo);
2652     ajouter_mg_maillage(mgmai);
2653     }
2654 francois 465 if (entite=="MAILLAGE_STRUCTURE")
2655     {
2656     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
2657     long idgeo=cid(param[2].argument[0]);
2658 francois 626 mggeo=get_mg_geometrieid(idgeo);
2659 francois 465 mgmai=new MG_MAILLAGE(id,mggeo);
2660     ajouter_mg_maillage(mgmai);
2661     double xmin=atof(param[3].argument[0].c_str());
2662     double ymin=atof(param[4].argument[0].c_str());
2663     double zmin=atof(param[5].argument[0].c_str());
2664     double xmax=atof(param[6].argument[0].c_str());
2665     double ymax=atof(param[7].argument[0].c_str());
2666     double zmax=atof(param[8].argument[0].c_str());
2667     int nx=atoi(param[9].argument[0].c_str());
2668     int ny=atoi(param[10].argument[0].c_str());
2669     int nz=atoi(param[11].argument[0].c_str());
2670     BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
2671     mgmai->change_param_structure(b,nx,ny,nz);
2672     }
2673 francois 283 if (entite=="FEM_MAILLAGE")
2674     {
2675     parse.decode(data.c_str(),"@,@,@",param+2);
2676     int degre=atoi(param[2].argument[0].c_str());
2677     long idmai=cid(param[3].argument[0]);
2678     long idgeo=cid(param[4].argument[0]);
2679 francois 626 mggeo=get_mg_geometrieid(idgeo);
2680     mgmai=get_mg_maillageid(idmai);
2681 francois 283 femmai=new FEM_MAILLAGE(id,mggeo,mgmai,degre);
2682     ajouter_fem_maillage(femmai);
2683     }
2684 francois 465 if (entite=="FEM_MAILLAGE_STRUCTURE")
2685     {
2686     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
2687     int degre=atoi(param[2].argument[0].c_str());
2688     long idmai=cid(param[3].argument[0]);
2689     long idgeo=cid(param[4].argument[0]);
2690 francois 626 mggeo=get_mg_geometrieid(idgeo);
2691     mgmai=get_mg_maillageid(idmai);
2692 francois 465 femmai=new FEM_MAILLAGE(id,mggeo,mgmai,degre);
2693     ajouter_fem_maillage(femmai);
2694     double xmin=atof(param[5].argument[0].c_str());
2695     double ymin=atof(param[6].argument[0].c_str());
2696     double zmin=atof(param[7].argument[0].c_str());
2697     double xmax=atof(param[8].argument[0].c_str());
2698     double ymax=atof(param[9].argument[0].c_str());
2699     double zmax=atof(param[10].argument[0].c_str());
2700     int nx=atoi(param[11].argument[0].c_str());
2701     int ny=atoi(param[12].argument[0].c_str());
2702     int nz=atoi(param[13].argument[0].c_str());
2703     BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
2704     femmai->change_param_structure(b,nx,ny,nz);
2705     }
2706 francois 551 if (entite=="NOEUD") lire_NOEUD(id,parse,param,data,mgmai,mggeo);
2707 francois 283 if (entite=="FEM_NOEUD")
2708     {
2709     parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
2710     long idtopo=cid(param[2].argument[0]);
2711     long idmai=cid(param[3].argument[0]);
2712     double x=atof(param[4].argument[0].c_str());
2713     double y=atof(param[5].argument[0].c_str());
2714     double z=atof(param[6].argument[0].c_str());
2715     int num=atoi(param[7].argument[0].c_str());
2716     int numopt=atoi(param[8].argument[0].c_str());
2717     MG_ELEMENT_MAILLAGE* elmai;
2718     if (idmai>-1)
2719     {
2720     elmai=mgmai->get_mg_noeudid(idmai);
2721     if (elmai==NULL) elmai=mgmai->get_mg_segmentid(idmai);
2722     if (elmai==NULL) elmai=mgmai->get_mg_triangleid(idmai);
2723     if (elmai==NULL) elmai=mgmai->get_mg_tetraid(idmai);
2724     }
2725     else elmai=NULL;
2726     FEM_NOEUD* noeud;
2727     if (elmai!=NULL) noeud=new FEM_NOEUD(id,elmai,x,y,z);
2728     else
2729     {
2730     MG_ELEMENT_TOPOLOGIQUE* topo;
2731     if (idtopo>-1)
2732     {
2733     topo=mggeo->get_mg_sommetid(idtopo);
2734     if (topo==NULL) topo=mggeo->get_mg_areteid(idtopo);
2735     if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
2736     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
2737     }
2738     else topo=NULL;
2739     noeud=new FEM_NOEUD(id,topo,x,y,z);
2740     }
2741     noeud->change_numero(num);
2742     noeud->change_numero_opt(numopt);
2743     femmai->ajouter_fem_noeud(noeud);
2744     }
2745     if (entite=="FEM_NOEUD_DEF")
2746     {
2747     parse.decode(data.c_str(),"@,@,@",param+2);
2748     double x=atof(param[2].argument[0].c_str());
2749     double y=atof(param[3].argument[0].c_str());
2750     double z=atof(param[4].argument[0].c_str());
2751     FEM_NOEUD* noeud=femmai->get_fem_noeudid(id);
2752     noeud->change_dx(x);
2753     noeud->change_dy(y);
2754     noeud->change_dz(z);
2755     femmai->active_deforme();
2756     }
2757 francois 325 if (entite=="FEM_NOEUD_REAC")
2758     {
2759     parse.decode(data.c_str(),"@,@,@",param+2);
2760     double x=atof(param[2].argument[0].c_str());
2761     double y=atof(param[3].argument[0].c_str());
2762     double z=atof(param[4].argument[0].c_str());
2763     FEM_NOEUD* noeud=femmai->get_fem_noeudid(id);
2764     noeud->change_rx(x);
2765     noeud->change_ry(y);
2766     noeud->change_rz(z);
2767 francois 339 femmai->active_reaction();;
2768 francois 325 }
2769 francois 551 if (entite=="SEGMENT") lire_SEGMENT(id,parse,param,data,mgmai,mggeo);
2770 francois 399 if (entite=="FEM_ELEMENT_NOEUD")
2771     {
2772     parse.decode(data.c_str(),"@,@,@",param+2);
2773     long idtopo=cid(param[2].argument[0]);
2774     long idmai=cid(param[3].argument[0]);
2775     long idn1=cid(param[4].argument[0]);
2776     FEM_NOEUD* tab[1];
2777     tab[0]=femmai->get_fem_noeudid(idn1);
2778     MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2779     if (idtopo>-1)
2780     topo=mggeo->get_mg_sommetid(idtopo);
2781     MG_ELEMENT_MAILLAGE* elmai;
2782     if (idmai>-1)
2783     elmai=mgmai->get_mg_noeudid(idmai);
2784     else elmai=NULL;
2785     FEM_ELEMENT0* fem=new FEM_ELEMENT0(id,topo,elmai,tab);
2786     femmai->ajouter_fem_element0(fem);
2787     }
2788 francois 283 if (entite=="FEM_SEGMENT2")
2789     {
2790     parse.decode(data.c_str(),"@,@,@,@",param+2);
2791 francois 378 long idtopo=cid(param[2].argument[0]);
2792 francois 283 long idmai=cid(param[3].argument[0]);
2793     long idn1=cid(param[4].argument[0]);
2794     long idn2=cid(param[5].argument[0]);
2795     FEM_NOEUD* tab[2];
2796     tab[0]=femmai->get_fem_noeudid(idn1);
2797     tab[1]=femmai->get_fem_noeudid(idn2);
2798 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2799     if (idtopo>-1)
2800     topo=mggeo->get_mg_areteid(idtopo);
2801 francois 767 if (topo==NULL) topo=mggeo->get_mg_poutreid(idtopo);
2802 francois 378 MG_ELEMENT_MAILLAGE* elmai;
2803 francois 283 if (idmai>-1)
2804     elmai=mgmai->get_mg_segmentid(idmai);
2805     else elmai=NULL;
2806 francois 378 FEM_SEGMENT2* seg=new FEM_SEGMENT2(id,topo,elmai,tab);
2807 francois 309 femmai->ajouter_fem_element1(seg);
2808 francois 283 }
2809 francois 767 if (entite=="FEM_MINI_SEGMENT2")
2810     {
2811     parse.decode(data.c_str(),"@,@",param+2);
2812     long idn1=cid(param[2].argument[0]);
2813     long idn2=cid(param[3].argument[0]);
2814     FEM_NOEUD* tab[2];
2815     tab[0]=femmai->get_fem_noeudid(idn1);
2816     tab[1]=femmai->get_fem_noeudid(idn2);
2817     MG_SEGMENT* mseg=femmai->get_mg_maillage()->get_mg_segment(tab[0]->get_mg_element_maillage()->get_id(),tab[1]->get_mg_element_maillage()->get_id());
2818     FEM_MINI_SEGMENT2* seg=new FEM_MINI_SEGMENT2(id,mseg,tab);
2819     femmai->ajouter_fem_element1(seg);
2820     }
2821 francois 283 if (entite=="FEM_SEGMENT3")
2822     {
2823     parse.decode(data.c_str(),"@,@,@,@,@",param+2);
2824 francois 378 long idtopo=cid(param[2].argument[0]);
2825     long idmai=cid(param[3].argument[0]);
2826 francois 283 long idn1=cid(param[4].argument[0]);
2827     long idn2=cid(param[5].argument[0]);
2828     long idn3=cid(param[6].argument[0]);
2829     FEM_NOEUD* tab[3];
2830     tab[0]=femmai->get_fem_noeudid(idn1);
2831     tab[1]=femmai->get_fem_noeudid(idn2);
2832     tab[2]=femmai->get_fem_noeudid(idn3);
2833     MG_ELEMENT_MAILLAGE* elmai;
2834 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2835     if (idtopo>-1)
2836     topo=mggeo->get_mg_areteid(idtopo);
2837     if (idmai>-1)
2838 francois 283 elmai=mgmai->get_mg_segmentid(idmai);
2839     else elmai=NULL;
2840 francois 378 FEM_SEGMENT3* seg=new FEM_SEGMENT3(id,topo,elmai,tab);
2841 francois 309 femmai->ajouter_fem_element1(seg);
2842 francois 283 }
2843 francois 551 if (entite=="TRIANGLE") lire_TRIANGLE(id,parse,param,data,mgmai,mggeo);
2844     if (entite=="QUADRANGLE") lire_QUADRANGLE(id,parse,param,data,mgmai,mggeo);
2845 francois 283 if (entite=="FEM_TRIANGLE3")
2846     {
2847     parse.decode(data.c_str(),"@,@,@,@,@",param+2);
2848 francois 378 long idtopo=cid(param[2].argument[0]);
2849 francois 283 long idmai=cid(param[3].argument[0]);
2850     long idn1=cid(param[4].argument[0]);
2851     long idn2=cid(param[5].argument[0]);
2852     long idn3=cid(param[6].argument[0]);
2853     FEM_NOEUD* tab[3];
2854     tab[0]=femmai->get_fem_noeudid(idn1);
2855     tab[1]=femmai->get_fem_noeudid(idn2);
2856     tab[2]=femmai->get_fem_noeudid(idn3);
2857     MG_ELEMENT_MAILLAGE* elmai;
2858     if (idmai>-1)
2859     elmai=mgmai->get_mg_triangleid(idmai);
2860     else elmai=NULL;
2861 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2862     if (idtopo>-1)
2863 francois 383 topo=mggeo->get_mg_faceid(idtopo);
2864 francois 378 FEM_TRIANGLE3* tri=new FEM_TRIANGLE3(id,topo,elmai,tab);
2865 francois 309 femmai->ajouter_fem_element2(tri);
2866 francois 283 }
2867     if (entite=="FEM_TRIANGLE6")
2868     {
2869     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
2870 francois 378 long idtopo=cid(param[2].argument[0]);
2871 francois 283 long idmai=cid(param[3].argument[0]);
2872     long idn1=cid(param[4].argument[0]);
2873     long idn2=cid(param[5].argument[0]);
2874     long idn3=cid(param[6].argument[0]);
2875     long idn4=cid(param[7].argument[0]);
2876     long idn5=cid(param[8].argument[0]);
2877     long idn6=cid(param[9].argument[0]);
2878     FEM_NOEUD* tab[6];
2879     tab[0]=femmai->get_fem_noeudid(idn1);
2880     tab[1]=femmai->get_fem_noeudid(idn2);
2881     tab[2]=femmai->get_fem_noeudid(idn3);
2882     tab[3]=femmai->get_fem_noeudid(idn4);
2883     tab[4]=femmai->get_fem_noeudid(idn5);
2884     tab[5]=femmai->get_fem_noeudid(idn6);
2885     MG_ELEMENT_MAILLAGE* elmai;
2886     if (idmai>-1)
2887     elmai=mgmai->get_mg_triangleid(idmai);
2888     else elmai=NULL;
2889 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2890     if (idtopo>-1)
2891 francois 383 topo=mggeo->get_mg_faceid(idtopo);
2892 francois 378 FEM_TRIANGLE6* tri=new FEM_TRIANGLE6(id,topo,elmai,tab);
2893 francois 309 femmai->ajouter_fem_element2(tri);
2894 francois 283 }
2895 francois 310 if (entite=="FEM_QUADRANGLE4")
2896     {
2897     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
2898 francois 378 long idtopo=cid(param[2].argument[0]);
2899     long idmai=cid(param[3].argument[0]);
2900 francois 310 long idn1=cid(param[4].argument[0]);
2901     long idn2=cid(param[5].argument[0]);
2902     long idn3=cid(param[6].argument[0]);
2903     long idn4=cid(param[7].argument[0]);
2904     FEM_NOEUD* tab[4];
2905     tab[0]=femmai->get_fem_noeudid(idn1);
2906     tab[1]=femmai->get_fem_noeudid(idn2);
2907     tab[2]=femmai->get_fem_noeudid(idn3);
2908     tab[3]=femmai->get_fem_noeudid(idn4);
2909     MG_ELEMENT_MAILLAGE* elmai;
2910     if (idmai>-1)
2911     elmai=mgmai->get_mg_quadrangleid(idmai);
2912     else elmai=NULL;
2913 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2914     if (idtopo>-1)
2915 francois 383 topo=mggeo->get_mg_faceid(idtopo);
2916 francois 378 FEM_QUADRANGLE4* quad=new FEM_QUADRANGLE4(id,topo,elmai,tab);
2917 francois 310 femmai->ajouter_fem_element2(quad);
2918     }
2919     if (entite=="FEM_QUADRANGLE8")
2920     {
2921     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
2922 francois 378 long idtopo=cid(param[2].argument[0]);
2923     long idmai=cid(param[3].argument[0]);
2924 francois 310 long idn1=cid(param[4].argument[0]);
2925     long idn2=cid(param[5].argument[0]);
2926     long idn3=cid(param[6].argument[0]);
2927     long idn4=cid(param[7].argument[0]);
2928     long idn5=cid(param[8].argument[0]);
2929     long idn6=cid(param[9].argument[0]);
2930     long idn7=cid(param[10].argument[0]);
2931     long idn8=cid(param[11].argument[0]);
2932     FEM_NOEUD* tab[8];
2933     tab[0]=femmai->get_fem_noeudid(idn1);
2934     tab[1]=femmai->get_fem_noeudid(idn2);
2935     tab[2]=femmai->get_fem_noeudid(idn3);
2936     tab[3]=femmai->get_fem_noeudid(idn4);
2937     tab[4]=femmai->get_fem_noeudid(idn5);
2938     tab[5]=femmai->get_fem_noeudid(idn6);
2939     tab[6]=femmai->get_fem_noeudid(idn7);
2940     tab[7]=femmai->get_fem_noeudid(idn8);
2941     MG_ELEMENT_MAILLAGE* elmai;
2942     if (idmai>-1)
2943     elmai=mgmai->get_mg_quadrangleid(idmai);
2944     else elmai=NULL;
2945 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2946     if (idtopo>-1)
2947 francois 383 topo=mggeo->get_mg_faceid(idtopo);
2948 francois 378 FEM_QUADRANGLE8* quad=new FEM_QUADRANGLE8(id,topo,elmai,tab);
2949 francois 310 femmai->ajouter_fem_element2(quad);
2950     }
2951 francois 551 if (entite=="TETRAEDRE") lire_TETRA(id,parse,param,data,mgmai,mggeo);
2952    
2953     if (entite=="HEXAEDRE") lire_HEXA(id,parse,param,data,mgmai,mggeo);
2954 francois 876 if (entite=="PENTAEDRE") lire_PENTA(id,parse,param,data,mgmai,mggeo);
2955 francois 283 if (entite=="FEM_TETRA4")
2956     {
2957 francois 339 parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
2958 francois 378 long idtopo=cid(param[2].argument[0]);
2959     long idmai=cid(param[3].argument[0]);
2960 francois 283 long idn1=cid(param[4].argument[0]);
2961     long idn2=cid(param[5].argument[0]);
2962     long idn3=cid(param[6].argument[0]);
2963     long idn4=cid(param[7].argument[0]);
2964 francois 339 long etat=atoi(param[8].argument[0].c_str());
2965 francois 283 FEM_NOEUD* tab[4];
2966     tab[0]=femmai->get_fem_noeudid(idn1);
2967     tab[1]=femmai->get_fem_noeudid(idn2);
2968     tab[2]=femmai->get_fem_noeudid(idn3);
2969     tab[3]=femmai->get_fem_noeudid(idn4);
2970     MG_ELEMENT_MAILLAGE* elmai;
2971     if (idmai>-1)
2972     elmai=mgmai->get_mg_tetraid(idmai);
2973     else elmai=NULL;
2974 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2975     if (idtopo>-1)
2976 francois 393 topo=mggeo->get_mg_volumeid(idtopo);
2977 francois 378 FEM_TETRA4* tet=new FEM_TETRA4(id,topo,elmai,tab);
2978 francois 410 tet->change_etat(0,etat);
2979 francois 309 femmai->ajouter_fem_element3(tet);
2980 francois 283 }
2981 francois 399 if (entite=="XFEM_ELEMENT_NOEUD")
2982 francois 339 {
2983 francois 380 parse.decode(data.c_str(),"@,@,@,@",param+2);
2984 francois 399 unsigned long idele=cid(param[2].argument[0]);
2985     unsigned long idtopo=cid(param[3].argument[0]);
2986     unsigned long idn1=cid(param[4].argument[0]);
2987 francois 380 int etat=atoi(param[5].argument[0].c_str());
2988 francois 399 MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_sommetid(idtopo);
2989     FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element0id(idele);
2990     if (mai==NULL) mai=femmai->get_fem_element1id(idele);
2991     if (mai==NULL) mai=femmai->get_fem_element2id(idele);
2992     if (mai==NULL) mai=femmai->get_fem_element3id(idele);
2993 francois 380 FEM_NOEUD* tab[4];
2994     tab[0]=femmai->get_fem_noeudid(idn1);
2995 francois 399 XFEM_ELEMENT0* xele=new XFEM_ELEMENT0(id,mai,topo,tab);
2996     femmai->ajouter_xfem_element0(xele);
2997     xele->change_etat(etat);
2998     }
2999     if (entite=="XFEM_SEGMENT2")
3000     {
3001     parse.decode(data.c_str(),"@,@,@,@,@",param+2);
3002     unsigned long idele=cid(param[2].argument[0]);
3003     unsigned long idtopo=cid(param[3].argument[0]);
3004     unsigned long idn1=cid(param[4].argument[0]);
3005     unsigned long idn2=cid(param[5].argument[0]);
3006     int etat=atoi(param[6].argument[0].c_str());
3007     FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element1id(idele);
3008     if (mai==NULL) mai=femmai->get_fem_element2id(idele);
3009     if (mai==NULL) mai=femmai->get_fem_element3id(idele);
3010     MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_areteid(idtopo);
3011     FEM_NOEUD* tab[4];
3012     tab[0]=femmai->get_fem_noeudid(idn1);
3013 francois 380 tab[1]=femmai->get_fem_noeudid(idn2);
3014 francois 399 XFEM_SEGMENT2* xseg=new XFEM_SEGMENT2(id,mai,topo,tab);
3015 francois 380 femmai->ajouter_xfem_element1(xseg);
3016 francois 399 xseg->change_etat(etat);
3017 francois 380 }
3018 francois 410 if (entite=="XFEM_TRIANGLE3")
3019     {
3020     parse.decode(data.c_str(),"@,@,@,@,@,@",param+2);
3021     unsigned long idtet=cid(param[2].argument[0]);
3022     unsigned long idtopo=cid(param[3].argument[0]);
3023     unsigned long idn1=cid(param[4].argument[0]);
3024     unsigned long idn2=cid(param[5].argument[0]);
3025     unsigned long idn3=cid(param[6].argument[0]);
3026     int etat=atoi(param[7].argument[0].c_str());
3027     FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element3id(idtet);
3028     MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_volumeid(idtopo);
3029     FEM_NOEUD* tab[3];
3030     tab[0]=femmai->get_fem_noeudid(idn1);
3031     tab[1]=femmai->get_fem_noeudid(idn2);
3032     tab[2]=femmai->get_fem_noeudid(idn3);
3033     XFEM_TRIANGLE3* xtri=new XFEM_TRIANGLE3(id,mai,topo,tab);
3034     femmai->ajouter_xfem_element2(xtri);
3035     xtri->change_etat(etat);
3036     }
3037 francois 380 if (entite=="XFEM_TETRA4")
3038     {
3039 francois 399 parse.decode(data.c_str(),"@,@,@,@,@,@,@",param+2);
3040 francois 339 unsigned long idtet=cid(param[2].argument[0]);
3041 francois 399 unsigned long idtopo=cid(param[3].argument[0]);
3042     unsigned long idn1=cid(param[4].argument[0]);
3043     unsigned long idn2=cid(param[5].argument[0]);
3044     unsigned long idn3=cid(param[6].argument[0]);
3045     unsigned long idn4=cid(param[7].argument[0]);
3046     int etat=atoi(param[8].argument[0].c_str());
3047 francois 408 FEM_ELEMENT_MAILLAGE* mai=femmai->get_fem_element3id(idtet);
3048 francois 399 MG_ELEMENT_TOPOLOGIQUE* topo=mggeo->get_mg_volumeid(idtopo);
3049     FEM_NOEUD* tab[4];
3050 francois 378 tab[0]=femmai->get_fem_noeudid(idn1);
3051     tab[1]=femmai->get_fem_noeudid(idn2);
3052     tab[2]=femmai->get_fem_noeudid(idn3);
3053     tab[3]=femmai->get_fem_noeudid(idn4);
3054 francois 399 XFEM_TETRA4* xtet=new XFEM_TETRA4(id,mai,topo,tab);
3055 francois 339 femmai->ajouter_xfem_element3(xtet);
3056 francois 383 xtet->change_etat(etat);
3057 francois 339 }
3058 francois 283 if (entite=="FEM_TETRA10")
3059     {
3060     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@",param+2);
3061 francois 378 long idtopo=cid(param[2].argument[0]);
3062     long idmai=cid(param[3].argument[0]);
3063 francois 283 long idn1=cid(param[4].argument[0]);
3064     long idn2=cid(param[5].argument[0]);
3065     long idn3=cid(param[6].argument[0]);
3066     long idn4=cid(param[7].argument[0]);
3067     long idn5=cid(param[8].argument[0]);
3068     long idn6=cid(param[9].argument[0]);
3069     long idn7=cid(param[10].argument[0]);
3070     long idn8=cid(param[11].argument[0]);
3071     long idn9=cid(param[12].argument[0]);
3072     long idn10=cid(param[13].argument[0]);
3073     FEM_NOEUD* tab[10];
3074     tab[0]=femmai->get_fem_noeudid(idn1);
3075     tab[1]=femmai->get_fem_noeudid(idn2);
3076     tab[2]=femmai->get_fem_noeudid(idn3);
3077     tab[3]=femmai->get_fem_noeudid(idn4);
3078     tab[4]=femmai->get_fem_noeudid(idn5);
3079     tab[5]=femmai->get_fem_noeudid(idn6);
3080     tab[6]=femmai->get_fem_noeudid(idn7);
3081     tab[7]=femmai->get_fem_noeudid(idn8);
3082     tab[8]=femmai->get_fem_noeudid(idn9);
3083     tab[9]=femmai->get_fem_noeudid(idn10);
3084     MG_ELEMENT_MAILLAGE* elmai;
3085     if (idmai>-1)
3086     elmai=mgmai->get_mg_tetraid(idmai);
3087     else elmai=NULL;
3088 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3089     if (idtopo>-1)
3090 francois 393 topo=mggeo->get_mg_volumeid(idtopo);
3091 francois 378 FEM_TETRA10* tet=new FEM_TETRA10(id,topo,elmai,tab);
3092 francois 309 femmai->ajouter_fem_element3(tet);
3093 francois 283 }
3094 francois 310 if (entite=="FEM_HEXA8")
3095     {
3096     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@",param+2);
3097 francois 378 long idtopo=cid(param[2].argument[0]);
3098     long idmai=cid(param[3].argument[0]);
3099 francois 310 long idn1=cid(param[4].argument[0]);
3100     long idn2=cid(param[5].argument[0]);
3101     long idn3=cid(param[6].argument[0]);
3102     long idn4=cid(param[7].argument[0]);
3103     long idn5=cid(param[8].argument[0]);
3104     long idn6=cid(param[9].argument[0]);
3105     long idn7=cid(param[10].argument[0]);
3106     long idn8=cid(param[11].argument[0]);
3107     FEM_NOEUD* tab[8];
3108     tab[0]=femmai->get_fem_noeudid(idn1);
3109     tab[1]=femmai->get_fem_noeudid(idn2);
3110     tab[2]=femmai->get_fem_noeudid(idn3);
3111     tab[3]=femmai->get_fem_noeudid(idn4);
3112     tab[4]=femmai->get_fem_noeudid(idn5);
3113     tab[5]=femmai->get_fem_noeudid(idn6);
3114     tab[6]=femmai->get_fem_noeudid(idn7);
3115     tab[7]=femmai->get_fem_noeudid(idn8);
3116     MG_ELEMENT_MAILLAGE* elmai;
3117     if (idmai>-1)
3118     elmai=mgmai->get_mg_hexaid(idmai);
3119     else elmai=NULL;
3120 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3121     if (idtopo>-1)
3122 francois 393 topo=mggeo->get_mg_volumeid(idtopo);
3123 francois 378 FEM_HEXA8* hex=new FEM_HEXA8(id,topo,elmai,tab);
3124 francois 310 femmai->ajouter_fem_element3(hex);
3125     }
3126     if (entite=="FEM_HEXA20")
3127     {
3128     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@",param+2);
3129 francois 378 long idtopo=cid(param[2].argument[0]);
3130     long idmai=cid(param[3].argument[0]);
3131 francois 310 long idn1=cid(param[4].argument[0]);
3132     long idn2=cid(param[5].argument[0]);
3133     long idn3=cid(param[6].argument[0]);
3134     long idn4=cid(param[7].argument[0]);
3135     long idn5=cid(param[8].argument[0]);
3136     long idn6=cid(param[9].argument[0]);
3137     long idn7=cid(param[10].argument[0]);
3138     long idn8=cid(param[11].argument[0]);
3139     long idn9=cid(param[12].argument[0]);
3140     long idn10=cid(param[13].argument[0]);
3141     long idn11=cid(param[14].argument[0]);
3142     long idn12=cid(param[15].argument[0]);
3143     long idn13=cid(param[16].argument[0]);
3144     long idn14=cid(param[17].argument[0]);
3145     long idn15=cid(param[18].argument[0]);
3146     long idn16=cid(param[19].argument[0]);
3147     long idn17=cid(param[20].argument[0]);
3148     long idn18=cid(param[21].argument[0]);
3149     long idn19=cid(param[22].argument[0]);
3150     long idn20=cid(param[23].argument[0]);
3151     FEM_NOEUD* tab[20];
3152     tab[0]=femmai->get_fem_noeudid(idn1);
3153     tab[1]=femmai->get_fem_noeudid(idn2);
3154     tab[2]=femmai->get_fem_noeudid(idn3);
3155     tab[3]=femmai->get_fem_noeudid(idn4);
3156     tab[4]=femmai->get_fem_noeudid(idn5);
3157     tab[5]=femmai->get_fem_noeudid(idn6);
3158     tab[6]=femmai->get_fem_noeudid(idn7);
3159     tab[7]=femmai->get_fem_noeudid(idn8);
3160     tab[8]=femmai->get_fem_noeudid(idn9);
3161     tab[9]=femmai->get_fem_noeudid(idn10);
3162     tab[10]=femmai->get_fem_noeudid(idn11);
3163     tab[11]=femmai->get_fem_noeudid(idn12);
3164     tab[12]=femmai->get_fem_noeudid(idn13);
3165     tab[13]=femmai->get_fem_noeudid(idn14);
3166     tab[14]=femmai->get_fem_noeudid(idn15);
3167     tab[15]=femmai->get_fem_noeudid(idn16);
3168     tab[16]=femmai->get_fem_noeudid(idn17);
3169     tab[17]=femmai->get_fem_noeudid(idn18);
3170     tab[18]=femmai->get_fem_noeudid(idn19);
3171     tab[19]=femmai->get_fem_noeudid(idn20);
3172     MG_ELEMENT_MAILLAGE* elmai;
3173     if (idmai>-1)
3174     elmai=mgmai->get_mg_hexaid(idmai);
3175     else elmai=NULL;
3176 francois 378 MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3177     if (idtopo>-1)
3178 francois 393 topo=mggeo->get_mg_volumeid(idtopo);
3179 francois 378 FEM_HEXA20* hex=new FEM_HEXA20(id,topo,elmai,tab);
3180 francois 310 femmai->ajouter_fem_element3(hex);
3181     }
3182 francois 876 if (entite=="FEM_PENTA6")
3183 francois 283 {
3184 francois 876 parse.decode(data.c_str(),"@,@,@,@,@,@,@,@",param+2);
3185     long idtopo=cid(param[2].argument[0]);
3186     long idmai=cid(param[3].argument[0]);
3187     long idn1=cid(param[4].argument[0]);
3188     long idn2=cid(param[5].argument[0]);
3189     long idn3=cid(param[6].argument[0]);
3190     long idn4=cid(param[7].argument[0]);
3191     long idn5=cid(param[8].argument[0]);
3192     long idn6=cid(param[9].argument[0]);
3193     FEM_NOEUD* tab[6];
3194     tab[0]=femmai->get_fem_noeudid(idn1);
3195     tab[1]=femmai->get_fem_noeudid(idn2);
3196     tab[2]=femmai->get_fem_noeudid(idn3);
3197     tab[3]=femmai->get_fem_noeudid(idn4);
3198     tab[4]=femmai->get_fem_noeudid(idn5);
3199     tab[5]=femmai->get_fem_noeudid(idn6);
3200     MG_ELEMENT_MAILLAGE* elmai;
3201     if (idmai>-1)
3202 francois 878 elmai=mgmai->get_mg_pentaid(idmai);
3203 francois 876 else elmai=NULL;
3204     MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3205     if (idtopo>-1)
3206     topo=mggeo->get_mg_volumeid(idtopo);
3207     FEM_PENTA6* pen=new FEM_PENTA6(id,topo,elmai,tab);
3208     femmai->ajouter_fem_element3(pen);
3209     }
3210     if (entite=="FEM_PENTA15")
3211     {
3212     parse.decode(data.c_str(),"@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@,@",param+2);
3213     long idtopo=cid(param[2].argument[0]);
3214     long idmai=cid(param[3].argument[0]);
3215     long idn1=cid(param[4].argument[0]);
3216     long idn2=cid(param[5].argument[0]);
3217     long idn3=cid(param[6].argument[0]);
3218     long idn4=cid(param[7].argument[0]);
3219     long idn5=cid(param[8].argument[0]);
3220     long idn6=cid(param[9].argument[0]);
3221     long idn7=cid(param[10].argument[0]);
3222     long idn8=cid(param[11].argument[0]);
3223     long idn9=cid(param[12].argument[0]);
3224     long idn10=cid(param[13].argument[0]);
3225     long idn11=cid(param[14].argument[0]);
3226     long idn12=cid(param[15].argument[0]);
3227     long idn13=cid(param[16].argument[0]);
3228     long idn14=cid(param[17].argument[0]);
3229     long idn15=cid(param[18].argument[0]);
3230     FEM_NOEUD* tab[15];
3231     tab[0]=femmai->get_fem_noeudid(idn1);
3232     tab[1]=femmai->get_fem_noeudid(idn2);
3233     tab[2]=femmai->get_fem_noeudid(idn3);
3234     tab[3]=femmai->get_fem_noeudid(idn4);
3235     tab[4]=femmai->get_fem_noeudid(idn5);
3236     tab[5]=femmai->get_fem_noeudid(idn6);
3237     tab[6]=femmai->get_fem_noeudid(idn7);
3238     tab[7]=femmai->get_fem_noeudid(idn8);
3239     tab[8]=femmai->get_fem_noeudid(idn9);
3240     tab[9]=femmai->get_fem_noeudid(idn10);
3241     tab[10]=femmai->get_fem_noeudid(idn11);
3242     tab[11]=femmai->get_fem_noeudid(idn12);
3243     tab[12]=femmai->get_fem_noeudid(idn13);
3244     tab[13]=femmai->get_fem_noeudid(idn14);
3245     tab[14]=femmai->get_fem_noeudid(idn15);
3246     MG_ELEMENT_MAILLAGE* elmai;
3247     if (idmai>-1)
3248 francois 878 elmai=mgmai->get_mg_pentaid(idmai);
3249 francois 876 else elmai=NULL;
3250     MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
3251     if (idtopo>-1)
3252     topo=mggeo->get_mg_volumeid(idtopo);
3253     FEM_PENTA15* pen=new FEM_PENTA15(id,topo,elmai,tab);
3254     femmai->ajouter_fem_element3(pen);
3255     }
3256     if (entite=="SOLUTION")
3257     {
3258 francois 377 parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
3259 francois 283 int typeentite=atoi(param[2].argument[0].c_str());
3260 francois 377 int typesolution=atoi(param[3].argument[0].c_str());
3261     std::string nomsol=param[4].argument[0];
3262     long idmai=cid(param[5].argument[0]);
3263     int nb=atoi(param[6].argument[0].c_str());
3264     std::string chemin=param[7].argument[0];
3265 francois 283 MG_MAILLAGE* mai=get_mg_maillageid(idmai);
3266 francois 377 MG_SOLUTION* sol=new MG_SOLUTION(id,mai,nb,(char*)chemin.c_str(),SOL_EXISTANTE,nomsol,typeentite,typesolution);
3267 francois 283 ajouter_mg_solution(sol);
3268     for (int i=0;i<nb;i++)
3269 francois 377 sol->change_legende(i,param[8].argument[i]);
3270 francois 283 }
3271     if (entite=="FEM_SOLUTION")
3272     {
3273 francois 375 parse.decode(data.c_str(),"@,@,@,@,@,@,(&)",param+2);
3274 francois 283 int typeentite=atoi(param[2].argument[0].c_str());
3275 francois 375 int typesolution=atoi(param[3].argument[0].c_str());
3276     std::string nomsol=param[4].argument[0];
3277     long idmai=cid(param[5].argument[0]);
3278     int nb=atoi(param[6].argument[0].c_str());
3279 couturad 919 std::string chemin_sol=param[7].argument[0];
3280 francois 283 FEM_MAILLAGE* mai=get_fem_maillageid(idmai);
3281 couturad 919 FEM_SOLUTION* sol=new FEM_SOLUTION(id,mai,nb,(char*)chemin_sol.c_str(),SOL_EXISTANTE,nomsol,typeentite,typesolution);
3282 francois 283 ajouter_fem_solution(sol);
3283     for (int i=0;i<nb;i++)
3284 francois 375 sol->change_legende(i,param[8].argument[i]);
3285 francois 283 }
3286     #ifdef WINDOWS_VERSION
3287     if (entite=="CAD4FE_MCSEGMENT")
3288     {
3289     parse.decode(data.c_str(),"@,@,@",param+2);
3290     long idtopo=cid(param[2].argument[0]);
3291     long idn1=cid(param[3].argument[0]);
3292     long idn2=cid(param[4].argument[0]);
3293     CAD4FE::MCNode* noeud1=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn1);
3294     CAD4FE::MCNode* noeud2=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn2);
3295     MG_ELEMENT_TOPOLOGIQUE* topo;
3296     if (idtopo>-1)
3297     {
3298     topo=mggeo->get_mg_areteid(idtopo);
3299     if (topo==NULL) topo=mggeo->get_mg_faceid(idtopo);
3300     if (topo==NULL) topo=mggeo->get_mg_volumeid(idtopo);
3301     }
3302     else topo=NULL;
3303     CAD4FE::MCSegment * seg = new CAD4FE::MCSegment(id,topo,noeud1,noeud2);
3304     mgmai->ajouter_mg_segment(seg);
3305     }
3306     if (entite=="CAD4FE_MCNODE")
3307     {
3308     parse.decode(data.c_str(),"@,@,@,@,@",param+2);
3309     long idRefTopo=cid(param[2].argument[0]);
3310     long idMCTopo=cid(param[3].argument[0]);
3311     double x=atof(param[4].argument[0].c_str());
3312     double y=atof(param[5].argument[0].c_str());
3313     double z=atof(param[6].argument[0].c_str());
3314     MG_ELEMENT_TOPOLOGIQUE* refTopo=NULL;
3315     if (refTopo==NULL) refTopo=mggeo->get_mg_sommetid(idRefTopo);
3316     if (refTopo==NULL) refTopo=mggeo->get_mg_areteid(idRefTopo);
3317     if (refTopo==NULL) refTopo=mggeo->get_mg_faceid(idRefTopo);
3318     if (refTopo==NULL) refTopo=mggeo->get_mg_volumeid(idRefTopo);
3319     MG_ELEMENT_TOPOLOGIQUE* mcTopo=NULL;
3320     if (mcTopo==NULL) mcTopo=mggeo->get_mg_sommetid(idMCTopo);
3321     if (mcTopo==NULL) mcTopo=mggeo->get_mg_areteid(idMCTopo);
3322     if (mcTopo==NULL) mcTopo=mggeo->get_mg_faceid(idMCTopo);
3323     if (mcTopo==NULL) mcTopo=mggeo->get_mg_volumeid(idMCTopo);
3324    
3325     if (mcTopo->get_dimension()==0)
3326     {
3327     if (updatedMergedRefVertices == false)
3328     {
3329     for (std::multimap<CAD4FE::MCVertex * , unsigned long>::iterator itMergedRefVertices = mapMergedRefVertices.begin();
3330     itMergedRefVertices != mapMergedRefVertices.end();
3331     itMergedRefVertices++)
3332     {
3333     CAD4FE::MCVertex * v = itMergedRefVertices->first;
3334     MG_SOMMET * refV = NULL;
3335     unsigned long id = itMergedRefVertices->second;
3336     refV = (MG_SOMMET *) mggeo->get_mg_sommetid(id);
3337     v->MergeRefVertex(refV);
3338     }
3339    
3340     updatedMergedRefVertices = true;
3341     }
3342     }
3343    
3344     CAD4FE::MCNode* noeud=new CAD4FE::MCNode(id,mcTopo,refTopo,x,y,z);
3345     mgmai->ajouter_mg_noeud(noeud);
3346     }
3347     if (entite=="CAD4FE_MCTRIANGLE")
3348     {
3349     parse.decode(data.c_str(),"@,@,@,@",param+2);
3350     long idtopo=cid(param[2].argument[0]);
3351     long idn1=cid(param[3].argument[0]);
3352     long idn2=cid(param[4].argument[0]);
3353     long idn3=cid(param[5].argument[0]);
3354     CAD4FE::MCNode* noeud1=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn1);
3355     CAD4FE::MCNode* noeud2=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn2);
3356     CAD4FE::MCNode* noeud3=(CAD4FE::MCNode*)mgmai->get_mg_noeudid(idn3);
3357     CAD4FE::MCSegment* mgsegment[3];
3358     CAD4FE::MCNode *mgnoeud[3]={noeud1,noeud2,noeud3};
3359     // la topo. d'un MCTriangle est obligatoirement une MCFace
3360     CAD4FE::MCFace* mcFace=(CAD4FE::MCFace*)mggeo->get_mg_faceid(idtopo);
3361     for (int i=0;i<3;i++)
3362     {
3363     mgsegment[i]=(CAD4FE::MCSegment*)mgmai->get_mg_segment(mgnoeud[i]->get_id(),mgnoeud[(i+1)%3]->get_id());
3364     if (mgsegment[i]==NULL)
3365     {
3366     mgsegment[i]=new CAD4FE::MCSegment(mcFace,mgnoeud[i],mgnoeud[(i+1)%3]);
3367     mgmai->ajouter_mg_segment(mgsegment[i]);
3368     }
3369     }
3370     CAD4FE::M3D_MCTriangle *triangle = new CAD4FE::M3D_MCTriangle(id,mcFace,noeud1,noeud2,noeud3,mgsegment[0],mgsegment[1],mgsegment[2]);
3371     mgmai->ajouter_mg_triangle(triangle);
3372     }
3373     #endif
3374     }
3375     }
3376     while (param[0].argument[0]!="FIN");
3377 francois 878
3378 francois 881 for (int i=0;i<volumemince.size();i=i+3)
3379 francois 878 {
3380 francois 881 MG_VOLUME *vol=mggeo->get_mg_volumeid(volumemince[i]);
3381     MG_FACE* face1=mggeo->get_mg_faceid(volumemince[i+1]);
3382     MG_FACE* face2=mggeo->get_mg_faceid(volumemince[i+2]);
3383     vol->ajouter_face_correspondante(face1,face2);
3384 francois 878 }
3385    
3386    
3387 francois 741 LISTE_MG_ARBRE::iterator itarbre;
3388     for (MG_ARBRE* arb=get_premier_arbre(itarbre);arb!=NULL;arb=get_suivant_arbre(itarbre))
3389     {
3390     LISTE_MG_ASSEMBLAGE::iterator itass;
3391     for (MG_ASSEMBLAGE *ass=arb->get_premier_assemblage(itass);ass!=NULL;ass=arb->get_suivant_assemblage(itass))
3392     ass->ini_donne(arb);
3393     }
3394 francois 526 LISTE_MG_GEOMETRIE::iterator itgeo;
3395     for (MG_GEOMETRIE* geo=get_premier_geometrie(itgeo);geo;geo=get_suivant_geometrie(itgeo))
3396     {
3397     LISTE_MG_SOMMET::iterator itsom;
3398     for (MG_SOMMET* som=geo->get_premier_sommet(itsom);som;som=geo->get_suivant_sommet(itsom))
3399     if (som->est_un_sommet_noeud())
3400     {
3401     MG_SOMMET_NOEUD* somno=(MG_SOMMET_NOEUD*)som;
3402     unsigned long idnoeud=somno->get_id_mg_noeud();
3403     MG_NOEUD* noeud;
3404     LISTE_MG_MAILLAGE::iterator itmai;
3405     for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
3406     if (mai->get_mg_noeudid(idnoeud)!=NULL) noeud=mai->get_mg_noeudid(idnoeud);
3407     somno->change_mg_noeud(noeud);
3408     }
3409 francois 685 LISTE_MG_COQUE::iterator itcoq;
3410     for (MG_COQUE* coq=geo->get_premier_coque(itcoq);coq;coq=geo->get_suivant_coque(itcoq))
3411     if (coq->est_une_coque_element())
3412     {
3413     MG_COQUE_ELEMENT* coque=(MG_COQUE_ELEMENT*)coq;
3414     int nbele=coque->get_nb_liste_id();
3415     MG_MAILLAGE* mgmai=NULL;
3416     for (int i=0;i<nbele;i++)
3417     {
3418     unsigned long eleid=coque->get_liste_id(i);
3419     if (i==0)
3420     {
3421     LISTE_MG_MAILLAGE::iterator itmai;
3422     for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
3423     {
3424     if (mai->get_mg_triangleid(eleid)!=NULL) mgmai=mai;
3425     if (mai->get_mg_quadrangleid(eleid)!=NULL) mgmai=mai;
3426     }
3427     }
3428     MG_ELEMENT_MAILLAGE* ele=NULL;
3429     if (ele==NULL) ele=mgmai->get_mg_triangleid(eleid);
3430     if (ele==NULL) ele=mgmai->get_mg_quadrangleid(eleid);
3431     coque->ajouter_element(ele);
3432     }
3433    
3434     }
3435 francois 753 LISTE_MG_POUTRE::iterator itpou;
3436     for (MG_POUTRE* pou=geo->get_premier_poutre(itpou);pou;pou=geo->get_suivant_poutre(itpou))
3437     if (pou->est_une_poutre_element())
3438     {
3439     MG_POUTRE_ELEMENT* poutre=(MG_POUTRE_ELEMENT*)pou;
3440     int nbele=poutre->get_nb_liste_id();
3441     MG_MAILLAGE* mgmai=NULL;
3442     for (int i=0;i<nbele;i++)
3443     {
3444     unsigned long eleid=poutre->get_liste_id(i);
3445     if (i==0)
3446     {
3447     LISTE_MG_MAILLAGE::iterator itmai;
3448     for (MG_MAILLAGE* mai=get_premier_mg_maillage(itmai);mai;mai=get_suivant_mg_maillage(itmai))
3449     {
3450     if (mai->get_mg_segmentid(eleid)!=NULL) mgmai=mai;
3451     }
3452     }
3453     MG_ELEMENT_MAILLAGE* ele=NULL;
3454     if (ele==NULL) ele=mgmai->get_mg_segmentid(eleid);
3455     poutre->ajouter_element(ele);
3456     }
3457    
3458     }
3459 francois 526 }
3460 francois 283 #ifdef WINDOWS_VERSION
3461     if (updatedMergedRefVertices == false)
3462     {
3463     for (std::multimap<CAD4FE::MCVertex * , unsigned long>::iterator itMergedRefVertices = mapMergedRefVertices.begin();
3464     itMergedRefVertices != mapMergedRefVertices.end();
3465     itMergedRefVertices++)
3466     {
3467     CAD4FE::MCVertex * v = itMergedRefVertices->first;
3468     MG_SOMMET * refV = NULL;
3469     unsigned long id = itMergedRefVertices->second;
3470     refV = (MG_SOMMET *) mggeo->get_mg_sommetid(id);
3471     v->MergeRefVertex(refV);
3472     }
3473    
3474     updatedMergedRefVertices = true;
3475     }
3476    
3477     #endif
3478     fclose(in);
3479     return 1;
3480     }
3481    
3482    
3483    
3484