ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/lib/fichier/src/mg_file.cpp
Revision: 951
Committed: Fri Aug 10 15:17:17 2018 UTC (6 years, 9 months ago) by couturad
File size: 150609 byte(s)
Log Message: 
-> Ajout de Project Chrono (voir CMakeLists.txt).
-> Ajout d'un générateur de microstructure basé sur la dynamique des corps rigides (MSTRUCT_GENERATEUR_DCR).
-> Ajout d'un opérateur de décallage de la topologie (MG_CG_OP_TRANSF_DECALLAGE).
-> Retrait de «using namespace std»  (conflit avec namespace chrono) et modification des fichiers affectés.
-> Modification de mailleur2d.cpp afin d'enregistrer un fichier MAGiC (void.magic) lorsque le nombre d'itération dépasse la valeur maximale.

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