MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
magic_script.cpp
Aller à la documentation de ce fichier.
1 //####//------------------------------------------------------------
2 //####//------------------------------------------------------------
3 //####// MAGiC
4 //####// Jean Christophe Cuilliere et Vincent FRANCOIS
5 //####// Departement de Genie Mecanique - UQTR
6 //####//------------------------------------------------------------
7 //####// MAGIC est un projet de recherche de l equipe ERICCA
8 //####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9 //####// http://www.uqtr.ca/ericca
10 //####// http://www.uqtr.ca/
11 //####//------------------------------------------------------------
12 //####//------------------------------------------------------------
13 //####//
14 //####// magic_script.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:58:57 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 #include "gestionversion.h"
23 #include "magic_script.h"
24 #include <iostream>
25 #include <map>
26 #include <string>
27 #include <stdlib.h>
28 #include "mg_file.h"
29 #include "mg_export.h"
30 #include "parse.h"
31 #include "pars_argument.h"
32 #include "occ_import.h"
33 #include "mg_arbre.h"
34 #include "mg_primitive_boite.h"
35 #include "mg_primitive_sphere.h"
36 #include "mg_primitive_ellipsoide_revolution.h"
37 #include "mg_primitive_cylindre.h"
38 #include "mg_primitive_tore.h"
39 #include "mg_primitive_cone.h"
40 #include "mg_operateur_boolean_union.h"
41 #include "mg_operateur_boolean_difference.h"
42 #include "mg_operateur_boolean_intersection.h"
43 #include "mg_assemblage.h"
44 
45 #include "occ_fonction_v2017.h"
46 #include "mg_geometrie.h"
47 #include "mg_sous_geometrie.h"
48 #include "mg_cg.h"
49 #include "mg_cg_modele.h"
50 #include "mg_cg_assemblage.h"
51 #include "mg_cg_forme.h"
52 #include "mg_cg_operateur.h"
53 #include "mg_cg_forme_volume_boite.h"
54 #include "mg_cg_forme_volume_sphere.h"
55 #include "mg_cg_forme_volume_ellipsoide.h"
56 #include "mg_cg_forme_volume_cylindre.h"
57 #include "mg_cg_forme_volume_cone.h"
58 #include "mg_cg_forme_volume_tore.h"
59 #include "mg_cg_operateur.h"
60 #include "mg_cg_op_bool_union.h"
61 #include "mg_cg_op_bool_difference.h"
62 #include "mg_cg_op_bool_intersection.h"
63 #include "mg_cg_op_bool_fragment.h"
64 
65 void affiche_erreur(char* message)
66 {
67 std::cout << "\033[1;31m" << message << "\033[1;32m" << std::endl;
68 exit(0);
69 }
70 
71 template <class X> void ajouter_list(int ligne,std::string var,X* x,std::map<std::string,X*> &lst)
72 {
73 typedef typename std::map<std::string,X* >::iterator ITERATEUR;
74 std::pair<std::string ,X*> tmp(var,x);
75 std::pair<ITERATEUR,bool> ret=lst.insert(tmp);
76 if (ret.second==false)
77  {
78  char mess[500];
79  sprintf(mess," Ligne %d : variable %s deja utilisée",ligne,var.c_str());
80  affiche_erreur(mess);
81  }
82 }
83 
84 
85 
86 template <class X> X* get_list(int ligne,std::string var,std::map<std::string,X*> &lst)
87 {
88 typedef typename std::map<std::string,X* >::iterator ITERATEUR;
89 ITERATEUR it=lst.find(var);
90 if (it!=lst.end())
91  return it->second;
92 char mess[500];
93 sprintf(mess," Ligne %d : variable %s inconnue",ligne,var.c_str());
94 affiche_erreur(mess);
95 return NULL;
96 }
97 
98 
99 MAGIC_SCRIPT::MAGIC_SCRIPT(char* chemin)
100  {
101  execute(chemin);
102  }
103 
104 
105 
106 
107  MAGIC_SCRIPT::MAGIC_SCRIPT(MAGIC_SCRIPT &mdd)
108  {
109 
110  }
111 
112 
113 int MAGIC_SCRIPT::get_semantique(char* mess)
114 {
115 upcase(mess);
116 if (strcmp(mess,"CHAMFREIN")==0) return MAGIC::SEMANTIQUECSG::CHAMFREIN;
117 if (strcmp(mess,"CONGE")==0) return MAGIC::SEMANTIQUECSG::CONGE;
118 if (strcmp(mess,"INTERSECTION")==0) return MAGIC::SEMANTIQUECSG::INTERSECTION;
119 if (strcmp(mess,"PERCAGE")==0) return MAGIC::SEMANTIQUECSG::PERCAGE;
120 if (strcmp(mess,"SOUSTRACTION")==0) return MAGIC::SEMANTIQUECSG::SOUSTRACTION;
121 if (strcmp(mess,"UNION")==0) return MAGIC::SEMANTIQUECSG::UNION;
122 if (strcmp(mess,"EXTRUSION")==0) return MAGIC::SEMANTIQUECSG::EXTRUSION;
123 return MAGIC::SEMANTIQUECSG::SANS;
124 }
125 
126 
127 void MAGIC_SCRIPT::execute(char *chemin)
128 {
129 cpu.initialise();
130 time(&debut);
131 CODE_ASTER_CPU=0;
132 CODE_ASTER_ECOULE=0;
133 char version[500];
134 affiche((char*)"\033[1;36m************************************************************");
135 sprintf(version,"* MAGiC %s *",MAGIC_VERSION);
136 affiche(version);
137 affiche((char*)"************************************************************");
138 GESTIONVERSION v;
139 v.print(version);
140 affiche(version);
141 affiche((char*)"************************************************************");
142 affiche((char*)"Execution d'un script MAGiC\033[1;31m");
143 affiche(chemin);
144 affiche((char*)"\033[1;32m************************************************************\033[1;33m");
145 affiche((char*)"");
146 affiche((char*)"");
147 affiche((char*)"Debut execution");
148 FILE* in=fopen(chemin,"rt");
149 if (in==NULL) affiche_erreur((char*)" Fichier script absent");
150 std::map<std::string,MG_GESTIONNAIRE*> lstgest;
151 std::map<std::string,MG_GEOMETRIE*> lst_mg_geometrie;
152 std::map<std::string,MG_CG_MODELE*> lst_mgcg_modele;
153 std::map<std::string,MG_CG_ASSEMBLAGE*> lst_mgcg_assemblage;
154 std::map<std::string,MG_CG_FORME*> lst_mgcg_forme;
155 std::map<std::string,MG_CG_OPERATEUR*> lst_mgcg_operateur;
156 char instruction[500];
157 fgets(instruction,500,in);
158 int ligne=0;
159 while (!feof(in))
160  {
161  ligne++;
162  PARS_ARGUMENT param[100];
163  PARSE parse;
164  char commande[500];
165  char variable[500];
166  std::string instruction2=instruction;
167  size_t pos=instruction2.find_first_not_of(" ");
168  instruction2.erase(0,pos);
169  strcpy(instruction,(char*)instruction2.c_str());
170  parse.decode(instruction,"@ = @",param);
171  strcpy(variable,param[0].argument[0].c_str());
172  strcpy(commande,param[1].argument[0].c_str());
173  char key[500];
174  int nb=sscanf(commande,"%s",key);
175  if (nb==1)
176  {
177  upcase(key);
178  if (variable[0]!='#')
179  {
180  if (strcmp(key,"FICHIER")==0)
181  {
182  char fichier[400];
183  sscanf(commande,"%s %s",key,fichier);
184  upcase(fichier);
185  if (strcmp(fichier,"NOUVEAU")==0)
186  {
187  char message[5000];
188  sprintf(message," Création d'un nouveau fichier MAGiC \033[38;5;46m[%s]\033[1;33m",variable);
189  affiche(message);
190  MG_GESTIONNAIRE *gest=new MG_GESTIONNAIRE;
191  ajouter_list<MG_GESTIONNAIRE>(ligne,variable,gest,lstgest);
192  }
193  else
194  {
195  char message[5000];
196  sprintf(message," Lecture d'un fichier MAGiC \033[38;5;46m[%s]\033[1;33m",variable);
197  affiche(message);
198  MG_FILE *gest=new MG_FILE(fichier);
199  ajouter_list<MG_GESTIONNAIRE>(ligne,variable,gest,lstgest);
200 
201  }
202  }
203 #ifdef ALL_OCC
204  else if (strcmp(key,"IMPORTSTEPOCC")==0)
205  {
206  // variable = IMPORTSTEPOCC [MG_GESTIONNAIRE* gest] [char *fichier_entree] [char *fichier_sortie] [double eps] [char* fusion] [char* triSTL] [double eps2]
207  char var[400];
208  char fichier_entree[400];
209  char fichier_sortie[400];
210  char fusion[400];
211  char triSTL[400];
212  double eps=1e-6;
213  double eps_tri=1.0;
214  bool fusionner_entite_similaire=false;
215  bool importer_triangulation=false;
216  int importtri=0;
217  sscanf(commande,"%s %s %s %s %lf %s %s %lf",key,var,fichier_entree,fichier_sortie,&eps,fusion,triSTL,&eps_tri);
218  upcase(fusion); if(strcmp(fusion,"FUSION")==0)fusionner_entite_similaire=true;
219  upcase(triSTL);
220  if(strcmp(triSTL,"TRISTL")==0)importtri=1;
221  if(strcmp(triSTL,"TRIANGULATION")==0)importtri=2;
222  if(importtri>0) importer_triangulation=true;
223  char message[5000];
224  sprintf(message," Importation d'un fichier step via OpenCascade \033[38;5;46m[%s]\033[1;33m",variable);
225  affiche(message);
226  MG_GESTIONNAIRE *gest=get_list<MG_GESTIONNAIRE>(ligne,var,lstgest);
227  OCC_IMPORT occimport;
228  std::string str_fichier_sortie_caf;
229  std::string str_nom_fichier_caf_mggeo;
230  std::string str_fichier_sortie(fichier_sortie);
231  if(str_fichier_sortie.size()>6)
232  {
233  std::size_t find_magic = str_fichier_sortie.find(".magic");
234  if(find_magic!=std::string::npos)
235  {
236  str_fichier_sortie_caf = str_fichier_sortie;
237  str_fichier_sortie_caf.erase(find_magic,6);
238  str_nom_fichier_caf_mggeo = str_fichier_sortie_caf;
239  str_fichier_sortie_caf = str_fichier_sortie_caf + ".ocaf";
240  }
241  }
242  MG_GEOMETRIE* mggeo=occimport.importer_fichier_STEP_V2017(*gest,fichier_entree,(char*)str_nom_fichier_caf_mggeo.c_str(),FICHIERSTEP,eps,fusionner_entite_similaire);
243  if(importer_triangulation) occimport.importer_triangulation_V2017(*gest,mggeo,eps_tri,importtri);
244  ajouter_list<MG_GEOMETRIE>(ligne,variable,mggeo,lst_mg_geometrie);
245  }
246 
247  else if (strcmp(key,"CREEMODELE")==0)
248  {
249  // variable = CREER_MG_CG_MODELE [MG_GESTIONNAIRE* gest] [char *nom] [double unite] [double eps] [char* fusion] [char* triSTL] [double eps_tri]
250  char var[400];
251  char nom[400];
252  double unite=1.0;
253  double eps=1e-6;
254  char fusion[400];
255  char triSTL[400];
256  double eps_tri=1.0;
257  bool fusionner_entite_similaire=false;
258  bool importer_triangulation=false;
259  sscanf(commande,"%s %s %s %lf %lf %s %s %lf",key,var,nom,&unite,&eps,fusion,triSTL,&eps_tri);
260  upcase(fusion); if(strcmp(fusion,"FUSION")==0)fusionner_entite_similaire=true;
261  upcase(triSTL);
262  if(strcmp(triSTL,"TRISTL")==0)importer_triangulation=true;
263  else if(strcmp(triSTL,"TRIANGULATION")==0)importer_triangulation=true;
264  else if(strcmp(triSTL,"TRUE")==0)importer_triangulation=true;
265  MG_GESTIONNAIRE *gest=get_list<MG_GESTIONNAIRE>(ligne,var,lstgest);
266  MG_CG_MODELE* mgcg_modele = MG_CG::creer_MG_CG_MODELE(gest,nom,unite,eps);
267  gest->ajouter_mgcg_modele(mgcg_modele);
268  mgcg_modele->change_fusionner_entite_similaire(fusionner_entite_similaire);
269  mgcg_modele->change_importer_triangulation(importer_triangulation);
270  mgcg_modele->change_epsilon_triangulation(eps_tri);
271  ajouter_list<MG_CG_MODELE>(ligne,variable,mgcg_modele,lst_mgcg_modele);
272  char message[5000];
273  sprintf(message," Création d'un MG_CG_MODELE \033[38;5;46m[%s]\033[1;33m : ID MG_GEOMETRIE = \033[1;31m%li\033[1;33m",variable,mgcg_modele->get_mg_geometrie()->get_id());
274  affiche(message);
275  }
276 
277  else if (strcmp(key,"CREEASSEMBLAGE")==0)
278  {
279  // variable = CREER_MG_CG_ASSEMBLAGE [MG_CG_MODELE* mgcg_modele] [char *nom]
280  char var[400];
281  char nom[400];
282  sscanf(commande,"%s %s %s",key,var,nom);
283  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
284  MG_CG_ASSEMBLAGE* mgcg_assemblage = MG_CG::creer_MG_CG_ASSEMBLAGE(mgcg_modele,nom);
285  ajouter_list<MG_CG_ASSEMBLAGE>(ligne,variable,mgcg_assemblage,lst_mgcg_assemblage);
286  char message[5000];
287  sprintf(message," Création d'un MG_CG_ASSEMBLAGE \033[38;5;46m[%s]\033[1;33m : ID MG_GEOMETRIE = \033[1;31m%li\033[1;33m",variable,mgcg_assemblage->get_mg_sous_geometrie()->get_id());
288  affiche(message);
289  }
290 
291  else if (strcmp(key,"AJOUTASS")==0)
292  {
293  //variable = AJOUTASS [MG_CG_ASSEMBLAGE] [MG_CG_FORME]
294  char var1[400];
295  char var2[400];
296  char message[5000];
297  sscanf(commande,"%s %s %s",key,var1,var2);
298  sprintf(message," Ajout d'une MG_CG_FORME \033[38;5;46m[%s]\033[1;33m à un MG_CG_ASSEMBLAGE \033[38;5;46m[%s]\033[1;33m",var2,var1);
299  affiche(message);
300  MG_CG_ASSEMBLAGE* mgcg_assemblage = get_list<MG_CG_ASSEMBLAGE>(ligne,var1,lst_mgcg_assemblage);
301  MG_CG_FORME* mgcg_forme = get_list<MG_CG_FORME>(ligne,var2,lst_mgcg_forme);
302  mgcg_assemblage->ajouter_mgcg_forme(mgcg_forme);
303  }
304  else if (strcmp(key,"P_BOITE")==0)
305  {
306  // variable = CREER_MG_CG_FORME_VOLUME_BOITE [MG_CG_MODELE] [x1] [y1] [z1] [x2] [y2] [z2]
307  char var[400];
308  double x1,y1,z1,x2,y2,z2;
309  sscanf(commande,"%s %s %lf %lf %lf %lf %lf %lf ",key,var,&x1,&y1,&z1,&x2,&y2,&z2);
310  char message[5000];
311  sprintf(message," Création d'une MG_CG_FORME_VOLUME_BOITE \033[38;5;46m[%s]\033[1;33m",variable);
312  affiche(message);
313  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
314  MG_CG_FORME* mgcg_forme = MG_CG::creer_MG_CG_FORME_VOLUME_BOITE(mgcg_modele,x1,y1,z1,x2,y2,z2);
315  mgcg_forme->construire();
316  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme,lst_mgcg_forme);
317  }
318  else if (strcmp(key,"P_SPHERE")==0)
319  {
320  char var[400];
321  double x1,y1,z1,r;
322  sscanf(commande,"%s %s %lf %lf %lf %lf",key,var,&x1,&y1,&z1,&r);
323  char message[5000];
324  sprintf(message," Création d'une MG_CG_FORME_VOLUME_SPHERE \033[38;5;46m[%s]\033[1;33m",variable);
325  affiche(message);
326  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
327  MG_CG_FORME* mgcg_forme = MG_CG::creer_MG_CG_FORME_VOLUME_SPHERE(mgcg_modele,x1,y1,z1,r);
328  mgcg_forme->construire();
329  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme,lst_mgcg_forme);
330  }
331  else if (strcmp(key,"P_ELLIPSOIDE")==0)
332  {
333  char var[400];
334  double centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon_majeur,rayon_mineur;
335  sscanf(commande,"%s %s %lf %lf %lf %lf %lf %lf %lf %lf",key,var,&centre_x,&centre_y,&centre_z,&axe_x,&axe_y,&axe_z,&rayon_majeur,&rayon_mineur);
336  char message[5000];
337  sprintf(message," Création d'une MG_CG_FORME_VOLUME_ELLIPSOIDE \033[38;5;46m[%s]\033[1;33m",variable);
338  affiche(message);
339  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
340  MG_CG_FORME* mgcg_forme = MG_CG::creer_MG_CG_FORME_VOLUME_ELLIPSOIDE(mgcg_modele,centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon_majeur,rayon_mineur);
341  mgcg_forme->construire();
342  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme,lst_mgcg_forme);
343  }
344  else if (strcmp(key,"P_CYLINDRE")==0)
345  {
346  char var[400];
347  double centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon,longueur;
348  sscanf(commande,"%s %s %lf %lf %lf %lf %lf %lf %lf %lf",key,var,&centre_x,&centre_y,&centre_z,&axe_x,&axe_y,&axe_z,&rayon,&longueur);
349  char message[5000];
350  sprintf(message," Création d'une MG_CG_FORME_VOLUME_CYLINDRE \033[38;5;46m[%s]\033[1;33m",variable);
351  affiche(message);
352  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
353  MG_CG_FORME* mgcg_forme = MG_CG::creer_MG_CG_FORME_VOLUME_CYLINDRE(mgcg_modele,centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon,longueur);
354  mgcg_forme->construire();
355  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme,lst_mgcg_forme);
356  }
357  else if (strcmp(key,"P_CONE")==0)
358  {
359  char var[400];
360  double centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon,longueur;
361  sscanf(commande,"%s %s %lf %lf %lf %lf %lf %lf %lf %lf",key,var,&centre_x,&centre_y,&centre_z,&axe_x,&axe_y,&axe_z,&rayon,&longueur);
362  char message[5000];
363  sprintf(message," Création d'une MG_CG_FORME_VOLUME_CONE \033[38;5;46m[%s]\033[1;33m",variable);
364  affiche(message);
365  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
366  MG_CG_FORME* mgcg_forme = MG_CG::creer_MG_CG_FORME_VOLUME_CONE(mgcg_modele,centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon,longueur);
367  mgcg_forme->construire();
368  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme,lst_mgcg_forme);
369  }
370  else if (strcmp(key,"P_TORE")==0)
371  {
372  char var[400];
373  double centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon_cercle,rayon_tore,angle_seg,angle_rotation;
374  sscanf(commande,"%s %s %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",key,var,&centre_x,&centre_y,&centre_z,&axe_x,&axe_y,&axe_z,&rayon_cercle,&rayon_tore,&angle_seg,&angle_rotation);
375  char message[5000];
376  sprintf(message," Création d'une MG_CG_FORME_VOLUME_TORE \033[38;5;46m[%s]\033[1;33m",variable);
377  affiche(message);
378  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
379  MG_CG_FORME* mgcg_forme = MG_CG::creer_MG_CG_FORME_VOLUME_TORE(mgcg_modele,centre_x,centre_y,centre_z,axe_x,axe_y,axe_z,rayon_cercle,rayon_tore,angle_seg,angle_rotation);
380  mgcg_forme->construire();
381  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme,lst_mgcg_forme);
382  }
383  else if (strcmp(key,"UNION")==0)
384  {
385  char var[400];
386  char var1[400];
387  char var2[400];
388  char sem[500];sem[0]=0;
389  sscanf(commande,"%s %s %s %s %s",key,var,var1,var2,sem);
390  char message[5000];
391  sprintf(message," Création d'un MG_CG_OP_BOOL_UNION et construction de la MG_CG_FORME \033[38;5;46m[%s]\033[1;33m",variable);
392  affiche(message);
393  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
394  MG_CG_FORME* mgcg_forme_entree_1 = get_list<MG_CG_FORME>(ligne,var1,lst_mgcg_forme);
395  MG_CG_FORME* mgcg_forme_entree_2 = get_list<MG_CG_FORME>(ligne,var2,lst_mgcg_forme);
396  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_UNION(mgcg_modele,get_semantique(sem),mgcg_forme_entree_1,mgcg_forme_entree_2);
397  mgcg_operateur->construire();
398  std::map<long,MG_CG_FORME*>::iterator it;
399  MG_CG_FORME* mgcg_forme_sortie = mgcg_operateur->get_premiere_mgcg_forme_sortie(it);
400  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme_sortie,lst_mgcg_forme);
401  }
402  else if (strcmp(key,"DIFF")==0)
403  {
404  char var[400];
405  char var1[400];
406  char var2[400];
407  char sem[500];sem[0]=0;
408  sscanf(commande,"%s %s %s %s %s",key,var,var1,var2,sem);
409  char message[5000];
410  sprintf(message," Création d'un MG_CG_OP_BOOL_DIFFERENCE et construction de la MG_CG_FORME \033[38;5;46m[%s]\033[1;33m",variable);
411  affiche(message);
412  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
413  MG_CG_FORME* mgcg_forme_entree_1 = get_list<MG_CG_FORME>(ligne,var1,lst_mgcg_forme);
414  MG_CG_FORME* mgcg_forme_entree_2 = get_list<MG_CG_FORME>(ligne,var2,lst_mgcg_forme);
415  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_DIFFERENCE(mgcg_modele,get_semantique(sem),mgcg_forme_entree_1,mgcg_forme_entree_2);
416  mgcg_operateur->construire();
417  std::map<long,MG_CG_FORME*>::iterator it;
418  MG_CG_FORME* mgcg_forme_sortie = mgcg_operateur->get_premiere_mgcg_forme_sortie(it);
419  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme_sortie,lst_mgcg_forme);
420  }
421  else if (strcmp(key,"INTER")==0)
422  {
423  char var[400];
424  char var1[400];
425  char var2[400];
426  char sem[500];sem[0]=0;
427  sscanf(commande,"%s %s %s %s %s",key,var,var1,var2,sem);
428  char message[5000];
429  sprintf(message," Création d'un MG_CG_OP_BOOL_INTERSECTION et construction de la MG_CG_FORME \033[38;5;46m[%s]\033[1;33m",variable);
430  affiche(message);
431  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
432  MG_CG_FORME* mgcg_forme_entree_1 = get_list<MG_CG_FORME>(ligne,var1,lst_mgcg_forme);
433  MG_CG_FORME* mgcg_forme_entree_2 = get_list<MG_CG_FORME>(ligne,var2,lst_mgcg_forme);
434  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(mgcg_modele,get_semantique(sem),mgcg_forme_entree_1,mgcg_forme_entree_2);
435  mgcg_operateur->construire();
436  std::map<long,MG_CG_FORME*>::iterator it;
437  MG_CG_FORME* mgcg_forme_sortie = mgcg_operateur->get_premiere_mgcg_forme_sortie(it);
438  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme_sortie,lst_mgcg_forme);
439  }
440  else if (strcmp(key,"FRAGMENT")==0)
441  {
442  char var[400];
443  char var1[400];
444  char var2[400];
445  char sem[500];sem[0]=0;
446  sscanf(commande,"%s %s %s %s %s",key,var,var1,var2,sem);
447  char message[5000];
448  sprintf(message," Création d'un MG_CG_OP_BOOL_FRAGMENT et construction de la MG_CG_FORME \033[38;5;46m[%s]\033[1;33m",variable);
449  affiche(message);
450  MG_CG_MODELE* mgcg_modele = get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
451  MG_CG_FORME* mgcg_forme_entree_1 = get_list<MG_CG_FORME>(ligne,var1,lst_mgcg_forme);
452  MG_CG_FORME* mgcg_forme_entree_2 = get_list<MG_CG_FORME>(ligne,var2,lst_mgcg_forme);
453  MG_CG_OPERATEUR* mgcg_operateur = MG_CG::creer_MG_CG_OP_BOOL_FRAGMENT(mgcg_modele,get_semantique(sem),mgcg_forme_entree_1,mgcg_forme_entree_2);
454  mgcg_operateur->construire();
455  std::map<long,MG_CG_FORME*>::iterator it;
456  MG_CG_FORME* mgcg_forme_sortie = mgcg_operateur->get_premiere_mgcg_forme_sortie(it);
457  ajouter_list<MG_CG_FORME>(ligne,variable,mgcg_forme_sortie,lst_mgcg_forme);
458  }
459  else if (strcmp(key,"TRISTLMODELE")==0)
460  {
461  char var[400];
462  char triSTL[400];
463  int importtri=0;
464  sscanf(commande,"%s %s %s",key,var,triSTL);
465  if(strcmp(triSTL,"TRISTL")==0)importtri=1;
466  if(strcmp(triSTL,"TRIANGULATION")==0)importtri=2;
467  MG_CG_MODELE* mgcg_modele=get_list<MG_CG_MODELE>(ligne,var,lst_mgcg_modele);
468  MG_GESTIONNAIRE *gest=mgcg_modele->get_mg_gestionnaire();
469  MG_GEOMETRIE* mg_geometrie=mgcg_modele->get_mg_geometrie();
470  MG_MAILLAGE* maillage_stl;
471  OCC_IMPORT occ_import;
472  maillage_stl = occ_import.importer_triangulation_V2017(*gest,mg_geometrie,mgcg_modele->get_epsilon_triangulation(),importtri);
473  char message[500];
474  sprintf(message," Generation de la triangulation STL de \033[38;5;46m[%s]\033[1;33m : ID = \033[1;31m%li\033[1;33m",var,maillage_stl->get_id());
475  affiche(message);
476  }
477  else if (strcmp(key,"TRISTLASSEMBLAGE")==0)
478  {
479  char var[400];
480  char triSTL[400];
481  int importtri=0;
482  sscanf(commande,"%s %s %s",key,var,triSTL);
483  if(strcmp(triSTL,"TRISTL")==0)importtri=1;
484  if(strcmp(triSTL,"TRIANGULATION")==0)importtri=2;
485  MG_CG_ASSEMBLAGE* mgcg_assemblage = get_list<MG_CG_ASSEMBLAGE>(ligne,var,lst_mgcg_assemblage);
486  MG_CG_MODELE* mgcg_modele=mgcg_assemblage->get_mgcg_modele();
487  MG_GESTIONNAIRE *gest=mgcg_modele->get_mg_gestionnaire();
488  MG_GEOMETRIE* mg_geometrie=mgcg_assemblage->get_mg_sous_geometrie();
489  MG_MAILLAGE* maillage_stl;
490  OCC_IMPORT occ_import;
491  maillage_stl = occ_import.importer_triangulation_V2017(*gest,mg_geometrie,mgcg_modele->get_epsilon_triangulation(),importtri);
492  char message[500];
493  sprintf(message," Generation de la triangulation STL de \033[38;5;46m[%s]\033[1;33m : ID = \033[1;31m%li\033[1;33m",var,maillage_stl->get_id());
494  affiche(message);
495  }
496  else if (strcmp(key,"BREPASSEMBLAGE")==0)
497  {
498  char var[400];
499  char nom[400];
500  sscanf(commande,"%s %s %s",key,var,nom);
501  char message[500];
502  sprintf(message," Exportation du modele BREP de \033[38;5;46m[%s]\033[1;33m",var);
503  affiche(message);
504  MG_CG_ASSEMBLAGE* mgcg_assemblage = get_list<MG_CG_ASSEMBLAGE>(ligne,var,lst_mgcg_assemblage);
505  MG_CG_MODELE* mgcg_modele=mgcg_assemblage->get_mgcg_modele();
506  MG_CG::exporter_fichier_brep(nom,mgcg_assemblage);
507  sprintf(message," Création du fichier \033[1;31m%s\033[1;33m ",nom);
508  affiche(message);
509  }
510 #endif
511  else if (strcmp(key,"ENREGISTRER")==0)
512  {
513  char var[400];
514  char nom[400];
515  sscanf(commande,"%s %s %s",key,var,nom);
516  affiche((char*)" Enregistrement d'un fichier MAGiC");
517  MG_GESTIONNAIRE *gest=get_list<MG_GESTIONNAIRE>(ligne,var,lstgest);
518  strcat(nom,".magic");
519  gest->enregistrer(nom);
520  char message[500];
521  sprintf(message," Création du fichier \033[1;31m%s\033[1;33m ",nom);
522  affiche(message);
523 
524  }
525 
526  else if (strcmp(key,"EXPORT_MG_GMSH")==0)
527  {
528  char var[400];
529  char nom[400];
530  int num=0;
531  sscanf(commande,"%s %s %s %d",key,var,nom,&num);
532  affiche((char*)" Exportation au format GMSH d'un maillage MG");
533  MG_GESTIONNAIRE *gest=get_list<MG_GESTIONNAIRE>(ligne,var,lstgest);
534  MG_EXPORT exp;
535  MG_MAILLAGE* mai=gest->get_mg_maillage(num-1);
536  exp.gmsh(mai,nom);
537  char message[500];
538  sprintf(message," Création du fichier \033[1;31m%s.msh\033[1;33m ",nom);
539  affiche(message);
540  }
541  else if (strcmp(key,"EXPORT_FEM_GMSH")==0)
542  {
543  char var[400];
544  char nom[400];
545  int num=0;
546  sscanf(commande,"%s %s %s %d",key,var,nom,&num);
547  affiche((char*)" Exportation au format GMSH d'un maillage FEM");
548  MG_GESTIONNAIRE *gest=get_list<MG_GESTIONNAIRE>(ligne,var,lstgest);
549  MG_EXPORT exp;
550  FEM_MAILLAGE* mai=gest->get_fem_maillage(num-1);
551  exp.gmsh(mai,nom);;
552  char message[500];
553  sprintf(message," Création du fichier \033[1;31m%s.msh\033[1;33m ",nom);
554  affiche(message);
555  }
556  else {char info[5000];sprintf(info," %s commande inconnue",commande);affiche_erreur(info);}
557  }
558  }
559  fgets(instruction,500,in);
560  }
561 
562 
563 
564 fclose(in);
565 affiche((char*)"Fin execution");
566 affiche((char*)"");
567 }
568 
569 
570 MAGIC_SCRIPT::~MAGIC_SCRIPT()
571 {
572 cpu.ajouter_etape("fin");
573 time_t fin;
574 time(&fin);
575 double ecoule=difftime(fin,debut)-CODE_ASTER_ECOULE;
576 affiche((char*)"\033[1;32m************************************************************");
577 char version[500];
578 double tps;
579 cpu.get_total(1,tps);
580  sprintf(version," MAGiC %s ",MAGIC_VERSION);
581  sprintf(version+20,"- CPU ");
582  sprintf(version+40,"- ECOULE ");
583 affiche(version);
584 if (CODE_ASTER_CPU>0)
585  {
586  sprintf(version," Total MAGiC ");
587  sprintf(version+20,": \033[1;31m%.2lfs\033[1;32m ",tps);
588  sprintf(version+54,": \033[1;31m%.0lfs\033[1;32m ",ecoule);
589  affiche(version);
590 if (CODE_ASTER_CPU>0)
591  {
592  //sprintf(version," Total Code Aster : \033[1;31m%.2lfs\033[1;32m \t : \033[1;31m%.0lfs\033[1;32m ",CODE_ASTER_CPU,CODE_ASTER_ECOULE);
593  sprintf(version," Total Code Aster : ");
594  sprintf(version+20,": \033[1;31m%.2lfs\033[1;32m ",CODE_ASTER_CPU);
595  sprintf(version+54,": \033[1;31m%.0lfs\033[1;32m ",CODE_ASTER_ECOULE);
596  affiche(version);
597  }
598 
599  }
600  sprintf(version," Total ");
601  sprintf(version+20,": \033[1;31m%.2lfs\033[1;32m ",CODE_ASTER_CPU+tps);
602  sprintf(version+54,": \033[1;31m%.0lfs\033[1;32m ",ecoule+CODE_ASTER_ECOULE);
603 affiche(version);
604 affiche((char*)"************************************************************\033[00m");
605 }
606 
607 void MAGIC_SCRIPT::upcase(char* chaine)
608 {
609  for (int i = 0; i < strlen(chaine); i++)
610  chaine[i]=toupper(chaine[i]);
611 }
612 
613 void MAGIC_SCRIPT::affiche(char* message)
614 {
615 std::cout << message << std::endl;
616 }
617 
CODE_ASTER_CPU
double CODE_ASTER_CPU
Definition: ot_cpu.cpp:26
MG_EXPORT
Definition: mg_export.h:33
MG_GESTIONNAIRE::enregistrer
virtual void enregistrer(std::ostream &o, double version=MAGIC_VERSION_FICHIER_DOUBLE)
Definition: mg_gestionnaire.cpp:1070
mg_cg_forme_volume_boite.h
mg_primitive_cylindre.h
mg_operateur_boolean_difference.h
mg_cg_forme.h
mg_geometrie.h
mg_cg_op_bool_intersection.h
mg_primitive_boite.h
mg_cg_op_bool_fragment.h
gestionversion.h
GESTIONVERSION::print
void print(char *version)
Definition: gestionversion.h:54
mg_cg.h
MAGIC::SEMANTIQUECSG::CHAMFREIN
@ CHAMFREIN
Definition: mg_definition.h:177
MG_IDENTIFICATEUR::get_id
unsigned long get_id()
Definition: mg_identificateur.cpp:53
MG_CG_MODELE::change_epsilon_triangulation
virtual void change_epsilon_triangulation(double val)
Definition: mg_cg_modele.cpp:1114
mg_cg_forme_volume_sphere.h
mg_arbre.h
MG_CG_MODELE::get_epsilon_triangulation
virtual double get_epsilon_triangulation(void)
Definition: mg_cg_modele.cpp:1119
MAGIC::SEMANTIQUECSG::PERCAGE
@ PERCAGE
Definition: mg_definition.h:177
MG_CG::creer_MG_CG_MODELE
static MG_CG_MODELE * creer_MG_CG_MODELE(MG_GESTIONNAIRE *mg_gestionnaire, std::string nom_mgcg_modele, double unite=1.0, double eps=1e-6)
Definition: mg_cg.cpp:75
mg_cg_forme_volume_cone.h
mg_cg_forme_volume_ellipsoide.h
MG_CG_ASSEMBLAGE::get_mgcg_modele
virtual MG_CG_MODELE * get_mgcg_modele(void)
Definition: mg_cg_assemblage.cpp:57
MG_CG::creer_MG_CG_OP_BOOL_UNION
static MG_CG_OP_BOOL_UNION * creer_MG_CG_OP_BOOL_UNION(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:305
mg_cg_forme_volume_tore.h
mg_file.h
MG_CG::creer_MG_CG_FORME_VOLUME_CYLINDRE
static MG_CG_FORME_VOLUME_CYLINDRE * creer_MG_CG_FORME_VOLUME_CYLINDRE(MG_CG_MODELE *mgcg_modele, double extremite_x, double extremite_y, double extremite_z, double direction_x, double direction_y, double direction_z, double rayon, double longueur)
Definition: mg_cg.cpp:243
OT_CPU::ajouter_etape
double ajouter_etape(std::string nom)
Definition: ot_cpu.cpp:58
mg_primitive_ellipsoide_revolution.h
MG_CG_ASSEMBLAGE::get_mg_sous_geometrie
virtual MG_SOUS_GEOMETRIE * get_mg_sous_geometrie(void)
Definition: mg_cg_assemblage.cpp:77
MAGIC::SEMANTIQUECSG::UNION
@ UNION
Definition: mg_definition.h:177
MG_GESTIONNAIRE
Definition: mg_gestionnaire.h:57
MAGIC::SEMANTIQUECSG::CONGE
@ CONGE
Definition: mg_definition.h:177
occ_import.h
GESTIONVERSION
Definition: gestionversion.h:51
parse.h
MG_CG_MODELE::change_importer_triangulation
virtual void change_importer_triangulation(bool val)
Definition: mg_cg_modele.cpp:1104
mg_cg_operateur.h
MAGIC_SCRIPT::get_semantique
int get_semantique(char *mess)
Definition: magic_script.cpp:113
OT_CPU::initialise
void initialise(void)
Definition: ot_cpu.cpp:49
MG_CG_MODELE::get_mg_geometrie
virtual MG_GEOMETRIE * get_mg_geometrie(void)
Definition: mg_cg_modele.cpp:98
magic_script.h
mg_cg_op_bool_union.h
MAGIC::SEMANTIQUECSG::EXTRUSION
@ EXTRUSION
Definition: mg_definition.h:177
MG_CG_FORME
Definition: mg_cg_forme.h:41
OCC_IMPORT::importer_triangulation_V2017
class MG_MAILLAGE * importer_triangulation_V2017(class MG_GESTIONNAIRE &gest, MG_GEOMETRIE *mggeo, double epsilon=1., int mode=1)
Definition: occ_import.cpp:1122
MAGIC_SCRIPT
Definition: magic_script.h:29
MG_CG_OPERATEUR
Definition: mg_cg_operateur.h:34
MAGIC_SCRIPT::~MAGIC_SCRIPT
~MAGIC_SCRIPT()
Definition: magic_script.cpp:570
mg_operateur_boolean_union.h
affiche_erreur
void affiche_erreur(char *message)
Definition: magic_script.cpp:65
mg_export.h
FEM_MAILLAGE
Definition: fem_maillage.h:66
MG_CG::creer_MG_CG_FORME_VOLUME_SPHERE
static MG_CG_FORME_VOLUME_SPHERE * creer_MG_CG_FORME_VOLUME_SPHERE(MG_CG_MODELE *mgcg_modele, double centre_x, double centre_y, double centre_z, double rayon)
Definition: mg_cg.cpp:215
MG_EXPORT::gmsh
void gmsh(class MG_MAILLAGE *mai, std::string fichier)
Definition: mg_export.cpp:803
MG_CG::creer_MG_CG_FORME_VOLUME_TORE
static MG_CG_FORME_VOLUME_TORE * creer_MG_CG_FORME_VOLUME_TORE(MG_CG_MODELE *mgcg_modele, double centre_x, double centre_y, double centre_z, double direction_x, double direction_y, double direction_z, double rayon_cercle, double rayon_tore, double angle_seg=2 *M_PI, double angle_rotation=0.0)
Definition: mg_cg.cpp:271
MAGIC_SCRIPT::execute
void execute(char *chemin)
Definition: magic_script.cpp:127
get_list
X * get_list(int ligne, std::string var, std::map< std::string, X * > &lst)
Definition: magic_script.cpp:86
MG_GESTIONNAIRE::get_fem_maillage
FEM_MAILLAGE * get_fem_maillage(unsigned int num)
Definition: mg_gestionnaire.cpp:670
MG_CG_MODELE
Definition: mg_cg_modele.h:41
MAGIC::SEMANTIQUECSG::INTERSECTION
@ INTERSECTION
Definition: mg_definition.h:177
PARSE::decode
void decode(char *code, std::string masque, class PARS_ARGUMENT *arg)
Definition: parse.cpp:71
mg_primitive_sphere.h
occ_fonction_v2017.h
MG_CG_ASSEMBLAGE
Definition: mg_cg_assemblage.h:37
MG_GESTIONNAIRE::get_mg_maillage
MG_MAILLAGE * get_mg_maillage(unsigned int num)
Definition: mg_gestionnaire.cpp:550
PARSE
Definition: parse.h:32
MAGIC::SEMANTIQUECSG::SANS
@ SANS
Definition: mg_definition.h:177
OT_CPU::get_total
void get_total(int num, double &temps)
Definition: ot_cpu.cpp:99
mg_operateur_boolean_intersection.h
mg_sous_geometrie.h
MG_CG::creer_MG_CG_OP_BOOL_FRAGMENT
static MG_CG_OP_BOOL_FRAGMENT * creer_MG_CG_OP_BOOL_FRAGMENT(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:347
MG_CG::creer_MG_CG_FORME_VOLUME_ELLIPSOIDE
static MG_CG_FORME_VOLUME_ELLIPSOIDE * creer_MG_CG_FORME_VOLUME_ELLIPSOIDE(MG_CG_MODELE *mgcg_modele, double centre_x, double centre_y, double centre_z, double direction_x, double direction_y, double direction_z, double rayon_majeur, double rayon_mineur)
Definition: mg_cg.cpp:229
MG_FILE
Definition: mg_file.h:31
MG_CG_OPERATEUR::get_premiere_mgcg_forme_sortie
virtual MG_CG_FORME * get_premiere_mgcg_forme_sortie(std::map< long, MG_CG_FORME * >::iterator &it)
Definition: mg_cg_operateur.cpp:224
OCC_IMPORT::importer_fichier_STEP_V2017
class MG_GEOMETRIE * importer_fichier_STEP_V2017(class MG_GESTIONNAIRE &gest, char *path_step, char *nom_caf, int typefichier, double precision=1e-6, bool fusionner_entite_similaire=false)
Definition: occ_import.cpp:118
mg_cg_forme_volume_cylindre.h
MG_CG_OPERATEUR::construire
virtual int construire(void)=0
mg_cg_modele.h
MG_CG_FORME::construire
virtual int construire(void)=0
mg_cg_assemblage.h
MG_CG::creer_MG_CG_FORME_VOLUME_BOITE
static MG_CG_FORME_VOLUME_BOITE * creer_MG_CG_FORME_VOLUME_BOITE(MG_CG_MODELE *mgcg_modele, double x1, double y1, double z1, double x2, double y2, double z2)
Definition: mg_cg.cpp:201
mg_primitive_tore.h
MAGIC::SEMANTIQUECSG::SOUSTRACTION
@ SOUSTRACTION
Definition: mg_definition.h:177
MG_CG::creer_MG_CG_ASSEMBLAGE
static MG_CG_ASSEMBLAGE * creer_MG_CG_ASSEMBLAGE(MG_CG_MODELE *mgcg_modele, std::string nom_mgcg_assemblage)
Definition: mg_cg.cpp:97
FICHIERSTEP
#define FICHIERSTEP
Definition: occ_import.h:57
PARS_ARGUMENT
Definition: pars_argument.h:37
MG_CG_MODELE::get_mg_gestionnaire
virtual MG_GESTIONNAIRE * get_mg_gestionnaire(void)
Definition: mg_cg_modele.cpp:83
MAGIC_VERSION
#define MAGIC_VERSION
Definition: version.h:5
MG_GEOMETRIE
Definition: mg_geometrie.h:84
MG_MAILLAGE
Definition: mg_maillage.h:62
MAGIC_SCRIPT::upcase
void upcase(char *chaine)
Definition: magic_script.cpp:607
MAGIC_SCRIPT::MAGIC_SCRIPT
MAGIC_SCRIPT(char *chemin)
Definition: magic_script.cpp:99
MG_CG::creer_MG_CG_FORME_VOLUME_CONE
static MG_CG_FORME_VOLUME_CONE * creer_MG_CG_FORME_VOLUME_CONE(MG_CG_MODELE *mgcg_modele, double extremite_x, double extremite_y, double extremite_z, double direction_x, double direction_y, double direction_z, double rayon, double longueur)
Definition: mg_cg.cpp:257
CODE_ASTER_ECOULE
double CODE_ASTER_ECOULE
Definition: ot_cpu.cpp:27
mg_primitive_cone.h
pars_argument.h
MG_GESTIONNAIRE::ajouter_mgcg_modele
int ajouter_mgcg_modele(MG_CG_MODELE *mgcg_modele)
Definition: mg_gestionnaire.cpp:96
mg_cg_op_bool_difference.h
MG_CG_ASSEMBLAGE::ajouter_mgcg_forme
virtual int ajouter_mgcg_forme(MG_CG_FORME *mgcg_forme, bool avec_mg_element=true)
Definition: mg_cg_assemblage.cpp:87
MAGIC_SCRIPT::debut
time_t debut
Definition: magic_script.h:40
OCC_IMPORT
Definition: occ_import.h:60
MAGIC_SCRIPT::cpu
OT_CPU cpu
Definition: magic_script.h:41
MAGIC_SCRIPT::affiche
static void affiche(char *message)
Definition: magic_script.cpp:613
MG_CG::exporter_fichier_brep
static int exporter_fichier_brep(char *nom, MG_CG_MODELE *mgcg_modele)
Definition: mg_cg.cpp:432
MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION
static MG_CG_OP_BOOL_INTERSECTION * creer_MG_CG_OP_BOOL_INTERSECTION(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:333
ajouter_list
void ajouter_list(int ligne, std::string var, X *x, std::map< std::string, X * > &lst)
Definition: magic_script.cpp:71
MG_CG::creer_MG_CG_OP_BOOL_DIFFERENCE
static MG_CG_OP_BOOL_DIFFERENCE * creer_MG_CG_OP_BOOL_DIFFERENCE(MG_CG_MODELE *mgcg_modele, int semantique, MG_CG_FORME *mgcg_forme_entree_1, MG_CG_FORME *mgcg_forme_entree_2)
Definition: mg_cg.cpp:319
mg_assemblage.h
MG_CG_MODELE::change_fusionner_entite_similaire
virtual void change_fusionner_entite_similaire(bool val)
Definition: mg_cg_modele.cpp:1084