MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
mgopt_posttraitement.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 //####// mgopt_posttraitement.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 "mgopt_posttraitement.h"
24 #include "fem_solution.h"
25 #include "fem_maillage.h"
26 #include "mg_maillage.h"
27 #include "mg_gestionnaire.h"
28 #include "mg_triangle_peau.h"
29 #include "mg_geometrie_outils.h"
30 #include "fem_maillage_outils.h"
31 #include "tpl_fonctions_generiques.h"
32 #include "ot_algorithme_geometrique.h"
33 #include "mg_maillage_outils.h"
34 #include "mailleur_analyse.h"
35 #include "mg_arete_element.h"
36 #include "mg_face_element.h"
37 #include "mg_volume_element.h"
38 #include "mg_sommet_noeud.h"
39 #include "mg_export.h"
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <time.h>
43 #include <string.h>
44 #include <math.h>
45 #include <complex>
46 #include "mailleur_analyse.h"
47 #include "m3d_triangle.h"
48 #include "fct_taille.h"
49 #include "mg_segment.h"
50 
51 
52 
53 MGOPT_POSTTRAITEMENT::MGOPT_POSTTRAITEMENT():affichageactif(0)
54 {
55 for (int i=0;i<9;i++) etat[i]=0;
56 params.ajouter("decoupage",0.,OT_PARAMETRES::DOUBLE,"0. découpage en conservant les mailles entieres 1. découpage par isodensite");
57 params.ajouter("seuil",0.5,OT_PARAMETRES::DOUBLE,"Valeur du seuil de densité pour les 2 découpages");
58 params.ajouter("nomdensextra","densiteextra.sol",OT_PARAMETRES::STRING,"Nom du fichier comportant la solution de la densité extrapolé au noeud");
59 params.ajouter("consimpose",1.,OT_PARAMETRES::DOUBLE,"0. Maillage non design non inclus dans le decoupage par mailles entieres 1. Maillage design inclus");
60 params.ajouter("consoptimise",1.,OT_PARAMETRES::DOUBLE,"0. Maillage optimise non inclus dans le decoupage par mailles entieres 1. Maillage optimise inclus");
61 params.ajouter("consnooptimise",0.,OT_PARAMETRES::DOUBLE,"0. Maillage non optimise non inclus dans le decoupage par mailles entieres 1. Maillage non optimise inclus");
62 params.ajouter("reactivation",1.,OT_PARAMETRES::DOUBLE,"1. Reactivation de mailles isolées sur le long des aretes 0. non reactivation");
63 params.ajouter("liss_aretes2017_nbiter",0.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations du lissage des arêtes 0. méthode non utilisee");
64 params.ajouter("liss_aretes2017_lambda",0.8,OT_PARAMETRES::DOUBLE,"Paramète de relaxation lambda du lissage Laplacien des arêtes, la valeur doit être positive et moins de 1");
65 params.ajouter("chen2005_debut",0.,OT_PARAMETRES::DOUBLE,"Numero d'itération du debut d'application du lissage de chen2005 0. méthode non utilisee");
66 params.ajouter("chen2005_itermax",10.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales du lissage de chen2005");
67 params.ajouter("chen2005_epsilon",0.01,OT_PARAMETRES::DOUBLE,"Critere de convergence du lissage de chen2005");
68 params.ajouter("chen2005_sigma",0.1,OT_PARAMETRES::DOUBLE,"Écart type du filtre de lissage de chen2005");
69 params.ajouter("chen2005_filtre",1.,OT_PARAMETRES::DOUBLE,"Choix du filtre de lissage de chen2005 1. Gaussian 2.Laplacien 3.elfallahford");
70 params.ajouter("chen2008_debut",0.,OT_PARAMETRES::DOUBLE,"Numero d'itération du debut d'application deu lissage de chen2008 0. méthode non utilisee");
71 params.ajouter("chen2008_itermax",10.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales du lissage de chen2008");
72 params.ajouter("chen2008_epsilon",0.01,OT_PARAMETRES::DOUBLE,"Critere de convergence du lissage de chen2008");
73 params.ajouter("chen2008_sigma",0.1,OT_PARAMETRES::DOUBLE,"Écart type du filtre de lissage de chen2008");
74 params.ajouter("chen2008_gamma",1.,OT_PARAMETRES::DOUBLE,"Vitesse d'avancement de déplacement du lissage de chen2008");
75 params.ajouter("chen2008_filtre",1.,OT_PARAMETRES::DOUBLE,"Choix du filtre de lissage de chen2008 1. Gaussian 2.Laplacien 3.elfallahford");
76 params.ajouter("jiao2012_debut",0.,OT_PARAMETRES::DOUBLE,"Numero d'itération du debut d'application deu lissage de jiao2012 0. méthode non utilisee");
77 params.ajouter("jiao2012_itermax",10.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales du lissage de jioa2012");
78 params.ajouter("McKenzie2016_debut",0.,OT_PARAMETRES::DOUBLE,"Numero d'itération du debut d'application du lissage de McKenzie2016 0. méthode non utilisee");
79 params.ajouter("McKenzie2016_lambda",0.33,OT_PARAMETRES::DOUBLE,"Paramète lambda, la valeur doit être positive");
80 params.ajouter("McKenzie2016_nu",-0.34,OT_PARAMETRES::DOUBLE,"Paramète nu, la valeur doit être negative et respecter 0<lambda<(-nu)");
81 params.ajouter("McKenzie2016_epsilon", 0.01000, OT_PARAMETRES::DOUBLE,"Critere de convergence du lissage de chen2008");
82 params.ajouter("McKenzie2016_sigma", 0.10000, OT_PARAMETRES::DOUBLE,"Écart type du filtre de lissage de chen2008");
83 params.ajouter("McKenzie2016_gamma_", 1.0, OT_PARAMETRES::DOUBLE,"Vitesse d'avancement de déplacement du lissage de chen2008");
84 params.ajouter("McKenzie2016_filtre", 1.0, OT_PARAMETRES::DOUBLE,"Choix du filtre de lissage de chen2008 1. Gaussian 2.Laplacien 3.elfallahford");
85 params.ajouter("McKenzie2016_itertaubmax",100.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales de la partie taubin du lissage de McKenzie2016");
86 params.ajouter("McKenzie2016_itermax",100.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales de la partie chen 2008 du lissage de McKenzie2016");
87 params.ajouter("Taubin1995_debut",0.,OT_PARAMETRES::DOUBLE,"Numero d'itération du debut d'application du lissage de Taubin1995 0. méthode non utilisee");
88 params.ajouter("Taubin1995_lambda",0.33,OT_PARAMETRES::DOUBLE,"Paramète lambda, la valeur doit être positive et moins de 1");
89 params.ajouter("Taubin1995_nu",-0.34,OT_PARAMETRES::DOUBLE,"Paramète nu, la valeur doit être negative et respecter 0<lambda<(-nu)");
90 params.ajouter("Taubin1995_itermax",100.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales du lissage Taubin1995");
91 params.ajouter("cardinalite_debut",0.,OT_PARAMETRES::DOUBLE,"Numero d'itération du debut d'application de l'étude de cardinalite des noeuds");
92 params.ajouter("cardinalite_iter",2.,OT_PARAMETRES::DOUBLE,"Nombre d'itérations maximales de l'étude de cardinalite des noeuds");
93 params.ajouter("rmimpose_debut",0.,OT_PARAMETRES::DOUBLE,"0. Pas de suppression 1. Suppression du non_design du resultat optimal.");
94 params.ajouter("nomfichpeau","peausansnondesign.magic",OT_PARAMETRES::STRING,"Nom en .magic du fichier de sortie apres suppression du non design");
95 }
96 
97 
98 MGOPT_POSTTRAITEMENT::~MGOPT_POSTTRAITEMENT()
99 {
100 for (int i=0;i<lst_peau.size();i++)
101  delete lst_peau[i];
102 }
103 
104 void MGOPT_POSTTRAITEMENT::active_affichage(void (*fonc)(char*))
105 {
106 affiche=fonc;
107 affichageactif=1;
108 }
109 
110 
111 
112 void MGOPT_POSTTRAITEMENT::posttraite(char *fichier)
113 {
114 affiche((char*)"");
115 affiche((char*)"***********************************************************");
116 affiche((char*)"Post-traitement d'un calcul d'optimisation de topologie");
117 affiche((char*)"***********************************************************");
118 affiche((char*)"");
119 affiche((char*)"");
120 affiche((char*)"");
121 affiche((char*)"Écriture d'un fichier de parametres par défaut");
122 params.enregistrer(fichier);
123 }
124 
125 
126 
127 void MGOPT_POSTTRAITEMENT::conserve(int origine)
128 {
129 etat[(origine-1000)/10]=1;
130 }
131 
132 
133 void MGOPT_POSTTRAITEMENT::copieorigine(FEM_MAILLAGE* mai)
134 {
135 LISTE_FEM_ELEMENT3::iterator it_tetra;
136 for (FEM_ELEMENT3* tet=mai->get_premier_element3(it_tetra);tet!=NULL;tet=mai->get_suivant_element3(it_tetra))
137  {
138  MG_TETRA* mgtet=(MG_TETRA*)tet->get_mg_element_maillage();
139  mgtet->change_origine(mgtet->get_origine());
140  }
141 }
142 
143 
144 void MGOPT_POSTTRAITEMENT::calcul_volume_ini(MG_MAILLAGE* mg_mai, double *volumetot,double *volumenondesign)
145 {
146 LISTE_MG_TETRA::iterator it_tetra;
147 double volume_initial = 0.;
148 double volume_final = 0.;
149 for (MG_TETRA* mgtet=mg_mai->get_premier_tetra(it_tetra);mgtet!=NULL;mgtet=mg_mai->get_suivant_tetra(it_tetra))
150  {
151  int originetet=mgtet->get_origine();
152  MG_NOEUD* noeud1 = mgtet->get_noeud1();
153  double x1 = noeud1->get_x();
154  double y1 = noeud1->get_y();
155  double z1 = noeud1->get_z();
156  MG_NOEUD* noeud2 = mgtet->get_noeud2();
157  double x2 = noeud2->get_x();
158  double y2 = noeud2->get_y();
159  double z2 = noeud2->get_z();
160  MG_NOEUD* noeud3 = mgtet->get_noeud3();
161  double x3 = noeud3->get_x();
162  double y3 = noeud3->get_y();
163  double z3 = noeud3->get_z();
164  MG_NOEUD* noeud4 = mgtet->get_noeud4();
165  double x4 = noeud4->get_x();
166  double y4 = noeud4->get_y();
167  double z4 = noeud4->get_z();
168  double volume_tet = (x2-x1)*((y3-y1)*(z4-z1)-(z3-z1)*(y4-y1))-(y2-y1)*((x3-x1)*(z4-z1)-(z3-z1)*(x4-x1)) + (z2-z1)*((x3-x1)*(y4-y1)-(y3-y1)*(x4-x1));
169  volume_tet = volume_tet/6.;
170  volume_initial = volume_initial + volume_tet;
171  if (originetet == MAGIC::ORIGINE::IMPOSE)
172  {
173  volume_final = volume_final + volume_tet;
174  }
175  }
176 *volumetot=volume_initial;
177 *volumenondesign=volume_final;
178 }
179 
180 void MGOPT_POSTTRAITEMENT::reactivation(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2)
181 {
182 std::cout << " Reactivation d'elements manquants sur aretes vives et faces planes" << std::endl;
183 LISTE_MG_TETRA::iterator it_tetra;
184 for (MG_TETRA* mgtet=mg_mai->get_premier_tetra(it_tetra);mgtet!=NULL;mgtet=mg_mai->get_suivant_tetra(it_tetra))
185  {
186  int originetet=mgtet->get_origine();
187  int compteur = 0;
188  if (originetet == MAGIC::ORIGINE::MAILLEUR_AUTO)
189  {
190  MG_TRIANGLE* tri1 = mgtet->get_triangle1();
191  MG_TRIANGLE* tri2 = mgtet->get_triangle2();
192  MG_TRIANGLE* tri3 = mgtet->get_triangle3();
193  MG_TRIANGLE* tri4 = mgtet->get_triangle4();
194  int nb_tet1 = tri1->get_lien_tetra()->get_nb();
195  for (int k = 0;k<nb_tet1;k++)
196  {
197  MG_TETRA* tet1 = tri1->get_lien_tetra()->get(k);
198  int ori1 = tet1->get_origine();
199  if ((tet1 != mgtet) && (ori1 == MAGIC::ORIGINE::MAILLEUR_AUTO)) compteur++;
200  }
201  int nb_tet2 = tri2->get_lien_tetra()->get_nb();
202  for (int k = 0;k<nb_tet2;k++)
203  {
204  MG_TETRA* tet2 = tri2->get_lien_tetra()->get(k);
205  int ori2 = tet2->get_origine();
206  if ((tet2 != mgtet) && (ori2 == MAGIC::ORIGINE::MAILLEUR_AUTO)) compteur++;
207  }
208  int nb_tet3 = tri3->get_lien_tetra()->get_nb();
209  for (int k = 0;k<nb_tet3;k++)
210  {
211  MG_TETRA* tet3 = tri3->get_lien_tetra()->get(k);
212  int ori3 = tet3->get_origine();
213  if ((tet3 != mgtet) && (ori3 == MAGIC::ORIGINE::MAILLEUR_AUTO)) compteur++;
214  }
215  int nb_tet4 = tri4->get_lien_tetra()->get_nb();
216  for (int k = 0;k<nb_tet4;k++)
217  {
218  MG_TETRA* tet4 = tri4->get_lien_tetra()->get(k);
219  int ori4 = tet4->get_origine();
220  if ((tet4 != mgtet) && (ori4 == MAGIC::ORIGINE::MAILLEUR_AUTO)) compteur++;
221  }
222  if (compteur == 0) mgtet->change_origine(MAGIC::ORIGINE::OPTIMISE);
223  }
224  }
225 }
226 
227 
228 
229 
230 MG_MAILLAGE* MGOPT_POSTTRAITEMENT::extract_skin_par_decoupage(FEM_SOLUTION* sol,double limit,MG_GESTIONNAIRE& gest2,std::string nom)
231 {
232 affiche((char*)"Extraction de l'enveloppe par découpage");
233 sol->active_solution(0);
234 FEM_MAILLAGE* mai=sol->get_maillage();
235 affiche((char*)" Extrapolation de la densité aux noeuds");
236 LISTE_FEM_NOEUD::iterator it;
237 for (FEM_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
238  {
239  double nume=0.;
240  double deno=0.;
241  int nb=no->get_lien_element3()->get_nb();
242  int passe=0;
243  for (int i=0;i<nb;i++)
244  {
245  FEM_ELEMENT3* tet=no->get_lien_element3()->get(i);
246  if (tet->get_mg_element_maillage()->get_origine()!=MAGIC::ORIGINE::IMPOSE)
247  {
248  double jac[9];
249  double volume=tet->get_jacobien(jac,jac,1.);
250  passe=1;
251  nume=nume+tet->get_solution()*volume;
252  deno=deno+volume;
253  }
254  }
255  if (passe==1) no->change_solution(nume/deno); else no->change_solution(1.);
256  }
257 if (nom!="")
258  {
259  affiche((char*)" Enregistrement de la densité aux noeuds");
260  MG_GESTIONNAIRE *gest=mai->get_mg_maillage()->get_gestionnaire();
261  std::string chemin=nom+".sol";
262  FEM_SOLUTION* femdens=new FEM_SOLUTION(mai,1,(char*)chemin.c_str(),mai->get_nb_fem_element3(),"Extrapolation aux noeuds",MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3_NOEUD,MAGIC::TYPE_SOLUTION::SCALAIRE);
263  gest->ajouter_fem_solution(femdens);
264  femdens->change_legende(0,"Densite");
265  LISTE_FEM_ELEMENT3::iterator it3;
266  int i=0;
267  for (FEM_ELEMENT3* tet=mai->get_premier_element3(it3);tet!=NULL;tet=mai->get_suivant_element3(it3))
268  {
269  MG_TETRA* tet2=(MG_TETRA*)tet->get_mg_element_maillage();
270  if (tet2->get_origine()==MAGIC::ORIGINE::IMPOSE)
271  {
272  femdens->ecrire(1.,i,0,0);
273  femdens->ecrire(1.,i,0,1);
274  femdens->ecrire(1.,i,0,2);
275  femdens->ecrire(1.,i,0,3);
276  }
277  else
278  {
279  femdens->ecrire(tet->get_fem_noeud(0)->get_solution(),i,0,0);
280  femdens->ecrire(tet->get_fem_noeud(1)->get_solution(),i,0,1);
281  femdens->ecrire(tet->get_fem_noeud(2)->get_solution(),i,0,2);
282  femdens->ecrire(tet->get_fem_noeud(3)->get_solution(),i,0,3);
283  }
284  i++;
285  }
286  MG_EXPORT exp;
287  exp.gmsh(mai,nom);
288  gest->supprimer_fem_solution(gest->get_nb_fem_solution()-1);
289  }
290 gest2.vide();
291 MG_GEOMETRIE* geo=new MG_GEOMETRIE((char*)"VIRTUEL",(char*)"VIRTUEL");
292 geo->change_valeur_unite(mai->get_mg_geometrie()->get_valeur_unite());
293 gest2.ajouter_mg_geometrie(geo);
294 MG_VOLUME_ELEMENT* vol=new MG_VOLUME_ELEMENT();
295 geo->ajouter_mg_volume(vol);
296 vol->copie_ccf(*(mai->get_mg_geometrie()->get_mg_volume(0)));
297 std::map<unsigned long,unsigned long> correspondidsom;
298 std::map<unsigned long,unsigned long> correspondid;
299 LISTE_MG_SOMMET::iterator its;
300 for (MG_SOMMET* som=mai->get_mg_geometrie()->get_premier_sommet(its);som!=NULL;som=mai->get_mg_geometrie()->get_suivant_sommet(its))
301  {
302  if (som->get_nb_ccf()>0)
303  {
304  MG_SOMMET_NOEUD* somno=new MG_SOMMET_NOEUD();
305  geo->ajouter_mg_sommet(somno);
306  somno->copie_ccf(*som);
307  correspondidsom[som->get_id()]=somno->get_id();
308  }
309  }
310 LISTE_MG_ARETE::iterator ita;
311 for (MG_ARETE* are=mai->get_mg_geometrie()->get_premier_arete(ita);are!=NULL;are=mai->get_mg_geometrie()->get_suivant_arete(ita))
312  {
313  if (are->get_nb_ccf()>0)
314  {
315  MG_ARETE_ELEMENT* areel=new MG_ARETE_ELEMENT();
316  geo->ajouter_mg_arete(areel);
317  areel->copie_ccf(*are);
318  correspondid[are->get_id()]=areel->get_id();
319  }
320  }
321 LISTE_MG_FACE::iterator itf;
322 for (MG_FACE* face=mai->get_mg_geometrie()->get_premier_face(itf);face!=NULL;face=mai->get_mg_geometrie()->get_suivant_face(itf))
323  {
324  if (face->get_nb_ccf()>0)
325  {
326  MG_FACE_ELEMENT* facel=new MG_FACE_ELEMENT();
327  geo->ajouter_mg_face(facel);
328  facel->copie_ccf(*face);
329  correspondid[face->get_id()]=facel->get_id();
330  }
331  }
332 MG_FACE_ELEMENT* faceex=new MG_FACE_ELEMENT();
333 geo->ajouter_mg_face(faceex);
334 MG_FACE_ELEMENT* facenoex=new MG_FACE_ELEMENT();
335 geo->ajouter_mg_face(facenoex);
336 MG_MAILLAGE* mgmai=new MG_MAILLAGE(geo);
337 gest2.ajouter_mg_maillage(mgmai);
338 
339 MG_MAILLAGE* mgfem=mai->get_mg_maillage();
340 LISTE_MG_TRIANGLE::iterator itmg;
341 for (MG_TRIANGLE* tri=mgfem->get_premier_triangle(itmg);tri!=NULL;tri=mgfem->get_suivant_triangle(itmg))
342  tri->change_nouveau_numero(0);
343 affiche((char*)" Decoupage des tetra optimises");
344 LISTE_FEM_ELEMENT3::iterator it3;
345 for (FEM_ELEMENT3* tet=mai->get_premier_element3(it3);tet!=NULL;tet=mai->get_suivant_element3(it3))
346 {
347 MG_TETRA* tet2=(MG_TETRA*)tet->get_mg_element_maillage();
348 if (tet2->get_origine()==MAGIC::ORIGINE::IMPOSE)
349  {
350  tet2->get_triangle1()->change_origine(MAGIC::ORIGINE::IMPOSE);
351  tet2->get_triangle2()->change_origine(MAGIC::ORIGINE::IMPOSE);
352  tet2->get_triangle3()->change_origine(MAGIC::ORIGINE::IMPOSE);
353  tet2->get_triangle4()->change_origine(MAGIC::ORIGINE::IMPOSE);
354  tet2->get_noeud1()->change_solution(tet->get_fem_noeud(0)->get_solution());
355  tet2->get_noeud2()->change_solution(tet->get_fem_noeud(1)->get_solution());
356  tet2->get_noeud3()->change_solution(tet->get_fem_noeud(2)->get_solution());
357  tet2->get_noeud4()->change_solution(tet->get_fem_noeud(3)->get_solution());
358  tet2->get_noeud1()->change_nouveau_numero(tet->get_fem_noeud(0)->get_id());
359  tet2->get_noeud2()->change_nouveau_numero(tet->get_fem_noeud(1)->get_id());
360  tet2->get_noeud3()->change_nouveau_numero(tet->get_fem_noeud(2)->get_id());
361  tet2->get_noeud4()->change_nouveau_numero(tet->get_fem_noeud(3)->get_id());
362  if (tet2->get_triangle1()->get_nouveau_numero()==0)
363  tet2->get_triangle1()->change_nouveau_numero(tet2->get_noeud4()->get_id());
364  else
365  tet2->get_triangle1()->change_nouveau_numero(-1);
366  if (tet2->get_triangle2()->get_nouveau_numero()==0)
367  tet2->get_triangle2()->change_nouveau_numero(tet2->get_noeud3()->get_id());
368  else
369  tet2->get_triangle2()->change_nouveau_numero(-1);
370  if (tet2->get_triangle3()->get_nouveau_numero()==0)
371  tet2->get_triangle3()->change_nouveau_numero(tet2->get_noeud1()->get_id());
372  else
373  tet2->get_triangle3()->change_nouveau_numero(-1);
374  if (tet2->get_triangle4()->get_nouveau_numero()==0)
375  tet2->get_triangle4()->change_nouveau_numero(tet2->get_noeud2()->get_id());
376  else
377  tet2->get_triangle4()->change_nouveau_numero(-1);
378  }
379 }
380 
381 TPL_LISTE_ENTITE<MG_TRIANGLE*> tri_impose_interne;
382 for (MG_TRIANGLE* tri=mgfem->get_premier_triangle(itmg);tri!=NULL;tri=mgfem->get_suivant_triangle(itmg))
383 {
384 if (tri->get_origine()==MAGIC::ORIGINE::IMPOSE)
385  if (tri->get_lien_topologie()->get_dimension()==3)
386  if (tri->get_nouveau_numero()>0)
387  tri_impose_interne.ajouter(tri);
388 }
389 for (FEM_ELEMENT3* tet=mai->get_premier_element3(it3);tet!=NULL;tet=mai->get_suivant_element3(it3))
390  {
391  if (tet->get_mg_element_maillage()->get_origine()!=MAGIC::ORIGINE::IMPOSE)
392  {
393  FEM_NOEUD* no1=tet->get_fem_noeud(0);
394  FEM_NOEUD* no2=tet->get_fem_noeud(1);
395  FEM_NOEUD* no3=tet->get_fem_noeud(2);
396  FEM_NOEUD* no4=tet->get_fem_noeud(3);
397  std::vector<MG_NOEUD*> tab;
398  interpole_segment(mai,no1,no2,&tab,limit,mgmai);
399  interpole_segment(mai,no1,no3,&tab,limit,mgmai);
400  interpole_segment(mai,no1,no4,&tab,limit,mgmai);
401  interpole_segment(mai,no2,no3,&tab,limit,mgmai);
402  interpole_segment(mai,no2,no4,&tab,limit,mgmai);
403  interpole_segment(mai,no3,no4,&tab,limit,mgmai);
404  int nb=tab.size();
405  FEM_NOEUD* noext;
406  if (nb>0)
407  {
408  if (no1->get_solution()<limit) noext=no1;
409  if (no2->get_solution()<limit) noext=no2;
410  if (no3->get_solution()<limit) noext=no3;
411  if (no4->get_solution()<limit) noext=no4;
412  }
413  if (nb==3)
414  {
415  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[0],tab[1],tab[2],mgmai,MAGIC::ORIGINE::TRIANGULATION);
416  oriente_tri(tri,noext->get_coord());
417  }
418  if (nb==4)
419  {
420  if (test_du_point_milieu(tab[0],tab[1],tet)==1)
421  {
422  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[0],tab[1],tab[2],mgmai,MAGIC::ORIGINE::TRIANGULATION);
423  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[0],tab[1],tab[3],mgmai,MAGIC::ORIGINE::TRIANGULATION);
424  oriente_tri(tri,noext->get_coord());
425  oriente_tri(tri2,noext->get_coord());
426  }
427  else if (test_du_point_milieu(tab[0],tab[2],tet)==1)
428  {
429  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[0],tab[2],tab[1],mgmai,MAGIC::ORIGINE::TRIANGULATION);
430  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[0],tab[2],tab[3],mgmai,MAGIC::ORIGINE::TRIANGULATION);
431  oriente_tri(tri,noext->get_coord());
432  oriente_tri(tri2,noext->get_coord());}
433  else if (test_du_point_milieu(tab[0],tab[3],tet)==1)
434  {
435  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[0],tab[3],tab[1],mgmai,MAGIC::ORIGINE::TRIANGULATION);
436  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[0],tab[3],tab[2],mgmai,MAGIC::ORIGINE::TRIANGULATION);
437  oriente_tri(tri,noext->get_coord());
438  oriente_tri(tri2,noext->get_coord());}
439  else if (test_du_point_milieu(tab[1],tab[2],tet)==1)
440  {
441  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[1],tab[2],tab[0],mgmai,MAGIC::ORIGINE::TRIANGULATION);
442  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[1],tab[2],tab[3],mgmai,MAGIC::ORIGINE::TRIANGULATION);
443  oriente_tri(tri,noext->get_coord());
444  oriente_tri(tri2,noext->get_coord());
445  }
446  else if (test_du_point_milieu(tab[1],tab[3],tet)==1)
447  {
448  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[1],tab[3],tab[0],mgmai,MAGIC::ORIGINE::TRIANGULATION);
449  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[1],tab[3],tab[2],mgmai,MAGIC::ORIGINE::TRIANGULATION);
450  oriente_tri(tri,noext->get_coord());
451  oriente_tri(tri2,noext->get_coord());}
452  else
453  {
454  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[2],tab[3],tab[0],mgmai,MAGIC::ORIGINE::TRIANGULATION);
455  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[2],tab[3],tab[1],mgmai,MAGIC::ORIGINE::TRIANGULATION);
456  oriente_tri(tri,noext->get_coord());
457  oriente_tri(tri2,noext->get_coord());
458  }
459 
460  }
461  }
462  }
463 affiche((char*)" Decoupage des triangles non design interne au volume");
464 for (int i=0;i<tri_impose_interne.get_nb();i++)
465  {
466  MG_TRIANGLE* tri=tri_impose_interne.get(i);
467  MG_NOEUD* no1=tri->get_noeud1();
468  MG_NOEUD* no2=tri->get_noeud2();
469  MG_NOEUD* no3=tri->get_noeud3();
470  std::vector<MG_NOEUD*> tab;
471  int num1=-1;
472  int num2=-1;
473  int num3=-1;
474  if (no1->get_solution()<limit)
475  {
476  MG_NOEUD* no=get_noeud_peau(mai->get_fem_noeudid(no1->get_nouveau_numero()),mgmai,correspondidsom,geo);
477  tab.push_back(no);
478  num1=1;
479  }
480  if (no2->get_solution()<limit)
481  {
482  MG_NOEUD* no=get_noeud_peau(mai->get_fem_noeudid(no2->get_nouveau_numero()),mgmai,correspondidsom,geo);
483  tab.push_back(no);
484  num2=1;
485  }
486  if (no3->get_solution()<limit)
487  {
488  MG_NOEUD* no=get_noeud_peau(mai->get_fem_noeudid(no3->get_nouveau_numero()),mgmai,correspondidsom,geo);
489  tab.push_back(no);
490  num3=1;
491  }
492  if (num1*num2<0) interpole_segment(mai,mai->get_fem_noeudid(no1->get_nouveau_numero()),mai->get_fem_noeudid(no2->get_nouveau_numero()),&tab,limit,mgmai);
493  if (num1*num3<0) interpole_segment(mai,mai->get_fem_noeudid(no1->get_nouveau_numero()),mai->get_fem_noeudid(no3->get_nouveau_numero()),&tab,limit,mgmai);
494  if (num2*num3<0) interpole_segment(mai,mai->get_fem_noeudid(no2->get_nouveau_numero()),mai->get_fem_noeudid(no3->get_nouveau_numero()),&tab,limit,mgmai);
495  MG_NOEUD* noint=mgfem->get_mg_noeudid(tri->get_nouveau_numero());
496  int nb=tab.size();
497  if (nb==3)
498  {
499  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[0],tab[1],tab[2],mgmai,MAGIC::ORIGINE::IMPOSE);
500  oriente_tri(tri,noint->get_coord());
501  tri->inverse_sens();
502  }
503  if (nb==4)
504  {
505  MG_TRIANGLE_PEAU* tri=insere_triangle(facenoex,tab[0],tab[1],tab[2],mgmai,MAGIC::ORIGINE::IMPOSE);
506  MG_TRIANGLE_PEAU* tri2=insere_triangle(facenoex,tab[1],tab[2],tab[3],mgmai,MAGIC::ORIGINE::IMPOSE);
507  oriente_tri(tri,noint->get_coord());
508  tri->inverse_sens();
509  oriente_tri(tri2,noint->get_coord());
510  tri2->inverse_sens();
511  }
512  }
513 affiche((char*)" Decoupage des triangles sur la frontiere du volume");
514 LISTE_FEM_ELEMENT2::iterator it2;
515 for (FEM_ELEMENT2* tri=mai->get_premier_element2(it2);tri!=NULL;tri=mai->get_suivant_element2(it2))
516  {
517  std::vector<MG_NOEUD*> tab;
518  FEM_NOEUD *no1=tri->get_fem_noeud(0);
519  FEM_NOEUD *no2=tri->get_fem_noeud(1);
520  FEM_NOEUD *no3=tri->get_fem_noeud(2);
521  int ori=((MG_FACE*)tri->get_lien_topologie())->get_mg_coface(0)->get_orientation();
522  OT_VECTEUR_3D n1n2(no1->get_coord(),no2->get_coord());
523  OT_VECTEUR_3D n1n3(no1->get_coord(),no3->get_coord());
524  OT_VECTEUR_3D nor=n1n3&n1n2;
525  double xyzext[3];
526  xyzext[0]=no1->get_x()+nor.get_x()*ori;
527  xyzext[1]=no1->get_y()+nor.get_y()*ori;
528  xyzext[2]=no1->get_z()+nor.get_z()*ori;
529  if (tri->get_mg_element_maillage()->get_origine()==MAGIC::ORIGINE::IMPOSE)
530  {
531  MG_NOEUD *mgno1=get_noeud_peau(no1,mgmai,correspondidsom,geo);
532  MG_NOEUD *mgno2=get_noeud_peau(no2,mgmai,correspondidsom,geo);
533  MG_NOEUD *mgno3=get_noeud_peau(no3,mgmai,correspondidsom,geo);
534  int num1=interpole_segment(mai,no1,no2,&tab,limit,mgmai,0);
535  int num2=interpole_segment(mai,no1,no3,&tab,limit,mgmai,0);
536  int num3=interpole_segment(mai,no2,no3,&tab,limit,mgmai,0);
537  int nb=tab.size();
538  MG_MAILLAGE* maiori=mai->get_mg_maillage();
539  MG_NOEUD* n1ori=(MG_NOEUD*)no1->get_mg_element_maillage();
540  MG_NOEUD* n2ori=(MG_NOEUD*)no2->get_mg_element_maillage();
541  MG_NOEUD* n3ori=(MG_NOEUD*)no3->get_mg_element_maillage();
542  MG_FACE* face=faceex;
543  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(tri->get_mg_element_maillage()->get_lien_topologie()->get_id());
544  if (it!=correspondid.end())
545  face=geo->get_mg_faceid(it->second);
546  if (nb==0)
547  {
548  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno2,mgno3,mgmai,MAGIC::ORIGINE::IMPOSE);
549  oriente_tri(tri,xyzext);
550  }
551  if (nb==1)
552  {
553  if (num1==1)
554  {
555  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno3,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
556  MG_TRIANGLE_PEAU* tri2=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno2,mgno3,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
557  oriente_tri(tri,xyzext);
558  oriente_tri(tri2,xyzext);
559  }
560  if (num2==1)
561  {
562  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno2,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
563  MG_TRIANGLE_PEAU* tri2=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno2,mgno3,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
564  oriente_tri(tri,xyzext);
565  oriente_tri(tri2,xyzext);
566  }
567  if (num3==1)
568  {
569  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno2,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
570  MG_TRIANGLE_PEAU* tri2=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno3,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
571  oriente_tri(tri,xyzext);
572  oriente_tri(tri2,xyzext);
573  }
574  }
575  if (nb==2)
576  {
577  if (num1==0)
578  {
579  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno2,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
580  MG_TRIANGLE_PEAU* tri2=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno2,tab[0],tab[1],mgmai,MAGIC::ORIGINE::IMPOSE);
581  MG_TRIANGLE_PEAU* tri3=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno3,tab[0],tab[1],mgmai,MAGIC::ORIGINE::IMPOSE);
582  oriente_tri(tri,xyzext);
583  oriente_tri(tri2,xyzext);
584  oriente_tri(tri3,xyzext);
585  }
586  if (num2==0)
587  {
588  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,mgno3,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
589  MG_TRIANGLE_PEAU* tri2=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno3,tab[0],tab[1],mgmai,MAGIC::ORIGINE::IMPOSE);
590  MG_TRIANGLE_PEAU* tri3=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno2,tab[0],tab[1],mgmai,MAGIC::ORIGINE::IMPOSE);
591  oriente_tri(tri,xyzext);
592  oriente_tri(tri2,xyzext);
593  oriente_tri(tri3,xyzext);
594  }
595  if (num2==0)
596  {
597  MG_TRIANGLE_PEAU* tri=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno2,mgno3,tab[0],mgmai,MAGIC::ORIGINE::IMPOSE);
598  MG_TRIANGLE_PEAU* tri2=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno3,tab[0],tab[1],mgmai,MAGIC::ORIGINE::IMPOSE);
599  MG_TRIANGLE_PEAU* tri3=insere_triangle(geo,maiori,n1ori,n2ori,n3ori,correspondid,face,mgno1,tab[0],tab[1],mgmai,MAGIC::ORIGINE::IMPOSE);
600  oriente_tri(tri,xyzext);
601  oriente_tri(tri2,xyzext);
602  oriente_tri(tri3,xyzext);
603  }
604  }
605  }
606  else if ((no1->get_solution()>=limit) && (no2->get_solution()>=limit) && (no3->get_solution()>=limit))
607  {
608  MG_NOEUD *mgno1=get_noeud_peau(no1,mgmai,correspondidsom,geo);
609  MG_NOEUD *mgno2=get_noeud_peau(no2,mgmai,correspondidsom,geo);
610  MG_NOEUD *mgno3=get_noeud_peau(no3,mgmai,correspondidsom,geo);
611  MG_TRIANGLE_PEAU* tri=insere_triangle(faceex,mgno1,mgno2,mgno3,mgmai,MAGIC::ORIGINE::TRIANGULATION);
612  oriente_tri(tri,xyzext);
613  }
614  else if (!((no1->get_solution()<limit) && (no2->get_solution()<limit) && (no3->get_solution()<limit)))
615  {
616  std::vector<MG_NOEUD*> tab;
617  int num1=-1;
618  int num2=-1;
619  int num3=-1;
620  if (no1->get_solution()>=limit)
621  {
622  MG_NOEUD* no=get_noeud_peau(no1,mgmai,correspondidsom,geo);
623  tab.push_back(no);
624  num1=1;
625  }
626  if (no2->get_solution()>=limit)
627  {
628  MG_NOEUD* no=get_noeud_peau(no2,mgmai,correspondidsom,geo);
629  tab.push_back(no);
630  num2=1;
631  }
632  if (no3->get_solution()>=limit)
633  {
634  MG_NOEUD* no=get_noeud_peau(no3,mgmai,correspondidsom,geo);
635  tab.push_back(no);
636  num3=1;
637  }
638  if (num1*num2<0) interpole_segment(mai,no1,no2,&tab,limit,mgmai);
639  if (num1*num3<0) interpole_segment(mai,no1,no3,&tab,limit,mgmai);
640  if (num2*num3<0) interpole_segment(mai,no2,no3,&tab,limit,mgmai);
641  int nb=tab.size();
642  if (nb==3)
643  {
644  MG_TRIANGLE_PEAU* tri=insere_triangle(faceex,tab[0],tab[1],tab[2],mgmai,MAGIC::ORIGINE::TRIANGULATION);
645  oriente_tri(tri,xyzext);
646  }
647  if (nb==4)
648  {
649  MG_TRIANGLE_PEAU* tri=insere_triangle(faceex,tab[0],tab[1],tab[2],mgmai,MAGIC::ORIGINE::TRIANGULATION);
650  MG_TRIANGLE_PEAU* tri2=insere_triangle(faceex,tab[1],tab[2],tab[3],mgmai,MAGIC::ORIGINE::TRIANGULATION);
651  oriente_tri(tri,xyzext);
652  oriente_tri(tri2,xyzext);
653  }
654  }
655  }
656 LISTE_MG_TRIANGLE::iterator it_tri;
657 for (MG_TRIANGLE* mgtri=mgmai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mgmai->get_suivant_triangle(it_tri))
658  {
659  MG_TRIANGLE_PEAU* tripeau=(MG_TRIANGLE_PEAU*)mgtri;
660  MG_TRIANGLE_PEAU* voisin1=recherche_voisin(tripeau->get_noeud1(),tripeau->get_noeud2(),tripeau);
661  MG_TRIANGLE_PEAU* voisin2=recherche_voisin(tripeau->get_noeud2(),tripeau->get_noeud3(),tripeau);
662  MG_TRIANGLE_PEAU* voisin3=recherche_voisin(tripeau->get_noeud3(),tripeau->get_noeud1(),tripeau);
663  tripeau->change_voisin1(voisin1);
664  tripeau->change_voisin2(voisin2);
665  tripeau->change_voisin3(voisin3);
666  tripeau->change_nouveau_numero(0);
667  }
668 int fin;
669 do
670  {
671  fin=1;
672  for (MG_TRIANGLE* mgtri=mgmai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mgmai->get_suivant_triangle(it_tri))
673  {
674  MG_TRIANGLE_PEAU *tripeau=(MG_TRIANGLE_PEAU*)mgtri;
675  if (tripeau->get_nouveau_numero()==0)
676  {
677  fin=0;
678  std::vector<MG_TRIANGLE_PEAU*> *peau=new std::vector<MG_TRIANGLE_PEAU*>;
679  lst_peau.push_back(peau);
680  tripeau->change_nouveau_numero(1);
681  peau->push_back(tripeau);
682  determine_peau(peau);
683  }
684  }
685  }
686 while (fin==0);
687 return mgmai;
688 }
689 
690 
691 void MGOPT_POSTTRAITEMENT::suppression_peaux_isoles(MG_MAILLAGE* mgmai)
692 {
693 affiche((char*)"Suppression des peaux isolées");
694 
695 char message[500];
696 for (int cas=0;cas<2;cas++)
697 {
698 if (cas==0) affiche((char*)" Analyse initiale des peaux");
699 if (cas==1) affiche((char*)" Analyse finale des peaux");
700 int nbisole=0;
701 for (int i=0;i<lst_peau.size();i++)
702  {
703  int isole=1;
704  for (int j=0;j<lst_peau[i]->size();j++)
705  if ((*lst_peau[i])[j]->get_origine()==MAGIC::ORIGINE::IMPOSE) {isole=0;break;}
706  if (isole==1)
707  {
708  nbisole++;
709  for (int j=0;j<lst_peau[i]->size();j++)
710  {
711  mgmai->supprimer_mg_triangleid((*lst_peau[i])[j]->get_id());
712  }
713  lst_peau[i]->clear();
714  }
715  }
716 sprintf(message," %d peaux, %d non isoles, %d isoles",(int)lst_peau.size(),(int)lst_peau.size()-nbisole,nbisole);
717 affiche(message);
718 for (std::vector<std::vector<MG_TRIANGLE_PEAU*> *>::iterator j=lst_peau.end()-1;j>lst_peau.begin();j--)
719  if ((*j)->size()==0)
720  lst_peau.erase(j);
721 }
722 LISTE_MG_TRIANGLE::iterator itmg;
723 for (MG_TRIANGLE* tri=mgmai->get_premier_triangle(itmg);tri!=NULL;tri=mgmai->get_suivant_triangle(itmg))
724  {
725  if (tri->get_origine()==MAGIC::ORIGINE::IMPOSE)
726  {
727  tri->get_noeud1()->change_origine(MAGIC::ORIGINE::IMPOSE);
728  tri->get_noeud2()->change_origine(MAGIC::ORIGINE::IMPOSE);
729  tri->get_noeud3()->change_origine(MAGIC::ORIGINE::IMPOSE);
730  }
731  }
732 
733 }
734 
735 
736 void MGOPT_POSTTRAITEMENT::oriente_tri(MG_TRIANGLE_PEAU* tri,double *xyz)
737 {
738 MG_NOEUD* no1=tri->get_noeud1();
739 MG_NOEUD* no2=tri->get_noeud2();
740 MG_NOEUD* no3=tri->get_noeud3();
741 OT_VECTEUR_3D n1n2(no1->get_coord(),no2->get_coord());
742 OT_VECTEUR_3D n1n3(no1->get_coord(),no3->get_coord());
743 OT_VECTEUR_3D normal=n1n3&n1n2;
744 OT_VECTEUR_3D dir(no1->get_coord(),xyz);
745 dir.norme();
746 normal.norme();
747 double ps=normal*dir;
748 if (ps<0) tri->inverse_sens();
749 }
750 
751 
752 
753 MG_NOEUD* MGOPT_POSTTRAITEMENT::get_noeud_peau(FEM_NOEUD* no,MG_MAILLAGE* mai,std::map<unsigned long,unsigned long> &correspondid,MG_GEOMETRIE* geo)
754 {
755 static std::map<std::string,MG_NOEUD*> correspond;
756 unsigned long id=no->get_id();
757 char message[255];
758 sprintf(message,"_%lu_",id);
759 std::string key=message;
760 MG_NOEUD* mgno=correspond[key];
761 if (mgno==NULL)
762  {
763  int origine=MAGIC::ORIGINE::TRIANGULATION;
764  if (((MG_NOEUD*)no->get_mg_element_maillage())->get_lien_topologie()->get_dimension()==1) origine=MAGIC::ORIGINE::TRIANGULATION_ARETE;
765  MG_ELEMENT_TOPOLOGIQUE* ele=NULL;
766  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(no->get_mg_element_maillage()->get_lien_topologie()->get_id());
767  if (it!=correspondid.end())
768  ele=geo->get_mg_sommetid(it->second);
769  mgno=new MG_NOEUD(NULL,no->get_x(),no->get_y(),no->get_z(),origine);
770  if (it!=correspondid.end())
771  ((MG_SOMMET_NOEUD*)ele)->change_mg_noeud(mgno);
772  mai->ajouter_mg_noeud(mgno);
773  correspond[key]=mgno;
774  }
775 return mgno;
776 }
777 
778 
779 int MGOPT_POSTTRAITEMENT::test_du_point_milieu(MG_NOEUD* no1,MG_NOEUD* no2,FEM_ELEMENT3* tet)
780 {
781 double *xyz1=no1->get_coord();
782 double *xyz2=no2->get_coord();
783 double xyz[3];
784 xyz[0]=0.5*(xyz1[0]+xyz2[0]);
785 xyz[1]=0.5*(xyz1[1]+xyz2[1]);
786 xyz[2]=0.5*(xyz1[2]+xyz2[2]);
787 FEM_MAILLAGE_OUTILS ot;
788 if (((ot.estdansletetra(tet,xyz[0],xyz[1],xyz[2])>>1)&1)==1) return 1;
789 return 0;
790 }
791 
792 
793 
794 int MGOPT_POSTTRAITEMENT::interpole_segment(FEM_MAILLAGE* fem,FEM_NOEUD* no1,FEM_NOEUD* no2,std::vector<MG_NOEUD*> *tab,double limit,MG_MAILLAGE* mai,int creation)
795 {
796 static std::map<std::string,MG_NOEUD*> correspond;
797 unsigned long id1=no1->get_id();
798 unsigned long id2=no2->get_id();
799 char message[255];
800 sprintf(message,"_%lu_%lu_",id1,id2);
801 std::string key1=message;
802 sprintf(message,"_%lu_%lu_",id2,id1);
803 std::string key2=message;
804 double sol1=no1->get_solution();
805 double sol2=no2->get_solution();
806 MG_NOEUD* n1=(MG_NOEUD*)no1->get_mg_element_maillage();
807 MG_NOEUD* n2=(MG_NOEUD*)no2->get_mg_element_maillage();
808 MG_SEGMENT *seg=fem->get_mg_maillage()->get_mg_segment(n1->get_id(),n2->get_id());
809 int origine=MAGIC::ORIGINE::TRIANGULATION;
810 if (seg->get_lien_topologie()->get_dimension()==2) origine=MAGIC::ORIGINE::TRIANGULATION_ARETE;
811 if (seg->get_lien_topologie()->get_dimension()==1) origine=MAGIC::ORIGINE::TRIANGULATION_ARETE;
812 
813 if (fabs(sol1-limit)<0.0000001)
814  {
815  sprintf(message,"%lu",id1);
816  std::string key=message;
817  MG_NOEUD* no=correspond[key];
818  if (no==NULL)
819  {
820  double *xyz1=no1->get_coord();
821  no=new MG_NOEUD(NULL,xyz1[0],xyz1[1],xyz1[2],origine);
822  mai->ajouter_mg_noeud(no);
823  correspond[key]=no;
824  }
825  int present=0;
826  for (int i=0;i<tab->size();i++)
827  if ((*tab)[i]==no) present=1;
828  if (present==0)
829  {
830  tab->push_back(no);
831  return 1;
832  }
833  else return 0;
834  }
835 if (fabs(sol2-limit)<0.0000001)
836  {
837  sprintf(message,"%lu",id2);
838  std::string key=message;
839  MG_NOEUD* no=correspond[key];
840  if (no==NULL)
841  {
842  double *xyz2=no2->get_coord();
843  no=new MG_NOEUD(NULL,xyz2[0],xyz2[1],xyz2[2],origine);
844  mai->ajouter_mg_noeud(no);
845  correspond[key]=no;
846  }
847  int present=0;
848  for (int i=0;i<tab->size();i++)
849  if ((*tab)[i]==no) present=1;
850  if (present==0)
851  {
852  tab->push_back(no);
853  return 1;
854  }
855  else return 0;
856 
857  }
858 
859 if (((sol1<limit) && (sol2>limit))||((sol1>limit) && (sol2<limit)))
860  {
861  MG_NOEUD* no=correspond[key1];
862  if (no==NULL) no=correspond[key2];
863  if ((no==NULL) && (creation==1))
864  {
865  double t=(limit-sol1)/(sol2-sol1);
866  double xyz[3];
867  double *xyz1=no1->get_coord();
868  double *xyz2=no2->get_coord();
869  xyz[0]=xyz1[0]+t*(xyz2[0]-xyz1[0]);
870  xyz[1]=xyz1[1]+t*(xyz2[1]-xyz1[1]);
871  xyz[2]=xyz1[2]+t*(xyz2[2]-xyz1[2]);
872  no=new MG_NOEUD(NULL,xyz[0],xyz[1],xyz[2],origine);
873  mai->ajouter_mg_noeud(no);
874  correspond[key1]=no;
875  }
876  if (no!=NULL)
877  {
878  tab->push_back(no);
879  return 1;
880  }
881  }
882 return 0;
883 }
884 
885 void MGOPT_POSTTRAITEMENT::lire_params(char *fichier)
886 {
887 params.lire(fichier);
888 }
889 
890 void MGOPT_POSTTRAITEMENT::posttraite(FEM_SOLUTION* sol, MG_GESTIONNAIRE& gest2,char *nomparam,char *nomout)
891 {
892 strcat(nomout,".volume");
893 FILE *in=fopen(nomout,"wt");
894 fprintf(in,"Suivi du volume pendant le posttraitement d'une optimisation de topologie\n");
895 fprintf(in,"**************************************************************************\n\n\n\n");
896 if (nomparam!=NULL) lire_params(nomparam);
897 FEM_MAILLAGE* fem=sol->get_maillage();
898 affiche((char*)"Calcul du volume de depart");
899 double voltot=0.;
900 double volnon=0.;
901 calcul_volume_ini(fem->get_mg_maillage(),&voltot,&volnon);
902 fprintf(in,"Statistique initiale\n");
903 fprintf(in,"Volume total=%.14le\nVolume non design=%.14le\nVolume à optimiser=%.14le\n\n\n\n",voltot,volnon,voltot-volnon);
904 affiche((char*)"Extraction du maillage de surface");
905 int decoup=params.get_valeur("decoupage");
906 MG_MAILLAGE* mgmai;
907 if (decoup==0)
908  {
909  affiche((char*)" Découpage par mailles 3D entieres");
910  adapte_seuil(fem,sol);
911  mgmai=extract_skin_maille_entiere(fem,gest2);
912  }
913 if (decoup==1)
914  {
915  affiche((char*)" Découpage par isodensité");
916  double seuil=params.get_valeur("seuil");
917  std::string nomfich=params.get_nom("nomdensextra");
918  mgmai=extract_skin_par_decoupage(sol,seuil,gest2,nomfich.c_str());
919  }
920 suppression_peaux_isoles(mgmai);
921 affiche((char*)"Calcul du volume après extraction de la peau");
922 MG_MAILLAGE_OUTILS ot;
923 double v=ot.get_volume(mgmai);
924 fprintf(in,"Statistique après extraction de la peau\n");
925 fprintf(in,"Volume total=%.14le\nVolume non design=%.14le\nVolume design=%.14le\nf reel=%.14le\n\n\n\n",v,volnon,v-volnon,(v-volnon)/(voltot-volnon));
926 affiche((char*)"Procedure de lissage");
927 
928 int liss_aretes2017_nbiter=params.get_valeur("liss_aretes2017_nbiter");
929 if(liss_aretes2017_nbiter!=0)
930 {
931  double lambda=params.get_valeur("liss_aretes2017_lambda");
932  lissage_aretes2017(mgmai,gest2,lambda,liss_aretes2017_nbiter);
933 }
934 else
935 {
936  LISTE_MG_NOEUD::iterator it_vec;
937  for(MG_NOEUD* no=mgmai->get_premier_noeud(it_vec);no!=NULL;no=mgmai->get_suivant_noeud(it_vec))
938  if((no->get_origine()==MAGIC::ORIGINE::TRIANGULATION_ARETE)||(no->get_origine()==MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE)) no->change_origine(MAGIC::ORIGINE::TRIANGULATION);
939 }
940 
941 int chen2005_debut=params.get_valeur("chen2005_debut");
942 int chen2008_debut=params.get_valeur("chen2008_debut");
943 int jiao2012_debut=params.get_valeur("jiao2012_debut");
944 int McKenzie2016_debut=params.get_valeur("McKenzie2016_debut");
945 int Taubin1995_debut=params.get_valeur("Taubin1995_debut");
946 int cardinalite_debut=params.get_valeur("cardinalite_debut");
947 int cardinalite_iter=params.get_valeur("cardinalite_iter");
948 int rmimpose_debut=params.get_valeur("rmimpose_debut");
949 int rmimpose_iter=params.get_valeur("rmimpose_iter");
950 int chen2005fait=0;
951 if (chen2005_debut==0) chen2005fait=1;
952 int chen2008fait=0;
953 if (chen2008_debut==0) chen2008fait=1;
954 int jiao2012fait=0;
955 if (jiao2012_debut==0) jiao2012fait=1;
956 int McKenzie2016fait=0;
957 if (McKenzie2016_debut==0) McKenzie2016fait=1;
958 int Taubin1995fait=0;
959 if (Taubin1995_debut==0) Taubin1995fait=1;
960 int cardinalitefait=0;
961 if (cardinalite_debut==0) cardinalitefait=1;
962 
963 int fin=0;
964 int iteration=1;
965 do
966  {
967  char nomiteration[500];
968  strcpy(nomiteration,"aucun lissage");
969  int next=2000000000;
970  if (chen2005fait==0) next=std::min(next,chen2005_debut);
971  if (chen2008fait==0) next=std::min(next,chen2008_debut);
972  if (jiao2012fait==0) next=std::min(next,jiao2012_debut);
973  if (McKenzie2016fait==0) next=std::min(next,McKenzie2016_debut);
974  if (Taubin1995fait==0) next=std::min(next,Taubin1995_debut);
975  if (cardinalitefait==0) next=std::min(next,cardinalite_debut);
976  if ((iteration>=chen2005_debut) && (chen2005_debut==next))
977  {
978  char message[300];
979  sprintf(message, " Iteration %d : lissage de Chen 2005",iteration);
980  affiche(message);
981  double epsilon=params.get_valeur("chen2005_epsilon");
982  double sigma=params.get_valeur("chen2005_sigma");
983  int iter_max=params.get_valeur("chen2005_itermax");
984  int nbiter=lissage_chen2005(mgmai,gest2,epsilon,sigma,iter_max);
985  if (nbiter==iter_max) sprintf(message," Arrêt de la procédure de lissage de Chen2005 après %d itérations",nbiter);
986  else sprintf(message," Convergence de la procédure de lissage de Chen2005 après %d itérations",nbiter);
987  affiche(message);
988  chen2005fait=1;
989  iteration=iteration+nbiter;
990  strcpy(nomiteration,"lissage de Chen2005");
991  }
992  else if ((iteration>=chen2008_debut) && (chen2008_debut==next))
993  {
994  char message[300];
995  sprintf(message, " Iteration %d : lissage de Chen 2008",iteration);
996  affiche(message);
997  double epsilon=params.get_valeur("chen2008_epsilon");
998  double sigma=params.get_valeur("chen2008_sigma");
999  double gamma=params.get_valeur("chen2008_gamma");
1000  int iter_max=params.get_valeur("chen2008_itermax");
1001  int nbiter=lissage_chen2008(mgmai,gest2,sigma,gamma,epsilon,iter_max);
1002  if (nbiter==iter_max) sprintf(message," Arrêt de la procédure de lissage de Chen2008 après %d itérations",nbiter);
1003  else sprintf(message," Convergence de la procédure de lissage de Chen2008 après %d itérations",nbiter);
1004  affiche(message);
1005  chen2008fait=1;
1006  iteration=iteration+nbiter;
1007  strcpy(nomiteration,"lissage de Chen2008");
1008  }
1009  else if ((iteration>=jiao2012_debut) && (jiao2012_debut==next))
1010  {
1011  char message[300];
1012  sprintf(message, " Iteration %d : lissage de Jiao 2012",iteration);
1013  affiche(message);
1014  int iter_max=params.get_valeur("jiao2012_itermax");
1015  int nbiter=lissage_jiao2012(mgmai,gest2,iter_max);
1016  if (nbiter==iter_max) sprintf(message," Arrêt de la procédure de lissage de Jiao2012 après %d itérations",nbiter);
1017  else sprintf(message," Convergence de la procédure de lissage de Jiao2012 après %d itérations",nbiter);
1018  affiche(message);
1019  jiao2012fait=1;
1020  iteration=iteration+nbiter;
1021  strcpy(nomiteration,"lissage de Jiao2012");
1022  }
1023  else if ((iteration>=McKenzie2016_debut) && (McKenzie2016_debut==next))
1024  {
1025  char message[300];
1026  sprintf(message, "Lissage de McKenzie2016");
1027  affiche(message);
1028  double lambda=params.get_valeur("McKenzie2016_lambda");
1029  double nu=params.get_valeur("McKenzie2016_nu");
1030  double epsilon=params.get_valeur("McKenzie2016_epsilon");
1031  double sigma=params.get_valeur("McKenzie2016_sigma");
1032  double gamma_ =params.get_valeur("McKenzie2016_sigma");
1033  int filtre=params.get_valeur("McKenzie2016_filtre");
1034  int iter_max=params.get_valeur("McKenzie2016_itermax");
1035  int itr_taubin=params.get_valeur("McKenzie2016_itertaubmax");
1036  int nbiter=lissage_McKenzie2016(mgmai,gest2,lambda,nu,epsilon,sigma,gamma_,filtre, iter_max, itr_taubin);
1037  if (nbiter==iter_max) sprintf(message," Arrêt de la procédure de lissage de McKenzie2016 après %d itérations",nbiter);
1038  else sprintf(message," Convergence de la procédure de lissage de McKenzie2016 après %d itérations",nbiter);
1039  affiche(message);
1040  McKenzie2016fait=1;
1041  iteration=iteration+nbiter;
1042  strcpy(nomiteration,"lissage de McKenzie2016");
1043  }
1044 
1045  else if ((iteration>=Taubin1995_debut) && (Taubin1995_debut==next))
1046  {
1047  char message[300];
1048  sprintf(message, "Lissage de Taubin1995");
1049  affiche(message);
1050  double lambda=params.get_valeur("Taubin1995_lambda");
1051  double nu=params.get_valeur("Taubin1995_nu");
1052  int iter_max=params.get_valeur("Taubin1995_itermax");
1053  int nbiter=lissage_Taubin1995(mgmai,gest2,lambda,nu, iter_max);
1054  if (nbiter==iter_max) sprintf(message," Arrêt de la procédure de lissage de Taubin1995 après %d itérations",nbiter);
1055  else sprintf(message," Convergence de la procédure de lissage de Taubin1995 après %d itérations",nbiter);
1056  affiche(message);
1057  Taubin1995fait=1;
1058  iteration=iteration+nbiter;
1059  strcpy(nomiteration,"lissage de Taubin1995");
1060  }
1061  else if ((iteration>=cardinalite_debut) && (cardinalite_debut==next))
1062  {
1063  char message[300];
1064  sprintf(message, "Étude de la cardinalite des noeuds");
1065  affiche(message);
1066  int nb=cardinalite(mgmai,cardinalite_iter);
1067  if (nb!=cardinalite_iter)
1068  sprintf(message, "Cardinalité des noeuds convergé");
1069  else
1070  sprintf(message, "Cardinalité des noeuds non convergé");
1071  affiche(message);
1072  strcpy(nomiteration,"Cardinalité");
1073  iteration=iteration+nb;
1074  cardinalitefait=1;
1075  }
1076  else
1077  {
1078  iteration++;
1079  }
1080  if (chen2005fait==1)
1081  if (chen2008fait==1)
1082  if (jiao2012fait==1)
1083  if (McKenzie2016fait==1)
1084  if (Taubin1995fait==1)
1085  if (cardinalitefait==1)
1086  fin=1;
1087  if (strcmp(nomiteration,"aucun lissage")!=0)
1088  {
1089  MG_MAILLAGE_OUTILS ot;
1090  double v=ot.get_volume(mgmai);
1091  fprintf(in,"Statistique après itération %d %s\n",iteration-1,nomiteration);
1092  fprintf(in,"Volume total=%.14le\nVolume non design=%.14le\nVolume design=%.14le\nf reel=%.14le\n\n\n\n",v,volnon,v-volnon,(v-volnon)/(voltot-volnon));
1093  }
1094 
1095  }
1096 while (fin==0);
1097 
1098 fclose(in);
1099 
1100 if (rmimpose_debut != 0)
1101  {
1102  char message[300];
1103  sprintf(message, "Suppression du non_design du resultat optimal");
1104  affiche(message);
1105  std::string nomfichier=params.get_nom("nomfichpeau");
1106  rmimpose(mgmai,(char*)nomfichier.c_str());
1107  }
1108 }
1109 
1110 
1111 MG_MAILLAGE* MGOPT_POSTTRAITEMENT::extract_skin_maille_entiere(FEM_MAILLAGE* mai,MG_GESTIONNAIRE &gest2)
1112 {
1113 affiche((char*)"Extraction du maillage de surface");
1114 int coderesu = 0;
1115 int mai2_id;
1116 int imp=params.get_valeur("consimpose");
1117 int opti=params.get_valeur("consoptimise");
1118 int m_auto=params.get_valeur("consnooptimise");
1119 if (opti==1) conserve(MAGIC::ORIGINE::OPTIMISE);
1120 if (imp==1) conserve(MAGIC::ORIGINE::IMPOSE);
1121 if (m_auto==1) conserve(MAGIC::ORIGINE::MAILLEUR_AUTO);
1122 copieorigine(mai);
1123 MG_MAILLAGE* mg_mai = (MG_MAILLAGE*)mai->get_mg_maillage();
1124 int reactiv=params.get_valeur("reactivation");
1125 if (reactiv == 1)
1126  {
1127  reactivation(mg_mai,gest2);
1128  }
1129 affiche((char*)" Analyse des cas non manifold");
1130 do
1131  {
1132  int nbmaniare,nbmanino,nbpeau;
1133  coderesu = extract_skin(mg_mai,gest2,nbpeau,nbmaniare,nbmanino,&mai2_id);
1134  char message[500];
1135  sprintf(message," %d peaux. %d manifold par arete. %d manifold par noeud",nbpeau,nbmaniare,nbmanino);
1136  affiche(message);
1137  }
1138 while (coderesu == 0);
1139 
1140 MG_MAILLAGE* mg_mai2=gest2.get_mg_maillageid(mai2_id);
1141 
1142 return mg_mai2;
1143 
1144 }
1145 
1146 
1147 void MGOPT_POSTTRAITEMENT::adapte_seuil(class FEM_MAILLAGE* fem,FEM_SOLUTION* solution)
1148 {
1149 double seuil=params.get_valeur("seuil");
1150 solution->active_solution(0);
1151 LISTE_FEM_ELEMENT3::iterator it;
1152 for (FEM_ELEMENT3 *tet=fem->get_premier_element3(it);tet!=NULL;tet=fem->get_suivant_element3(it))
1153  {
1154  if (((MG_TETRA*)tet->get_mg_element_maillage())->get_origine()!=MAGIC::ORIGINE::IMPOSE)
1155  if (tet->get_solution()>seuil)
1156  ((MG_TETRA*)tet->get_mg_element_maillage())->change_origine(MAGIC::ORIGINE::OPTIMISE);
1157  else
1158  ((MG_TETRA*)tet->get_mg_element_maillage())->change_origine(MAGIC::ORIGINE::MAILLEUR_AUTO);
1159 
1160  }
1161 }
1162 
1163 
1164 
1165 void MGOPT_POSTTRAITEMENT::lissage_aretes2017(MG_MAILLAGE* mg_mai, MG_GESTIONNAIRE& gest2, double lambda, int nb_iter)
1166 {
1167  std::vector<MG_NOEUD*> lst_no_1090_1091;
1168  LISTE_MG_NOEUD::iterator it_vec;
1169  MG_NOEUD* no=NULL;
1170  for(no=mg_mai->get_premier_noeud(it_vec);no!=NULL;no=mg_mai->get_suivant_noeud(it_vec))
1171  if((no->get_origine()==MAGIC::ORIGINE::TRIANGULATION_ARETE)||(no->get_origine()==MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE)) lst_no_1090_1091.push_back(no);
1172 
1173  std::vector<MG_NOEUD*> lst_no_extr;
1174  MG_NOEUD* no_voisin=NULL;
1175  MG_SEGMENT* seg=NULL;
1176  for (int i=0;i<lst_no_1090_1091.size();i++)
1177  {
1178  no=lst_no_1090_1091[i];
1179  for(int j=0;j<no->get_lien_segment()->get_nb();j++)
1180  {
1181  seg=no->get_lien_segment()->get(j);
1182  bool seg_bord=seg->get_lien_triangle()->get(0)->get_lien_topologie()!=seg->get_lien_triangle()->get(1)->get_lien_topologie();
1183  if(seg->get_noeud1()!=no) no_voisin=seg->get_noeud1();
1184  else no_voisin=seg->get_noeud2();
1185  if((no_voisin->get_origine()==MAGIC::ORIGINE::IMPOSE)&&seg_bord)
1186  lst_no_extr.push_back(no_voisin);
1187  }
1188  }
1189 
1190  std::vector<std::vector<MG_NOEUD*>> lst_aretes;
1191  std::map<int,MG_NOEUD*> lst_no_voisins;
1192  TPL_LISTE_ENTITE<long unsigned int> lst_idno_nonmanifold;
1193  MG_GEOMETRIE* geo=gest2.get_mg_geometrie(0);
1194  void recherche_voisins(MG_NOEUD* no, std::vector<MG_NOEUD*>* lst_no_1090_1091,std::vector<MG_NOEUD*>* arete, std::map<int,MG_NOEUD*>* lst_no_voisins, bool arete_ouverte, std::vector<MG_NOEUD*>* lst_no_extr);
1195  int passage_non_manifold(MG_NOEUD** no,std::map<int,MG_NOEUD*>* lst_no_voisins, MG_GEOMETRIE* geo, std::vector<MG_NOEUD*>* arete);
1196  bool arete_ouverte=true;
1197 
1198  for (int i=0;i<lst_no_extr.size();i++)
1199  {
1200  std::vector<MG_NOEUD*> arete;
1201  no=lst_no_extr[i];
1202  arete.push_back(no);
1203  do
1204  {
1205  lst_no_voisins.clear();
1206  recherche_voisins(no,&lst_no_1090_1091,&arete,&lst_no_voisins,arete_ouverte,&lst_no_extr);
1207  if((lst_no_voisins.size()==1)||(lst_no_voisins.size()==2))
1208  {
1209  arete.push_back(lst_no_voisins.begin()->second);
1210  lst_no_1090_1091.erase(lst_no_1090_1091.begin()+lst_no_voisins.begin()->first);
1211  no=lst_no_voisins.begin()->second;
1212  }
1213  /***traitement des cas "non-manifold"***/
1214  if(lst_no_voisins.size()==3)
1215  {
1216  lst_idno_nonmanifold.ajouter(no->get_id());
1217  lst_no_1090_1091.push_back(no);
1218  lst_no_1090_1091.erase(lst_no_1090_1091.begin()+passage_non_manifold(&no,&lst_no_voisins,geo,&arete));
1219  }
1220  }
1221  while(lst_no_voisins.size()!=0);
1222  if(arete.size()>6) lst_aretes.push_back(arete);
1223  else for(int i=1;i<arete.size()-1;i++)
1224  if((arete[i]->get_origine()!=MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE)&&(lst_idno_nonmanifold.est_dans_la_liste(arete[i]->get_id())==0))
1225  arete[i]->change_origine(MAGIC::ORIGINE::TRIANGULATION);
1226  }
1227 
1228  arete_ouverte=false;
1229  for (int i=0;i<lst_no_1090_1091.size();i++)
1230  if(lst_no_1090_1091[i]->get_origine()!=MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE)
1231  {
1232  std::vector<MG_NOEUD*> arete;
1233  no=lst_no_1090_1091[i];
1234  arete.push_back(no);
1235  do
1236  {
1237  lst_no_voisins.clear();
1238  recherche_voisins(no,&lst_no_1090_1091,&arete,&lst_no_voisins,arete_ouverte,&lst_no_extr);
1239  if((lst_no_voisins.size()==1)||(lst_no_voisins.size()==2))
1240  {
1241  arete.push_back(lst_no_voisins.begin()->second);
1242  lst_no_1090_1091.erase(lst_no_1090_1091.begin()+lst_no_voisins.begin()->first);
1243  no=lst_no_voisins.begin()->second;
1244  }
1245  /***traitement des cas "non-manifold"***/
1246  if(lst_no_voisins.size()==3)
1247  {
1248  lst_idno_nonmanifold.ajouter(no->get_id());
1249  lst_no_1090_1091.push_back(no);
1250  lst_no_1090_1091.erase(lst_no_1090_1091.begin()+passage_non_manifold(&no,&lst_no_voisins,geo,&arete));
1251  }
1252  }
1253  while(lst_no_voisins.size()!=0);
1254  if(arete.size()>6) lst_aretes.push_back(arete);
1255  else
1256  for(int i=0;i<arete.size()-1;i++)
1257  if((arete[i]->get_origine()!=MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE)&&(lst_idno_nonmanifold.est_dans_la_liste(arete[i]->get_id())==0))
1258  arete[i]->change_origine(MAGIC::ORIGINE::TRIANGULATION);
1259  }
1260 
1261  for(int iter=0;iter<nb_iter;iter++)
1262  for(int k=0;k<lst_aretes.size();k++)
1263  for(int i=0;i<lst_aretes[k].size()-1;i++)
1264  if((lst_aretes[k][i]->get_origine()==MAGIC::ORIGINE::TRIANGULATION_ARETE)&&
1265  (lst_idno_nonmanifold.est_dans_la_liste(lst_aretes[k][i]->get_id())==0))
1266  {
1267  MG_NOEUD* noeud_i=lst_aretes[k][i];
1268 
1269  int i_prec=i-1;
1270  if(i==0) i_prec=lst_aretes[k].size()-2;
1271 
1272  double x_i=lst_aretes[k][i]->get_x(), x_i_prec=lst_aretes[k][i_prec]->get_x(), x_i_suiv=lst_aretes[k][i+1]->get_x();
1273  double y_i=lst_aretes[k][i]->get_y(), y_i_prec=lst_aretes[k][i_prec]->get_y(), y_i_suiv=lst_aretes[k][i+1]->get_y();
1274  double z_i=lst_aretes[k][i]->get_z(), z_i_prec=lst_aretes[k][i_prec]->get_z(), z_i_suiv=lst_aretes[k][i+1]->get_z();
1275 
1276  double delta_x=0.5*(x_i_prec+x_i_suiv)-x_i;
1277  double delta_y=0.5*(y_i_prec+y_i_suiv)-y_i;
1278  double delta_z=0.5*(z_i_prec+z_i_suiv)-z_i;
1279 
1280  double x_i_prime=x_i+lambda*delta_x;
1281  double y_i_prime=y_i+lambda*delta_y;
1282  double z_i_prime=z_i+lambda*delta_z;
1283 
1284  noeud_i->change_x(x_i_prime);
1285  noeud_i->change_y(y_i_prime);
1286  noeud_i->change_z(z_i_prime);
1287  }
1288 }
1289 
1290 
1291 
1292 int MGOPT_POSTTRAITEMENT::lissage_chen2005(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, double epsilon, double sigma, int iter_max)
1293 {
1294 double un_sur_pi = 1./M_PI;
1295 int compteur = 0;
1296 int fin = 0;
1297 
1298 
1299 do
1300  {
1301  TPL_LISTE_ENTITE<OT_VECTEUR_3D> liste_normales;
1302  TPL_LISTE_ENTITE<OT_VECTEUR_3D> liste_normales2;
1303  TPL_LISTE_ENTITE<double> liste_wij;
1304  LISTE_MG_TRIANGLE::iterator it_tri;
1305  int k = 0; //pour identifier les triangles pour liste_normales et liste_wij
1306  for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
1307  {
1308  MG_TRIANGLE_PEAU* mgtri_i = (MG_TRIANGLE_PEAU*)mgtri;
1309  OT_VECTEUR_3D normal_f_i = mgtri_i->calcul_normal();
1310  normal_f_i.norme();
1311  liste_normales2.ajouter(normal_f_i);
1312  //Remplissage de la liste des voisins du triangle i
1313  TPL_MAP_ENTITE<MG_TRIANGLE_PEAU*> liste_voisins;
1314  MG_NOEUD* noeud1 = mgtri_i->get_noeud1();
1315  double nb_voisins1 = noeud1->get_lien_triangle()->get_nb();
1316  for (int j = 0;j<nb_voisins1;j++)
1317  {
1318  MG_TRIANGLE_PEAU* mgtri_1 = (MG_TRIANGLE_PEAU*) noeud1->get_lien_triangle()->get(j);
1319  liste_voisins.ajouter(mgtri_1);
1320  }
1321  MG_NOEUD* noeud2 = mgtri_i->get_noeud2();
1322  double nb_voisins2 = noeud2->get_lien_triangle()->get_nb();
1323  for (int j = 0;j<nb_voisins2;j++)
1324  {
1325  MG_TRIANGLE_PEAU* mgtri_2 = (MG_TRIANGLE_PEAU*) noeud2->get_lien_triangle()->get(j);
1326  liste_voisins.ajouter(mgtri_2);
1327  }
1328  MG_NOEUD* noeud3 = mgtri_i->get_noeud3();
1329  double nb_voisins3 = noeud3->get_lien_triangle()->get_nb();
1330  for (int j = 0;j<nb_voisins3;j++)
1331  {
1332  MG_TRIANGLE_PEAU* mgtri_3 = (MG_TRIANGLE_PEAU*) noeud3->get_lien_triangle()->get(j);
1333  liste_voisins.ajouter(mgtri_3);
1334  }
1335  liste_voisins.supprimer(mgtri_i);
1336  int nb_voisins = liste_voisins.get_nb();
1337  double w_ij = 1./nb_voisins;
1338  double phi_i_min = 10.;
1339  double s_i = 0.0;
1340  double phi_im = 0.0;
1341  double *phi_ij = new double[nb_voisins];
1342  OT_VECTEUR_3D normal_f_i_mean(0.,0.,0.);
1343  OT_VECTEUR_3D eta_i(0.,0.,0.);
1344  TPL_MAP_ENTITE<MG_TRIANGLE_PEAU*>::ITERATEUR it;
1345  int j = 0;
1346  for(MG_TRIANGLE_PEAU* mgtri_j=liste_voisins.get_premier(it);mgtri_j!=NULL;mgtri_j=liste_voisins.get_suivant(it))
1347  {
1348  OT_VECTEUR_3D normal_f_j = mgtri_j->calcul_normal();
1349  //1-Calculer la normale moyenne pour chaque triangle
1350  normal_f_i_mean = normal_f_i_mean + w_ij*normal_f_j;
1351  //2.1-On calcul l'angle entre normal_f_i et normal_f_j pour j allant de 1 a Nb_voisins
1352  double prod_scalaire = normal_f_i*normal_f_j;
1353  if (prod_scalaire > 1.)
1354  {
1355  prod_scalaire = 1.;
1356  }
1357  if (prod_scalaire < -1.)
1358  {
1359  prod_scalaire = -1.;
1360  }
1361  phi_ij[j] = acos(prod_scalaire)*un_sur_pi;
1362  //2.2-On trouve le plus petit des angles et la normale heta_i correspondante
1363  if (phi_ij[j] < phi_i_min)
1364  {
1365  phi_i_min = phi_ij[j];
1366  eta_i = normal_f_j;
1367  }
1368  //3.1-On calcul l'angle moyen phi_im
1369  phi_im = phi_im + w_ij*phi_ij[j];
1370  j++;
1371  }
1372  normal_f_i_mean.norme();
1373  j = 0;
1374  for(MG_TRIANGLE_PEAU* mgtri_j=liste_voisins.get_premier(it);mgtri_j!=NULL;mgtri_j=liste_voisins.get_suivant(it))
1375  {
1376  //3.2-Calcul de s_i selon la variance
1377  s_i = s_i + w_ij*pow((phi_ij[j] - phi_im),2);
1378  j++;
1379  }
1380  delete[] phi_ij;
1381  //4-On calcule une nouvelle normale pour chaque triangle
1382  double pond;
1383  int num=params.get_valeur("chen2005_filtre");
1384  if (num==1) pond=ponderation_gaussian(s_i,sigma);
1385  else if (num==2) pond=ponderation_laplacian(s_i,sigma);
1386  else if (num==3) pond=ponderation_elfallahford(s_i,sigma);
1387  OT_VECTEUR_3D normal_f_i_new = pond*normal_f_i_mean + (1. - pond)*eta_i;
1388  normal_f_i_new.norme();
1389  liste_normales.ajouter(normal_f_i_new);
1390  liste_wij.ajouter(w_ij);
1391  mgtri->change_nouveau_numero(k);
1392  k++;
1393  }
1394 
1395  LISTE_MG_NOEUD::iterator it_no;
1396  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1397  {
1398  int nb_voisins_j = noeud_i->get_lien_triangle()->get_nb();
1399  double w_ij_prime = 0.0;
1400  OT_VECTEUR_3D v_temp(0.,0.,0.);
1401  OT_VECTEUR_3D v_i(noeud_i->get_x(),noeud_i->get_y(),noeud_i->get_z());
1402  for(int j=0;j<nb_voisins_j;j++)
1403  {
1404  MG_TRIANGLE_PEAU* mgtri_j = (MG_TRIANGLE_PEAU*) noeud_i->get_lien_triangle()->get(j);
1405  //On calcule le centroide cj du triangle mgtri_j
1406  MG_NOEUD* n1 = mgtri_j->get_noeud1();
1407  MG_NOEUD* n2 = mgtri_j->get_noeud2();
1408  MG_NOEUD* n3 = mgtri_j->get_noeud3();
1409  double cj_x = 0.333333333333333*(n1->get_x() + n2->get_x() + n3->get_x());
1410  double cj_y = 0.333333333333333*(n1->get_y() + n2->get_y() + n3->get_y());
1411  double cj_z = 0.333333333333333*(n1->get_z() + n2->get_z() + n3->get_z());
1412  //On forme le vecteur vi_cj
1413  OT_VECTEUR_3D vi_cj(cj_x - noeud_i->get_x(),cj_y - noeud_i->get_y(),cj_z - noeud_i->get_z());
1414  OT_VECTEUR_3D normal_f_i_new = liste_normales.get(mgtri_j->get_nouveau_numero());
1415  // w_ij_prime correspond a la somme des aires des triangles voisins du noeuds
1416  OT_VECTEUR_3D AB(n2->get_x() - n1->get_x(),n2->get_y() - n1->get_y(),n2->get_z() - n1->get_z());
1417  OT_VECTEUR_3D AC(n3->get_x() - n1->get_x(),n3->get_y() - n1->get_y(),n3->get_z() - n1->get_z());
1418  OT_VECTEUR_3D prodvect = AB&AC;
1419  double w_ij = 0.5*prodvect.get_longueur();
1420  w_ij_prime = w_ij_prime + w_ij;
1421  v_temp = v_temp + w_ij*(vi_cj*normal_f_i_new)*normal_f_i_new;
1422  }
1423  //5-On met a jour la position des noeuds
1424  v_i = v_i + v_temp/w_ij_prime;
1425  int origine = noeud_i->get_origine();
1426  if (origine == MAGIC::ORIGINE::TRIANGULATION)
1427  {
1428  noeud_i->change_x(v_i.get_x());
1429  noeud_i->change_y(v_i.get_y());
1430  noeud_i->change_z(v_i.get_z());
1431  }
1432  }
1433  //Critere d'arret de l'algorithme
1434  int l=0;
1435  int nb_tri = mg_mai->get_nb_mg_triangle();
1436  for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
1437  {
1438  MG_TRIANGLE_PEAU* mgtri_i = (MG_TRIANGLE_PEAU*)mgtri;
1439  OT_VECTEUR_3D normal_f_i = liste_normales2.get(mgtri_i->get_nouveau_numero());
1440  OT_VECTEUR_3D normal_f_i_new = liste_normales.get(mgtri_i->get_nouveau_numero());
1441  double critere = 1. - normal_f_i*normal_f_i_new;
1442  if (critere <= epsilon) l++;
1443  }
1444  double tolerance = 0.01*nb_tri;
1445  if (nb_tri - l <= 0) fin = 1;
1446  compteur++;
1447  }
1448 while ((fin == 0) && (compteur < iter_max));
1449 
1450 return compteur;
1451 }
1452 
1453 int MGOPT_POSTTRAITEMENT::lissage_jiao2012(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, int iter_max)
1454 {
1455 int compteur = 0;
1456 
1457 do
1458  {
1459  std::vector<double> nouv_position_x;
1460  std::vector<double> nouv_position_y;
1461  std::vector<double> nouv_position_z;
1462  LISTE_MG_NOEUD::iterator it_no;
1463  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1464  {
1465  int origine = noeud_i->get_origine();
1466  if (origine == MAGIC::ORIGINE::TRIANGULATION)
1467  {
1468  int nb_voisins_j = noeud_i->get_lien_triangle()->get_nb();
1469  double wij = 0.0;
1470  double wij_sommej = 0.0;
1471  OT_VECTEUR_3D v_temp(0.,0.,0.);
1472  OT_VECTEUR_3D v_i(noeud_i->get_x(),noeud_i->get_y(),noeud_i->get_z());
1473  for(int j=0;j<nb_voisins_j;j++)
1474  {
1475  MG_TRIANGLE_PEAU* mgtri_j = (MG_TRIANGLE_PEAU*) noeud_i->get_lien_triangle()->get(j);
1476  //On calcule le centroide cj du triangle mgtri_j
1477  MG_NOEUD* n1 = mgtri_j->get_noeud1();
1478  MG_NOEUD* n2 = mgtri_j->get_noeud2();
1479  MG_NOEUD* n3 = mgtri_j->get_noeud3();
1480  double cj_x = 0.333333333333333*(n1->get_x() + n2->get_x() + n3->get_x());
1481  double cj_y = 0.333333333333333*(n1->get_y() + n2->get_y() + n3->get_y());
1482  double cj_z = 0.333333333333333*(n1->get_z() + n2->get_z() + n3->get_z());
1483  //On forme le vecteur vi_cj et le vecteur cj
1484  OT_VECTEUR_3D cj(cj_x ,cj_y,cj_z);
1485  OT_VECTEUR_3D vi_cj(cj_x - noeud_i->get_x(),cj_y - noeud_i->get_y(),cj_z - noeud_i->get_z());
1486  wij=vi_cj.get_longueur();
1487  wij_sommej=wij_sommej+wij;
1488  v_temp = v_temp + (wij*cj);
1489  }
1490  //5-On calcule la nouvelle position des noeuds et on affecte au tableau temporaire
1491  v_i =v_temp/wij_sommej;
1492  nouv_position_x.push_back(v_i.get_x());
1493  nouv_position_y.push_back(v_i.get_y());
1494  nouv_position_z.push_back(v_i.get_z());
1495  }
1496  }
1497  //On actualise la position des noeuds
1498  int ind_noeud=0;
1499  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1500  {
1501  int origine = noeud_i->get_origine();
1502  if (origine == MAGIC::ORIGINE::TRIANGULATION)
1503  {
1504  noeud_i->change_x(nouv_position_x[ind_noeud]);
1505  noeud_i->change_y(nouv_position_y[ind_noeud]);
1506  noeud_i->change_z(nouv_position_z[ind_noeud]);
1507  ind_noeud++;
1508  }
1509  }
1510  //Critere d'arret de l'algorithme
1511  compteur++;
1512  }
1513 while (compteur < iter_max);
1514 
1515 return compteur;
1516 }
1517 
1518 int MGOPT_POSTTRAITEMENT::lissage_chen2008(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, double sigma, double gamma, double epsilon, int iter_max)
1519 {
1520 double un_sur_pi = 1./M_PI;
1521 int compteur = 0;
1522 int fin = 0;
1523 compteur = 0;
1524 
1525 do
1526  {
1527  std::vector<double> nouv_position_x;
1528  std::vector<double> nouv_position_y;
1529  std::vector<double> nouv_position_z;
1530  TPL_LISTE_ENTITE<OT_VECTEUR_3D> liste_normales;
1531  TPL_LISTE_ENTITE<OT_VECTEUR_3D> liste_normales2;
1532  TPL_LISTE_ENTITE<double> liste_wij;
1533  LISTE_MG_TRIANGLE::iterator it_tri;
1534  int k = 0; //pour identifier les triangles pour liste_normales et liste_wij
1535  for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
1536  {
1537  MG_TRIANGLE_PEAU* mgtri_i = (MG_TRIANGLE_PEAU*)mgtri;
1538  OT_VECTEUR_3D normal_f_i = mgtri_i->calcul_normal();
1539  normal_f_i.norme();
1540  liste_normales2.ajouter(normal_f_i);
1541  //Remplissage de la liste des voisins du triangle i
1542  TPL_MAP_ENTITE<MG_TRIANGLE_PEAU*> liste_voisins;
1543  MG_NOEUD* noeud1 = mgtri_i->get_noeud1();
1544  double nb_voisins1 = noeud1->get_lien_triangle()->get_nb();
1545  for (int j = 0;j<nb_voisins1;j++)
1546  {
1547  MG_TRIANGLE_PEAU* mgtri_1 = (MG_TRIANGLE_PEAU*) noeud1->get_lien_triangle()->get(j);
1548  liste_voisins.ajouter(mgtri_1);
1549  }
1550  MG_NOEUD* noeud2 = mgtri_i->get_noeud2();
1551  double nb_voisins2 = noeud2->get_lien_triangle()->get_nb();
1552  for (int j = 0;j<nb_voisins2;j++)
1553  {
1554  MG_TRIANGLE_PEAU* mgtri_2 = (MG_TRIANGLE_PEAU*) noeud2->get_lien_triangle()->get(j);
1555  liste_voisins.ajouter(mgtri_2);
1556  }
1557  MG_NOEUD* noeud3 = mgtri_i->get_noeud3();
1558  double nb_voisins3 = noeud3->get_lien_triangle()->get_nb();
1559  for (int j = 0;j<nb_voisins3;j++)
1560  {
1561  MG_TRIANGLE_PEAU* mgtri_3 = (MG_TRIANGLE_PEAU*) noeud3->get_lien_triangle()->get(j);
1562  liste_voisins.ajouter(mgtri_3);
1563  }
1564  liste_voisins.supprimer(mgtri_i);
1565  int nb_voisins = liste_voisins.get_nb();
1566  double w_ij = 1./nb_voisins;
1567  double phi_i_min = 10.;
1568  double s_i = 0.0;
1569  double phi_im = 0.0;
1570  double *phi_ij = new double[nb_voisins];
1571  OT_VECTEUR_3D normal_f_i_mean(0.,0.,0.);
1572  normal_f_i_mean = normal_f_i;
1573  OT_VECTEUR_3D eta_i(0.,0.,0.);
1574  TPL_MAP_ENTITE<MG_TRIANGLE_PEAU*>::ITERATEUR it;
1575  int j = 0;
1576  for(MG_TRIANGLE_PEAU* mgtri_j=liste_voisins.get_premier(it);mgtri_j!=NULL;mgtri_j=liste_voisins.get_suivant(it))
1577  {
1578  OT_VECTEUR_3D normal_f_j = mgtri_j->calcul_normal();
1579  //1-Calculer la normale moyenne pour chaque triangle
1580  normal_f_i_mean = normal_f_i_mean + normal_f_j;
1581  //2.1-On calcule l'angle entre normal_f_i et normal_f_j pour j allant de 1 a Nb_voisins
1582  double prod_scalaire = normal_f_i*normal_f_j;
1583  if (prod_scalaire > 1.)
1584  {
1585  prod_scalaire = 1.;
1586  }
1587  if (prod_scalaire < -1.)
1588  {
1589  prod_scalaire = -1.;
1590  }
1591  phi_ij[j] = acos(prod_scalaire)*un_sur_pi;
1592  //2.2-On trouve le plus petit des angles et la normale heta_i correspondante
1593  if (phi_ij[j] < phi_i_min)
1594  {
1595  phi_i_min = phi_ij[j];
1596  eta_i = normal_f_j;
1597  }
1598  //3.1-On calcule l'angle moyen phi_im
1599  phi_im = phi_im + w_ij*phi_ij[j];
1600  j++;
1601  }
1602  normal_f_i_mean.norme();
1603  j = 0;
1604  for(MG_TRIANGLE_PEAU* mgtri_j=liste_voisins.get_premier(it);mgtri_j!=NULL;mgtri_j=liste_voisins.get_suivant(it))
1605  {
1606  //3.2-Calcul de s_i selon la variance
1607  s_i = s_i + w_ij*pow((phi_ij[j] - phi_im),2);
1608  j++;
1609  }
1610  delete[] phi_ij;
1611  //4-On calcule une nouvelle normale pour chaque triangle
1612  double pond;
1613  int num=params.get_valeur("chen2008_filtre");
1614  if (num==1) pond=ponderation_gaussian(s_i,sigma);
1615  else if (num==2) pond=ponderation_laplacian(s_i,sigma);
1616  else if (num==3) pond=ponderation_elfallahford(s_i,sigma);
1617  OT_VECTEUR_3D normal_f_i_new = pond*normal_f_i_mean + (1. - pond)*eta_i;
1618  normal_f_i_new.norme();
1619  liste_normales.ajouter(normal_f_i_new);
1620  liste_wij.ajouter(w_ij);
1621  mgtri->change_nouveau_numero(k);
1622  k++;
1623  }
1624 
1625  LISTE_MG_NOEUD::iterator it_no;
1626  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1627  {
1628  int origine = noeud_i->get_origine();
1629  if (origine == MAGIC::ORIGINE::TRIANGULATION)
1630  {
1631  int nb_voisins_j = noeud_i->get_lien_triangle()->get_nb();
1632  double w_ij_prime = 0.0;
1633  OT_VECTEUR_3D v_temp(0.,0.,0.);
1634  OT_VECTEUR_3D v_i(noeud_i->get_x(),noeud_i->get_y(),noeud_i->get_z());
1635  for(int j=0;j<nb_voisins_j;j++)
1636  {
1637  MG_TRIANGLE_PEAU* mgtri_j = (MG_TRIANGLE_PEAU*) noeud_i->get_lien_triangle()->get(j);
1638  //On calcule le centroide cj du triangle mgtri_j
1639  MG_NOEUD* n1 = mgtri_j->get_noeud1();
1640  MG_NOEUD* n2 = mgtri_j->get_noeud2();
1641  MG_NOEUD* n3 = mgtri_j->get_noeud3();
1642  double cj_x = 0.333333333333333*(n1->get_x() + n2->get_x() + n3->get_x());
1643  double cj_y = 0.333333333333333*(n1->get_y() + n2->get_y() + n3->get_y());
1644  double cj_z = 0.333333333333333*(n1->get_z() + n2->get_z() + n3->get_z());
1645  //On forme le vecteur vi_cj
1646  OT_VECTEUR_3D vi_cj(cj_x - noeud_i->get_x(),cj_y - noeud_i->get_y(),cj_z - noeud_i->get_z());
1647  OT_VECTEUR_3D normal_f_i_new = liste_normales.get(mgtri_j->get_nouveau_numero());
1648  v_temp = v_temp + (vi_cj*normal_f_i_new)*normal_f_i_new;
1649  }
1650  //5-On met a jour la position des noeuds
1651  v_i = v_i + (gamma/(2*nb_voisins_j))*v_temp;
1652  nouv_position_x.push_back(v_i.get_x());
1653  nouv_position_y.push_back(v_i.get_y());
1654  nouv_position_z.push_back(v_i.get_z());
1655  }
1656  }
1657 
1658  //On actualise la position des noeuds
1659  int ind_noeud=0;
1660  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1661  {
1662  int origine = noeud_i->get_origine();
1663  if (origine == MAGIC::ORIGINE::TRIANGULATION)
1664  {
1665  noeud_i->change_x(nouv_position_x[ind_noeud]);
1666  noeud_i->change_y(nouv_position_y[ind_noeud]);
1667  noeud_i->change_z(nouv_position_z[ind_noeud]);
1668  ind_noeud++;
1669  }
1670  }
1671 
1672  //Critere d'arret de l'algorithme
1673  int l=0;
1674  int nb_tri = mg_mai->get_nb_mg_triangle();
1675  for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
1676  {
1677  MG_TRIANGLE_PEAU* mgtri_i = (MG_TRIANGLE_PEAU*)mgtri;
1678  OT_VECTEUR_3D normal_f_i = liste_normales2.get(mgtri_i->get_nouveau_numero());
1679  OT_VECTEUR_3D normal_f_i_new = liste_normales.get(mgtri_i->get_nouveau_numero());
1680  double critere = 1. - normal_f_i*normal_f_i_new;
1681  if (critere <= epsilon) l++;
1682  }
1683  double tolerance = 0.01*nb_tri;
1684  if (nb_tri - l <= 0) fin = 1;
1685  compteur++;
1686  }
1687 while ((fin == 0) && (compteur < iter_max));
1688 
1689 return compteur;
1690 
1691 }
1692 
1693 
1694 
1695 int MGOPT_POSTTRAITEMENT::cycle_taubin1995(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, double lambda, double nu)
1696 {
1697 
1699  std::vector<double> nouv_position_x;
1700  std::vector<double> nouv_position_y;
1701  std::vector<double> nouv_position_z;
1702  LISTE_MG_NOEUD::iterator it_no;
1703  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1704  {
1705  int origine = noeud_i->get_origine();
1706  if ((origine == MAGIC::ORIGINE::TRIANGULATION)&& (noeud_i->get_lien_topologie()==NULL))//((origine != MAGIC::ORIGINE::IMPOSE)&& (origine != MAGIC::ORIGINE::TRIANGULATION_ARETE)&&(noeud_i->get_lien_topologie()==NULL))///////////////////////////////////////////////////////////////////////////////
1707  {
1708  TPL_MAP_ENTITE<MG_NOEUD*> liste_voisin;
1709  MG_MAILLAGE_OUTILS ot;
1710  ot.get_noeud_voisin(noeud_i,liste_voisin,2);
1711 
1712  int nb_voisins_j = noeud_i->get_lien_triangle()->get_nb();
1713  double delta_x = 0.0;
1714  double delta_y = 0.0;
1715  double delta_z = 0.0;
1716  double v_x = noeud_i->get_x();//v_1->get_x();
1717  double v_y = noeud_i->get_y();//v_1->get_y();
1718  double v_z = noeud_i->get_z();//v_1->get_z();
1719  double multiplicateur = (1.0/nb_voisins_j);
1720 
1721  for(int j=0;j<nb_voisins_j;j++)
1722  {
1723  double v_i_x=liste_voisin.get(j)->get_x();
1724  double v_i_y=liste_voisin.get(j)->get_y();
1725  double v_i_z=liste_voisin.get(j)->get_z();
1726  delta_x = delta_x+(multiplicateur*(v_i_x-v_x));
1727  delta_y = delta_y+(multiplicateur*(v_i_y-v_y));
1728  delta_z = delta_z+(multiplicateur*(v_i_z-v_z));
1729 
1730  }
1731  double x_prime = (v_x)+(lambda*delta_x);
1732  double y_prime = (v_y)+(lambda*delta_y);
1733  double z_prime = (v_z)+(lambda*delta_z);
1734 
1735  //On calcule la nouvelle position des noeuds et on affecte au tableau temporaire
1736  nouv_position_x.push_back(x_prime);
1737  nouv_position_y.push_back(y_prime);
1738  nouv_position_z.push_back(z_prime);
1739  }
1740  }
1741  //On actualise la position des noeuds
1742  int ind_noeud=0;
1743  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1744  {
1745  int origine = noeud_i->get_origine();
1746  if ((origine == MAGIC::ORIGINE::TRIANGULATION)&& (noeud_i->get_lien_topologie()==NULL))//((origine != MAGIC::ORIGINE::IMPOSE)&& (origine != MAGIC::ORIGINE::TRIANGULATION_ARETE)&&(noeud_i->get_lien_topologie()==NULL))///////////////////////////////////////////////////////////////////////////////
1747  {
1748  noeud_i->change_x(nouv_position_x[ind_noeud]);
1749  noeud_i->change_y(nouv_position_y[ind_noeud]);
1750  noeud_i->change_z(nouv_position_z[ind_noeud]);
1751  ind_noeud++;
1752  }
1753  }
1754 
1755 
1756  //partie nu du lissage
1757  nouv_position_x.clear();
1758  nouv_position_y.clear();
1759  nouv_position_z.clear();
1760  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1761  {
1762  int origine = noeud_i->get_origine();
1763  if ((origine == MAGIC::ORIGINE::TRIANGULATION)&& (noeud_i->get_lien_topologie()==NULL))//((origine != MAGIC::ORIGINE::IMPOSE)&& (origine != MAGIC::ORIGINE::TRIANGULATION_ARETE)&&(noeud_i2->get_lien_topologie()==NULL))///////////////////////////////////////////////////////////////////////////////
1764  {
1765  TPL_MAP_ENTITE<MG_NOEUD*> liste_voisin;
1766  MG_MAILLAGE_OUTILS ot;
1767  ot.get_noeud_voisin(noeud_i,liste_voisin,2);
1768 
1769  int nb_voisins_j = noeud_i->get_lien_triangle()->get_nb();
1770  double delta_x = 0.0;
1771  double delta_y = 0.0;
1772  double delta_z = 0.0;
1773  double v_x = noeud_i->get_x();//v_1->get_x();
1774  double v_y = noeud_i->get_y();//v_1->get_y();
1775  double v_z = noeud_i->get_z();//v_1->get_z();
1776  double multiplicateur = (1.0/nb_voisins_j);
1777 
1778  for(int j=0;j<nb_voisins_j;j++)
1779  {
1780  double v_i_x=liste_voisin.get(j)->get_x();
1781  double v_i_y=liste_voisin.get(j)->get_y();
1782  double v_i_z=liste_voisin.get(j)->get_z();
1783  delta_x = delta_x+(multiplicateur*(v_i_x-v_x));
1784  delta_y = delta_y+(multiplicateur*(v_i_y-v_y));
1785  delta_z = delta_z+(multiplicateur*(v_i_z-v_z));
1786 
1787  }
1788  double x_prime = (v_x)+(nu*delta_x);
1789  double y_prime = (v_y)+(nu*delta_y);
1790  double z_prime = (v_z)+(nu*delta_z);
1791 
1792  //On calcule la nouvelle position des noeuds et on affecte au tableau temporaire
1793  nouv_position_x.push_back(x_prime);
1794  nouv_position_y.push_back(y_prime);
1795  nouv_position_z.push_back(z_prime);
1796  }
1797  }
1798  //On actualise la position des noeuds
1799  ind_noeud=0;
1800  for (MG_NOEUD* noeud_i=mg_mai->get_premier_noeud(it_no);noeud_i!=NULL;noeud_i=mg_mai->get_suivant_noeud(it_no))
1801  {
1802  int origine = noeud_i->get_origine();
1803  if ((origine == MAGIC::ORIGINE::TRIANGULATION)&& ( noeud_i->get_lien_topologie()==NULL))//((origine != MAGIC::ORIGINE::IMPOSE)&& (origine != MAGIC::ORIGINE::TRIANGULATION_ARETE)&&( noeud_i2->get_lien_topologie()==NULL))/////////////////////////////////////////////////////////////////////////////
1804  {
1805  noeud_i->change_x(nouv_position_x[ind_noeud]);
1806  noeud_i->change_y(nouv_position_y[ind_noeud]);
1807  noeud_i->change_z(nouv_position_z[ind_noeud]);
1808  ind_noeud++;
1809  }
1810  }
1811 return 1;
1812 
1813 }
1814 
1815 int MGOPT_POSTTRAITEMENT::lissage_Taubin1995(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, double lambda, double nu, int iter_max)
1816 {
1817 int compt = 0;
1818 int ok = 0;
1819 char mess[200];
1820  do
1821  {
1822  int taubin=cycle_taubin1995(mg_mai, gest2, lambda, nu);
1823  sprintf(mess, "cycle taubin faite"); affiche(mess);
1824  compt = compt+1;
1825  sprintf(mess, "incrémentation compt %d",compt); affiche(mess);
1826  }while (compt < iter_max);
1827  return compt;
1828  sprintf(mess, "fin Taubin1995"); affiche(mess);
1829 }
1830 
1831 
1832 void MGOPT_POSTTRAITEMENT::varience_McKenzie2016(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, double *vari0,double *vari1,double *vari2)
1833 {
1834 char mess[300];
1835 int ecart_type = 0;
1836 double s_i = 0.0;
1837 double phi_im = 0.0;
1838 double ecart_type_i = 0.;
1839 ecart_type = 0;
1840 do
1841 {
1842 
1843  TPL_LISTE_ENTITE<OT_VECTEUR_3D> liste_normales;
1844  TPL_LISTE_ENTITE<OT_VECTEUR_3D> liste_normales2;
1845  TPL_LISTE_ENTITE<double> liste_wij;
1846  LISTE_MG_TRIANGLE::iterator it_tri;
1847  int k = 0; //pour identifier les triangles pour liste_normales et liste_wij
1848  for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
1849  {
1850  MG_TRIANGLE_PEAU* mgtri_i = (MG_TRIANGLE_PEAU*)mgtri;
1851  OT_VECTEUR_3D normal_f_i = mgtri_i->calcul_normal();
1852  normal_f_i.norme();
1853  liste_normales2.ajouter(normal_f_i);
1854  //Remplissage de la liste des voisins du triangle i
1855  TPL_MAP_ENTITE<MG_TRIANGLE_PEAU*> liste_voisins;
1856  MG_NOEUD* noeud1 = mgtri_i->get_noeud1();
1857  double nb_voisins1 = noeud1->get_lien_triangle()->get_nb();
1858  for (int j = 0;j<nb_voisins1;j++)
1859  {
1860  MG_TRIANGLE_PEAU* mgtri_1 = (MG_TRIANGLE_PEAU*) noeud1->get_lien_triangle()->get(j);
1861  liste_voisins.ajouter(mgtri_1);
1862  }
1863  MG_NOEUD* noeud2 = mgtri_i->get_noeud2();
1864  double nb_voisins2 = noeud2->get_lien_triangle()->get_nb();
1865  for (int j = 0;j<nb_voisins2;j++)
1866  {
1867  MG_TRIANGLE_PEAU* mgtri_2 = (MG_TRIANGLE_PEAU*) noeud2->get_lien_triangle()->get(j);
1868  liste_voisins.ajouter(mgtri_2);
1869  }
1870  MG_NOEUD* noeud3 = mgtri_i->get_noeud3();
1871  double nb_voisins3 = noeud3->get_lien_triangle()->get_nb();
1872  for (int j = 0;j<nb_voisins3;j++)
1873  {
1874  MG_TRIANGLE_PEAU* mgtri_3 = (MG_TRIANGLE_PEAU*) noeud3->get_lien_triangle()->get(j);
1875  liste_voisins.ajouter(mgtri_3);
1876  }
1877  liste_voisins.supprimer(mgtri_i);
1878  int nb_voisins = liste_voisins.get_nb();
1879  double w_ij = 1./nb_voisins;
1880  double phi_i_min = 10.;
1881  s_i = 0.0;
1882  phi_im = 0.0;
1883  double *phi_ij = new double[nb_voisins];
1884  OT_VECTEUR_3D normal_f_i_mean(0.,0.,0.);
1885  normal_f_i_mean = normal_f_i;
1886  OT_VECTEUR_3D eta_i(0.,0.,0.);
1887  TPL_MAP_ENTITE<MG_TRIANGLE_PEAU*>::ITERATEUR it;
1888  int j = 0;
1889  double un_sur_pi = 1./M_PI;
1890  for(MG_TRIANGLE_PEAU* mgtri_j=liste_voisins.get_premier(it);mgtri_j!=NULL;mgtri_j=liste_voisins.get_suivant(it))
1891  {
1892  OT_VECTEUR_3D normal_f_j = mgtri_j->calcul_normal();
1893  //1-Calculer la normale moyenne pour chaque triangle
1894  normal_f_i_mean = normal_f_i_mean + normal_f_j;
1895  //2.1-On calcule l'angle entre normal_f_i et normal_f_j pour j allant de 1 a Nb_voisins
1896  double prod_scalaire = normal_f_i*normal_f_j;
1897  if (prod_scalaire > 1.)
1898  {
1899  prod_scalaire = 1.;
1900  }
1901  if (prod_scalaire < -1.)
1902  {
1903  prod_scalaire = -1.;
1904  }
1905  phi_ij[j] = acos(prod_scalaire)*un_sur_pi;
1906  //2.2-On trouve le plus petit des angles et la normale heta_i correspondante
1907  if (phi_ij[j] < phi_i_min)
1908  {
1909  phi_i_min = phi_ij[j];
1910  eta_i = normal_f_j;
1911  }
1912  //3.1-On calcule l'angle moyen phi_im
1913  phi_im = phi_im + w_ij*phi_ij[j];
1914  j++;
1915  }
1916  normal_f_i_mean.norme();
1917  j = 0;
1918  for(MG_TRIANGLE_PEAU* mgtri_j=liste_voisins.get_premier(it);mgtri_j!=NULL;mgtri_j=liste_voisins.get_suivant(it))
1919  {
1920  //3.2-Calcul de s_i selon la variance
1921  s_i = s_i + w_ij*pow((phi_ij[j] - phi_im),2);
1922  j++;
1923  }
1924  delete[] phi_ij;
1925  }
1926  ecart_type_i = sqrt(s_i);
1927  ecart_type = 1;
1928  }
1929 while (ecart_type == 0);
1930 ecart_type = 0;//reinitialisation d'ecart_type pour la prochainepasse
1931 *vari0 = phi_im;
1932 *vari1 = s_i;
1933 *vari2 = ecart_type_i;
1934 
1935 }
1936 
1937 
1938 int MGOPT_POSTTRAITEMENT::lissage_McKenzie2016(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2, double lambda, double nu, double epsilon,double sigma,double gamma_,int filtre, int iter_max, int itr_taubin)
1939 {
1940 
1941 
1942 std::vector<double> coord_x;
1943 std::vector<double> coord_y;
1944 std::vector<double> coord_z;
1945 std::vector<double> vecteur_original;
1946  LISTE_MG_NOEUD::iterator it_no;
1947  int ii=0;
1948  for (MG_NOEUD* noeud=mg_mai->get_premier_noeud(it_no);noeud!=NULL;noeud=mg_mai->get_suivant_noeud(it_no))
1949  {
1950  MG_NOEUD* tri=(MG_NOEUD*)noeud;
1951  if(tri->get_origine()!=MAGIC::ORIGINE::MAILLEUR_AUTO)
1952  {
1953  coord_x.push_back(noeud->get_x());
1954  coord_y.push_back(noeud->get_y());
1955  coord_z.push_back(noeud->get_z());
1956  vecteur_original.push_back(sqrt(coord_x[ii]*coord_x[ii] + coord_y[ii]*coord_y[ii] + coord_z[ii]*coord_z[ii]));
1957  ii++;
1958  }
1959 
1960  }
1961 
1962 
1963 
1964 char mess[300];
1965 sprintf(mess, "Depart Taubin1995"); affiche(mess);
1966 double v_initial = 0.0;
1967 double v_final = 0.0;
1968 double v_taubin = 0.0;
1969 double v_taubin_prime = 0.0;
1970 double d_initial = 0.0;
1971 double d_final = 0.0;
1972 double d_taubin = 0.0;
1973 double nu_ = nu;
1974 double sigma_ = sigma;//variable utiliser pour sassuré que la pièce ne grossie pas dan taubin_chen 2
1975 int ecart_type = 0;
1976 double s_i = 0.0;
1977 double phi_im = 0.0;
1978 double ecart_type_i = 0.;
1979 int compteur_triangle_retourne =0;
1980 int compteur_total = 0;
1981 int compteur_taubin_initial = 0;
1982 int compteur_chen = 0;
1983 int compteur_taubin_chen = 0;
1984 int compteur_taubin_final = 0;
1985 int compteur_temp = 0;
1986 int compteur_taubin2D = 0;
1987 int triangle_final_retourne =0;
1988 int iter_taubin = itr_taubin;
1989 
1990 
1991 
1992 int activationPI = 1; // variable qui active l'adjustement du volume dans taubin1995
1993 int activationPI2 = 1; // variable qui active l'adjustement du volume dans taubin_chen
1994 double condition_de_varience = 1000.0; //variable de sortie pour les prenières iteration taubin pour s'assuré que la surface a une certaine surface lisse
1995 int taubin_premiere_passe = 0;
1996 
1998  MG_MAILLAGE_OUTILS ot;
1999  v_initial=ot.get_volume(mg_mai);
2000 
2001 
2002 
2003 
2004 
2005 
2006 double varience_ori0 = 10.0;
2007 double varience_ori1 = 10.0;
2008 double varience_ori2 = 10.0;
2009 varience_McKenzie2016(mg_mai,gest2, &varience_ori0, &varience_ori1, &varience_ori2);
2010  sprintf(mess," Moyenne des normes des triangles de la surface : %f",varience_ori0); affiche(mess);
2011  sprintf(mess," Varience des normes des triangles de la surface : %f",varience_ori1); affiche(mess);
2012  sprintf(mess," Ecart type des normes des triangles de la surface : %f",varience_ori2); affiche(mess);
2013 v_taubin=v_initial; //ajout vincent
2014 do
2015  {
2016  v_taubin_prime = v_taubin;//assignation du volume de l'itération précédente pour fair la loi de controle
2017  int taubin=cycle_taubin1995(mg_mai, gest2, lambda, nu);
2018 
2019  MG_MAILLAGE_OUTILS ot;
2020  v_taubin=ot.get_volume(mg_mai);
2021 
2022  //implemantion d'un PI por controler le volume
2023  if (activationPI==1)
2024  {
2025  if (((fabs(v_taubin)-fabs(v_taubin_prime))/fabs(v_taubin))<-0.1)//fine adjustment makes part bigger if new iteration of part is smaller than the preceeding pass and volume is less than 10% bigger than original
2026  {
2027  nu_ =nu_-0.00005;
2028  }
2029  if (((fabs(v_taubin)-fabs(v_taubin_prime))/fabs(v_taubin))>0.1)//fine adjustment makes part smaller if part is much bigger than preceeding pass and the volume is larger than original
2030  {
2031  nu_ = nu_+0.00005;
2032  }
2033  if (fabs(v_taubin)>(fabs(v_initial)*1.015))//gross adjustment makes part smaller if part is 3% bigger than original make smaller
2034  {
2035  nu_ =nu_+0.0005;
2036  }
2037  if (fabs(v_taubin)<(fabs(v_initial)*0.985))//gross adjustment makes part bigger if it is smaller than the original
2038  {
2039  nu_ =nu_-0.0005;
2040  }
2041  }
2042  //double un_sur_pi = 1./M_PI;
2043 
2044 
2045 
2046 
2047  //code qui vérifie la qualité des different trianges
2048 MAILLEUR_ANALYSE m3d(mg_mai);
2049 m3d.change_eps_angle_retourne(0.03000);
2050 m3d.change_borne(0.1,0.2,0.5);
2051 double qualmin,qualmax,qualmoy;
2052 int tab[7];
2053 m3d.analyse_qualite_maillage_2D(NULL,qualmin,qualmax,qualmoy,tab);
2054 int nbretourne=tab[0];
2055 int itri=0;
2056 
2057 
2058 
2059  if (tab[0]>0)
2060  {
2061  compteur_triangle_retourne++;
2062  compteur_temp--;
2063  sprintf(mess, "Triangle retourné");
2064  affiche(mess);
2065  }
2066  compteur_taubin_initial++;
2067  compteur_total++;
2068  compteur_temp++;
2069 
2070 
2071 double varience0 = 0.0;
2072 double varience1 =0.0;
2073 double varience2 =0.0;
2074 varience_McKenzie2016(mg_mai,gest2, &varience0, &varience1, &varience2);
2075 
2076  if (((compteur_temp >= iter_taubin)&&(varience1<0.0275))||(compteur_taubin_initial >(2*iter_taubin)))
2077  {
2078  taubin_premiere_passe = 1;
2079  }
2080 
2081 
2082  }
2083 while (taubin_premiere_passe == 0);
2084 
2085 
2086 
2087 
2088 
2089 
2090 
2091 
2092 
2093  sprintf(mess, "Début de Chen pour %d iterations avec Taubin qui résoud les triangles retournés",iter_max); affiche(mess);
2094 
2095  do
2096  {
2097 
2098 int nbiter=lissage_chen2008(mg_mai,gest2,sigma,gamma_,epsilon,1);
2099 
2100 MAILLEUR_ANALYSE m3d(mg_mai);
2101 m3d.change_eps_angle_retourne(0.03000);
2102 m3d.change_borne(0.1,0.2,0.5);
2103 double qualmin,qualmax,qualmoy;
2104 int tab[7];
2105 m3d.analyse_qualite_maillage_2D(NULL,qualmin,qualmax,qualmoy,tab);
2106 int triangleretourner =tab[0];
2107 
2108 if (triangleretourner >0)
2109 {
2110 do
2111  {
2112  v_taubin_prime = v_taubin;//assignation du volume de l'itération précédente pour fair la loi de controle
2113  int taubin=cycle_taubin1995(mg_mai, gest2, lambda, nu);
2114 
2115  MG_MAILLAGE_OUTILS ot;
2116  v_taubin=ot.get_volume(mg_mai);
2117 
2118  //implemantion d'un PI por controler le volume
2119  if (activationPI2 = 1)
2120  {
2121 
2122  if (((fabs(v_taubin)-fabs(v_taubin_prime))/fabs(v_taubin))<-0.1)//fine adjustment makes part bigger if new iteration of part is smaller than the preceeding pass and volume is less than 10% bigger than original
2123  {
2124  nu_ =nu_-0.00005;
2125  }
2126 
2127  if (((fabs(v_taubin)-fabs(v_taubin_prime))/fabs(v_taubin))>0.1)//fine adjustment makes part smaller if part is much bigger than preceeding pass and the volume is larger than original
2128  {
2129  nu_ = nu_+0.00005;
2130  }
2131 
2132  if (fabs(v_taubin)>(fabs(v_initial)*1.015))//gross adjustment makes part smaller if part is 3% bigger than original make smaller
2133  {
2134  nu_ =nu_+0.0005;
2135  }
2136  if (fabs(v_taubin)<(fabs(v_initial)*0.985))//gross adjustment makes part bigger if it is smaller than the original
2137  {
2138  nu_ =nu_-0.0005;
2139  }
2140  }
2141 
2142 m3d.analyse_qualite_maillage_2D(NULL,qualmin,qualmax,qualmoy,tab);
2143 if (tab[0]>0)
2144  {
2145  triangleretourner = 1;
2146  sprintf(mess, "Trianlge retourner pas régler"); affiche(mess);
2147 
2148  }
2149  else
2150  {
2151  triangleretourner = 0;
2152  sprintf(mess, "Trianlge retourner régler"); affiche(mess);
2153  }
2154 compteur_triangle_retourne++;
2155 compteur_taubin_chen++;
2156 compteur_total++;
2157 }
2158 
2159 while ((triangleretourner > 0));
2160 
2161 }
2162 compteur_total++;
2163 compteur_chen++;
2164 
2165 
2166 }
2167 while (compteur_chen < iter_max);
2168 
2169 sprintf(mess, "Début du retour de volume avec Taubin1995 qui résoud les triangles retournés"); affiche(mess);
2170 v_taubin=ot.get_volume(mg_mai);
2171 
2172 if ((fabs(fabs(v_initial)-fabs(v_taubin)))>(0.02*(fabs(v_initial))))
2173 {
2174 do
2175  {
2176  v_taubin_prime = v_taubin;
2177  int taubin=cycle_taubin1995(mg_mai, gest2, lambda, nu);
2178 
2179  v_taubin=ot.get_volume(mg_mai);
2180 
2181  //implemantion d'un PDF pour controler le volume
2182 
2183  if (((fabs(v_taubin)-fabs(v_taubin_prime))/fabs(v_taubin))<-0.1)//fine adjustment makes part bigger if new iteration of part is smaller than the preceeding pass and volume is less than 10% bigger than original
2184  {
2185  nu_ =nu_-0.00002;
2186  sprintf(mess, "ajustement mineur 1"); affiche(mess);
2187  }
2188 
2189  if (((fabs(v_taubin)-fabs(v_taubin_prime))/fabs(v_taubin))>0.1)//fine adjustment makes part smaller if part is much bigger than preceeding pass and the volume is larger than original
2190  {
2191  nu_ = nu_+0.00002;
2192  sprintf(mess, "ajustement mineur 2"); affiche(mess);
2193  }
2194 
2195  if (fabs(v_taubin)>(fabs(v_initial)*1.015))//gross adjustment makes part smaller if part is 1.5% bigger than original make smaller
2196  {
2197  nu_ =nu_+0.0005;
2198  sprintf(mess, "ajustement majeur 1"); affiche(mess);
2199  }
2200  if (fabs(v_taubin)<(fabs(v_initial)*0.985))//gross adjustment makes part bigger if it is more than 1.5% smaller than the original
2201  {
2202  nu_ =nu_-0.0005;
2203  sprintf(mess, "ajustement majeur 2"); affiche(mess);
2204  }
2205  sprintf(mess, "Volume: %f\n old vol: %f\n nu_: %f\n",v_taubin,v_taubin_prime, nu_); affiche(mess);
2206 
2207 
2208 
2209 
2210  //code qui vérifie la qualité des different trianges
2211 MAILLEUR_ANALYSE m3d(mg_mai);
2212 m3d.change_eps_angle_retourne(0.03000);
2213 m3d.change_borne(0.1,0.2,0.5);
2214 double qualmin,qualmax,qualmoy;
2215 int tab[7];
2216 m3d.analyse_qualite_maillage_2D(NULL,qualmin,qualmax,qualmoy,tab);
2217 int triangleretourner =tab[0];
2218 if (tab[0]>0)
2219  {
2220  compteur_triangle_retourne++;
2221  sprintf(mess, "Triangle retourné");
2222  affiche(mess);
2223  triangle_final_retourne =1;
2224  }
2225  else{triangle_final_retourne =0;}
2226 
2227  compteur_taubin_final++;
2228  compteur_total++;
2229 
2230  }
2231 
2232 while ((triangle_final_retourne ==0)&&(fabs(v_initial-v_taubin)>(fabs(0.02*v_initial))));//((compteur_ < 1000));
2233 
2234 }
2235 
2236 /******************code qui calcule la moyenne de pourcentage de déplacement des differents noeuds*/
2237  //LISTE_MG_NOEUD::iterator it_no;
2238  ii=0;
2239  int numdepla=0;
2240  double distot=0;
2241  double distotx=0;
2242  double distoty=0;
2243  double distotz=0;
2244  double dismin=1e300,dismax=-1e300;
2245  double disminx=1e300,dismaxx=-1e300;
2246  double disminy=1e300,dismaxy=-1e300;
2247  double disminz=1e300,dismaxz=-1e300;
2248  double xmin=1e300,xmax=-1e300;
2249  double ymin=1e300,ymax=-1e300;
2250  double zmin=1e300,zmax=-1e300;
2251  for (MG_NOEUD* noeud=mg_mai->get_premier_noeud(it_no);noeud!=NULL;noeud=mg_mai->get_suivant_noeud(it_no))
2252  {
2253  if(noeud->get_origine()!=MAGIC::ORIGINE::IMPOSE)
2254  {
2255  double x=noeud->get_x();
2256  double y=noeud->get_y();
2257  double z=noeud->get_z();
2258  if (x<xmin) xmin=x;
2259  if (y<ymin) ymin=y;
2260  if (z<zmin) zmin=z;
2261  if (x>xmax) xmax=x;
2262  if (y>ymax) ymax=y;
2263  if (z>zmax) zmax=z;
2264  double dx=fabs(noeud->get_x()-coord_x[ii]);
2265  double dy=fabs(noeud->get_y()-coord_y[ii]);
2266  double dz=fabs(noeud->get_z()-coord_z[ii]);
2267  double dis=sqrt(dx*dx+dy*dy+dz*dz);
2268  if (dx>dismaxx) dismaxx=dx;
2269  if (dx<disminx) disminx=dx;
2270  if (dy>dismaxy) dismaxy=dy;
2271  if (dy<disminy) disminy=dy;
2272  if (dz>dismaxz) dismaxz=dz;
2273  if (dz<disminz) disminz=dz;
2274  if (dis>dismax) dismax=dis;
2275  if (dis<dismin) dismin=dis;
2276  distot=distot+dis;
2277  distotx=distoty+dx;
2278  distoty=distoty+dy;
2279  distotz=distotz+dz;
2280  numdepla++;
2281  }
2282  ii++;
2283  }
2284 affiche((char*)"");
2285 sprintf(mess, "Déplacement absolu minimum en X : %f en Y : %f en Z : %f en amplitude : %f",disminx,disminy,disminz,dismin); affiche(mess);
2286 sprintf(mess, "Déplacement absolu maximum en X : %f en Y : %f en Z : %f en amplitude : %f",dismaxx,dismaxy,dismaxz,dismax); affiche(mess);
2287 sprintf(mess, "Déplacement absolu moyen (tous les noeuds) en X : %f en Y : %f en Z : %f en amplitude : %f",distotx/ii,distoty/ii,distotz/ii,distot/ii); affiche(mess);
2288 sprintf(mess, "Déplacement absolu moyen (les noeuds du non design) en X : %f en Y : %f en Z : %f en amplitude : %f",distotx/numdepla,distoty/numdepla,distotz/numdepla,distot/numdepla); affiche(mess);
2289 double dx=xmax-xmin;
2290 double dy=ymax-ymin;
2291 double dz=zmax-zmin;
2292 double dmax=dx;
2293 if (dy>dmax) dmax=dy;
2294 if (dz>dmax) dmax=dz;
2295 sprintf(mess, "Déplacement relatif moyen (tous les noeuds) en X : %f%% en Y : %f%% en Z : %f%% en amplitude : %f%%",distotx/ii/dx*100.,distoty/ii/dy*100.,distotz/ii/dz*100.,distot/ii/dmax*100.); affiche(mess);
2296 sprintf(mess, "Déplacement relatif moyen (les noeuds du non design) en X : %f%% en Y : %f%% en Z : %f%% en amplitude : %f%%",distotx/numdepla/dx*100.,distoty/numdepla/dy*100.,distotz/numdepla/dz*100.,distot/numdepla/dmax*100.); affiche(mess);
2297 
2298 
2299 
2300 affiche((char*)"");
2301 
2302 affiche((char*)"");
2303 
2304 
2305 
2306  v_final=ot.get_volume(mg_mai);
2307 
2308 double delta_vol = v_final-v_initial;
2309 double vol_pourcent = (v_final/v_initial)*100;
2310 double delta_vol_pourcent = vol_pourcent-100;
2311 sprintf(mess, "Volume initial: %f",v_initial);affiche(mess);
2312 sprintf(mess, "Volume final: %f",v_final);affiche(mess);
2313 sprintf(mess, "Volume final pourcentage: %f%%",vol_pourcent);affiche(mess);
2314 sprintf(mess, "Delta Volume: %f",delta_vol);affiche(mess);
2315 sprintf(mess, "Delta Volume pourcentage: %f%%",delta_vol_pourcent);affiche(mess);
2316 sprintf(mess, " Iteration inital Taubin1995: %i",compteur_taubin_initial); affiche(mess);
2317 sprintf(mess, " Iteration Chen2008: %i",compteur_chen); affiche(mess);
2318 sprintf(mess, " Iteration Taubin1995 dans Chen2008: %i",compteur_taubin_chen); affiche(mess);
2319 sprintf(mess, " epsilon: %f",epsilon); affiche(mess);
2320 sprintf(mess, " sigma: %f",sigma); affiche(mess);
2321 sprintf(mess, " gamma_: %f",gamma_); affiche(mess);
2322 sprintf(mess, " filtre: %i",filtre); affiche(mess);
2323 sprintf(mess, " Iteration final Taubin1995: %i",compteur_taubin_final); affiche(mess);
2324 sprintf(mess, " lambda(depart): %f",lambda); affiche(mess);
2325 sprintf(mess, " nu(depart):%f",nu); affiche(mess);
2326 sprintf(mess, " nu(fin):%f",nu_); affiche(mess);
2327 sprintf(mess, " Iteration triangle retourné: %i",compteur_triangle_retourne); affiche(mess);
2328 sprintf(mess, " Iteration Total: %i",compteur_total); affiche(mess);
2329 
2330 
2331 
2332 MAILLEUR_ANALYSE m3d(mg_mai);
2333 double eps_angle_retourne=0.03;
2334 m3d.change_eps_angle_retourne(eps_angle_retourne);
2335 double borne1=0.1;
2336 double borne2=0.2;
2337 double borne3=0.5;
2338 m3d.change_borne(borne1,borne2,borne3);
2339 double qualmin,qualmax,qualmoy;
2340 int tab[7];
2341 m3d.analyse_qualite_maillage_2D(NULL,qualmin,qualmax,qualmoy,tab);
2342 sprintf(mess,"\n\nANALYSEUR DE MG MAILLAGE 2D"); affiche(mess);
2343  sprintf(mess," Nombre de triangles avec des noeuds fusionnés : %d",tab[6]); affiche(mess);
2344  sprintf(mess," Nombre de triangles avec 1 voisin manquant : %d",tab[5]); affiche(mess);
2345  sprintf(mess," critere d'angle limite pour l'inversion : %lf",eps_angle_retourne); affiche(mess);
2346  sprintf(mess," qualite moyenne des triangles de frontiere : %lf",qualmoy); affiche(mess);
2347  sprintf(mess," qualite min des triangles de frontiere : %lf",qualmin); affiche(mess);
2348  sprintf(mess," qualite max des triangles de frontiere : %lf",qualmax); affiche(mess);
2349  sprintf(mess," nombre de triangles de frontiere >%lf : %d (%.2lf%%)",borne3,tab[4],tab[4]*100./mg_mai->get_nb_mg_triangle()); affiche(mess);
2350  sprintf(mess," nombre de triangles de frontiere >%lf : %d (%.2lf%%)",borne2,tab[3],tab[3]*100./mg_mai->get_nb_mg_triangle()); affiche(mess);
2351  sprintf(mess," nombre de triangles de frontiere >%lf : %d (%.2lf%%)",borne1,tab[2],tab[2]*100./mg_mai->get_nb_mg_triangle()); affiche(mess);
2352  sprintf(mess," nombre de triangles de frontiere >%lf : %d (%.2lf%%)",0.,tab[1],tab[1]*100./mg_mai->get_nb_mg_triangle()); affiche(mess);
2353  sprintf(mess," nombre de triangles de frontiere retournes : %d (%.2lf%%)",tab[0],tab[0]*100./mg_mai->get_nb_mg_triangle()); affiche(mess);
2354 
2355 double varience00 =0.0;
2356 double varience11 =0.0;
2357 double varience22 =0.0;
2358 varience_McKenzie2016(mg_mai,gest2, &varience00, &varience11, &varience22);
2359  sprintf(mess,"\n Moyenne des normes des triangles de la surface : %f",varience00); affiche(mess);
2360  sprintf(mess," Varience des normes des triangles de la surface : %f",varience11); affiche(mess);
2361  sprintf(mess," Ecart type des normes des triangles de la surface : %f",varience22); affiche(mess);
2362 
2363 return compteur_total;
2364 }
2365 
2366 
2367 
2368 
2369 int MGOPT_POSTTRAITEMENT::extract_skin(MG_MAILLAGE* mg_mai,MG_GESTIONNAIRE& gest2,int &nbpeau,int &nbmaniare,int &nbmanino, int *mai2_id)
2370 {
2371 
2372 LISTE_MG_TRIANGLE::iterator it_tri;
2373 for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
2374  {
2375  mgtri->change_nouveau_numero(0);
2376  mgtri->change_origine(MAGIC::ORIGINE::MAILLEUR_AUTO);
2377  }
2378 LISTE_MG_NOEUD::iterator it_noeud;
2379 for (MG_NOEUD* mgnoeud=mg_mai->get_premier_noeud(it_noeud);mgnoeud!=NULL;mgnoeud=mg_mai->get_suivant_noeud(it_noeud))
2380  {
2381  mgnoeud->change_nouveau_numero(0);
2382  }
2383 
2384 LISTE_MG_TETRA::iterator it_tetra;
2385 for (MG_TETRA* mgtet=mg_mai->get_premier_tetra(it_tetra);mgtet!=NULL;mgtet=mg_mai->get_suivant_tetra(it_tetra))
2386  {
2387  int origine = mgtet->get_origine();
2388  if (origine==MAGIC::ORIGINE::IMPOSE)
2389  {
2390  mgtet->get_triangle1()->change_origine(MAGIC::ORIGINE::IMPOSE);
2391  mgtet->get_triangle2()->change_origine(MAGIC::ORIGINE::IMPOSE);
2392  mgtet->get_triangle3()->change_origine(MAGIC::ORIGINE::IMPOSE);
2393  mgtet->get_triangle4()->change_origine(MAGIC::ORIGINE::IMPOSE);
2394  }
2395  if (origine==MAGIC::ORIGINE::OPTIMISE)
2396  {
2397  if (mgtet->get_triangle1()->get_origine()!=MAGIC::ORIGINE::IMPOSE) mgtet->get_triangle1()->change_origine(MAGIC::ORIGINE::OPTIMISE);
2398  if (mgtet->get_triangle2()->get_origine()!=MAGIC::ORIGINE::IMPOSE) mgtet->get_triangle2()->change_origine(MAGIC::ORIGINE::OPTIMISE);
2399  if (mgtet->get_triangle3()->get_origine()!=MAGIC::ORIGINE::IMPOSE) mgtet->get_triangle3()->change_origine(MAGIC::ORIGINE::OPTIMISE);
2400  if (mgtet->get_triangle4()->get_origine()!=MAGIC::ORIGINE::IMPOSE) mgtet->get_triangle4()->change_origine(MAGIC::ORIGINE::OPTIMISE);
2401  }
2402 
2403  if (((origine == MAGIC::ORIGINE::OPTIMISE) && (etat[(MAGIC::ORIGINE::OPTIMISE-1000)/10]==1) ) ||
2404  ((origine == MAGIC::ORIGINE::IMPOSE) && (etat[(MAGIC::ORIGINE::IMPOSE-1000)/10]==1) ) ||
2405  ((origine == MAGIC::ORIGINE::MAILLEUR_AUTO) && (etat[(MAGIC::ORIGINE::MAILLEUR_AUTO-1000)/10]==1) ) ||
2406  ((origine == MAGIC::ORIGINE::TRIANGULATION) && (etat[(MAGIC::ORIGINE::TRIANGULATION-1000)/10]==1) ) ||
2407  ((origine == MAGIC::ORIGINE::MODIFICATION) && (etat[(MAGIC::ORIGINE::MODIFICATION-1000)/10]==1) ) ||
2408  ((origine == MAGIC::ORIGINE::DUPLIQUER) && (etat[(MAGIC::ORIGINE::DUPLIQUER-1000)/10]==1) ) )
2409 
2410  {
2411  int num1 = mgtet->get_triangle1()->get_nouveau_numero();
2412  int num2 = mgtet->get_triangle2()->get_nouveau_numero();
2413  int num3 = mgtet->get_triangle3()->get_nouveau_numero();
2414  int num4 = mgtet->get_triangle4()->get_nouveau_numero();
2415  num1++;
2416  num2++;
2417  num3++;
2418  num4++;
2419  mgtet->get_triangle1()->change_nouveau_numero(num1);
2420  mgtet->get_triangle2()->change_nouveau_numero(num2);
2421  mgtet->get_triangle3()->change_nouveau_numero(num3);
2422  mgtet->get_triangle4()->change_nouveau_numero(num4);
2423  }
2424  }
2425 
2426 for (MG_TRIANGLE* mgtri=mg_mai->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mg_mai->get_suivant_triangle(it_tri))
2427  {
2428  int num = mgtri->get_nouveau_numero();
2429  if (num == 1)
2430  {
2431  MG_NOEUD* noeud1 = mgtri->get_noeud1();
2432  MG_NOEUD* noeud2 = mgtri->get_noeud2();
2433  MG_NOEUD* noeud3 = mgtri->get_noeud3();
2434  noeud1->change_nouveau_numero(1);
2435  noeud2->change_nouveau_numero(1);
2436  noeud3->change_nouveau_numero(1);
2437  if (mgtri->get_origine()==MAGIC::ORIGINE::IMPOSE)
2438  {
2439  noeud1->change_origine(MAGIC::ORIGINE::IMPOSE);
2440  noeud2->change_origine(MAGIC::ORIGINE::IMPOSE);
2441  noeud3->change_origine(MAGIC::ORIGINE::IMPOSE);
2442  }
2443  }
2444  }
2445 
2446 gest2.vide();
2447 MG_GEOMETRIE* geo=new MG_GEOMETRIE((char*)"VIRTUEL",(char*)"VIRTUEL");
2448 geo->change_valeur_unite(mg_mai->get_mg_geometrie()->get_valeur_unite());
2449 gest2.ajouter_mg_geometrie(geo);
2450 MG_VOLUME_ELEMENT* vol=new MG_VOLUME_ELEMENT();
2451 geo->ajouter_mg_volume(vol);
2452 vol->copie_ccf(*(mg_mai->get_mg_geometrie()->get_mg_volume(0)));
2453 std::map<unsigned long,unsigned long> correspondidsom;
2454 std::map<unsigned long,unsigned long> correspondid;
2455 LISTE_MG_SOMMET::iterator its;
2456 for (MG_SOMMET* som=mg_mai->get_mg_geometrie()->get_premier_sommet(its);som!=NULL;som=mg_mai->get_mg_geometrie()->get_suivant_sommet(its))
2457  {
2458  if (som->get_nb_ccf()>0)
2459  {
2460  MG_SOMMET_NOEUD* somno=new MG_SOMMET_NOEUD();
2461  geo->ajouter_mg_sommet(somno);
2462  somno->copie_ccf(*som);
2463  correspondidsom[som->get_id()]=somno->get_id();
2464  }
2465  }
2466 LISTE_MG_ARETE::iterator ita;
2467 for (MG_ARETE* are=mg_mai->get_mg_geometrie()->get_premier_arete(ita);are!=NULL;are=mg_mai->get_mg_geometrie()->get_suivant_arete(ita))
2468  {
2469  if (are->get_nb_ccf()>0)
2470  {
2471  MG_ARETE_ELEMENT* areel=new MG_ARETE_ELEMENT();
2472  geo->ajouter_mg_arete(areel);
2473  areel->copie_ccf(*are);
2474  correspondid[are->get_id()]=areel->get_id();
2475  }
2476  }
2477 LISTE_MG_FACE::iterator itf;
2478 for (MG_FACE* face=mg_mai->get_mg_geometrie()->get_premier_face(itf);face!=NULL;face=mg_mai->get_mg_geometrie()->get_suivant_face(itf))
2479  {
2480  if (face->get_nb_ccf()>0)
2481  {
2482  MG_FACE_ELEMENT* facel=new MG_FACE_ELEMENT();
2483  geo->ajouter_mg_face(facel);
2484  facel->copie_ccf(*face);
2485  correspondid[face->get_id()]=facel->get_id();
2486  }
2487  }
2488 MG_FACE_ELEMENT* faceex=new MG_FACE_ELEMENT();
2489 geo->ajouter_mg_face(faceex);
2490 MG_FACE_ELEMENT* facenoex=new MG_FACE_ELEMENT();
2491 geo->ajouter_mg_face(facenoex);
2492 MG_MAILLAGE* mai2 = new MG_MAILLAGE(geo);
2493 gest2.ajouter_mg_maillage(mai2);
2494 
2495 for (MG_NOEUD* mgnoeud=mg_mai->get_premier_noeud(it_noeud);mgnoeud!=NULL;mgnoeud=mg_mai->get_suivant_noeud(it_noeud))
2496  {
2497  int num = mgnoeud->get_nouveau_numero();
2498  if (num == 1)
2499  {
2500  double x = mgnoeud->get_x();
2501  double y = mgnoeud->get_y();
2502  double z = mgnoeud->get_z();
2503  int origine=MAGIC::ORIGINE::TRIANGULATION;
2504  int nb_tri=mgnoeud->get_lien_triangle()->get_nb();
2505  bool tri2d=false,tri3d=false;
2506  for (int i=0;i<nb_tri;i++)
2507  {
2508  if (mgnoeud->get_lien_triangle()->get(i)->get_nouveau_numero()==1)
2509  {
2510  if (mgnoeud->get_lien_triangle()->get(i)->get_lien_topologie()->get_dimension()==2) tri2d=true;
2511  if (mgnoeud->get_lien_triangle()->get(i)->get_lien_topologie()->get_dimension()==3) tri3d=true;
2512  }
2513  }
2514  if ((tri2d)&&(tri3d)) origine=MAGIC::ORIGINE::TRIANGULATION_ARETE;
2515  if (mgnoeud->get_lien_topologie()->get_dimension()<2) origine=MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE;
2516  if (mgnoeud->get_origine()==MAGIC::ORIGINE::IMPOSE) origine=MAGIC::ORIGINE::IMPOSE;
2517  MG_ELEMENT_TOPOLOGIQUE* topo=NULL;
2518  std::map<unsigned long,unsigned long>::iterator it=correspondidsom.find(mgnoeud->get_lien_topologie()->get_id());
2519  if (it!=correspondidsom.end())
2520  topo=geo->get_mg_sommetid(it->second);
2521  MG_NOEUD* noeud1 = new MG_NOEUD(topo,x,y,z,origine);
2522  if (it!=correspondidsom.end())
2523  ((MG_SOMMET_NOEUD*)topo)->change_mg_noeud(noeud1);
2524  mai2->ajouter_mg_noeud(noeud1);
2525  mgnoeud->change_nouveau_numero(noeud1->get_id());
2526  noeud1->change_nouveau_numero(mgnoeud->get_id());
2527  }
2528  }
2529 
2530 for (MG_TETRA* mgtet=mg_mai->get_premier_tetra(it_tetra);mgtet!=NULL;mgtet=mg_mai->get_suivant_tetra(it_tetra))
2531  {
2532  int originetet=mgtet->get_origine();
2533  if (((originetet == MAGIC::ORIGINE::OPTIMISE) && (etat[(MAGIC::ORIGINE::OPTIMISE-1000)/10]==1) ) ||
2534  ((originetet == MAGIC::ORIGINE::IMPOSE) && (etat[(MAGIC::ORIGINE::IMPOSE-1000)/10]==1) ) ||
2535  ((originetet == MAGIC::ORIGINE::MAILLEUR_AUTO) && (etat[(MAGIC::ORIGINE::MAILLEUR_AUTO-1000)/10]==1) ) ||
2536  ((originetet == MAGIC::ORIGINE::TRIANGULATION) && (etat[(MAGIC::ORIGINE::TRIANGULATION-1000)/10]==1) ) ||
2537  ((originetet == MAGIC::ORIGINE::MODIFICATION) && (etat[(MAGIC::ORIGINE::MODIFICATION-1000)/10]==1) ) ||
2538  ((originetet == MAGIC::ORIGINE::DUPLIQUER) && (etat[(MAGIC::ORIGINE::DUPLIQUER-1000)/10]==1) ) )
2539  {
2540  MG_NOEUD* noeud1 = mgtet->get_noeud1();
2541  MG_NOEUD* noeud2 = mgtet->get_noeud2();
2542  MG_NOEUD* noeud3 = mgtet->get_noeud3();
2543  MG_NOEUD* noeud4 = mgtet->get_noeud4();
2544  MG_NOEUD* node1 = mai2->get_mg_noeudid(noeud1->get_nouveau_numero());
2545  MG_NOEUD* node2 = mai2->get_mg_noeudid(noeud2->get_nouveau_numero());
2546  MG_NOEUD* node3 = mai2->get_mg_noeudid(noeud3->get_nouveau_numero());
2547  MG_NOEUD* node4 = mai2->get_mg_noeudid(noeud4->get_nouveau_numero());
2548  MG_TRIANGLE* tri1=mgtet->get_triangle1();
2549  MG_TRIANGLE* tri2=mgtet->get_triangle2();
2550  MG_TRIANGLE* tri3=mgtet->get_triangle3();
2551  MG_TRIANGLE* tri4=mgtet->get_triangle4();
2552  if (tri1->get_nouveau_numero()==1)
2553  {
2554  int origine=MAGIC::ORIGINE::TRIANGULATION;
2555  if (tri1->get_origine()==MAGIC::ORIGINE::IMPOSE) origine=MAGIC::ORIGINE::IMPOSE;
2556  MG_FACE* topo=facenoex;
2557  if (tri1->get_lien_topologie()->get_dimension()==2) topo=faceex;
2558  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(tri1->get_lien_topologie()->get_id());
2559  if (it!=correspondid.end())
2560  topo=geo->get_mg_faceid(it->second);
2561  MG_TRIANGLE_PEAU* tripeau = insere_triangle(geo,mg_mai,noeud1,noeud2,noeud3,correspondid,topo,node1,node2,node3,mai2,origine);
2562  tripeau->change_nouveau_numero(0);
2563  tri1->change_nouveau_numero(0);
2564  }
2565  if (tri2->get_nouveau_numero()==1)
2566  {
2567  int origine=MAGIC::ORIGINE::TRIANGULATION;
2568  if (tri2->get_origine()==MAGIC::ORIGINE::IMPOSE) origine=MAGIC::ORIGINE::IMPOSE;
2569  MG_FACE* topo=facenoex;
2570  if (tri2->get_lien_topologie()->get_dimension()==2) topo=faceex;
2571  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(tri2->get_lien_topologie()->get_id());
2572  if (it!=correspondid.end())
2573  topo=geo->get_mg_faceid(it->second);
2574  MG_TRIANGLE_PEAU* tripeau = insere_triangle(geo,mg_mai,noeud1,noeud4,noeud2,correspondid,topo,node1,node4,node2,mai2,origine);
2575  tripeau->change_nouveau_numero(0);
2576  tri2->change_nouveau_numero(0);
2577  }
2578  if (tri3->get_nouveau_numero()==1)
2579  {
2580  int origine=MAGIC::ORIGINE::TRIANGULATION;
2581  MG_FACE* topo=facenoex;
2582  if (tri3->get_lien_topologie()->get_dimension()==2) topo=faceex;
2583  if (tri3->get_origine()==MAGIC::ORIGINE::IMPOSE) origine=MAGIC::ORIGINE::IMPOSE;
2584  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(tri3->get_lien_topologie()->get_id());
2585  if (it!=correspondid.end())
2586  topo=geo->get_mg_faceid(it->second);
2587  MG_TRIANGLE_PEAU* tripeau = insere_triangle(geo,mg_mai,noeud2,noeud4,noeud3,correspondid,topo,node2,node4,node3,mai2,origine);
2588  tripeau->change_nouveau_numero(0);
2589  tri3->change_nouveau_numero(0);
2590  }
2591  if (tri4->get_nouveau_numero()==1)
2592  {
2593  int origine=MAGIC::ORIGINE::TRIANGULATION;
2594  MG_FACE* topo=facenoex;
2595  if (tri4->get_lien_topologie()->get_dimension()==2) topo=faceex;
2596  if (tri4->get_origine()==MAGIC::ORIGINE::IMPOSE) origine=MAGIC::ORIGINE::IMPOSE;
2597  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(tri4->get_lien_topologie()->get_id());
2598  if (it!=correspondid.end())
2599  topo=geo->get_mg_faceid(it->second);
2600  MG_TRIANGLE_PEAU* tripeau = insere_triangle(geo,mg_mai,noeud1,noeud3,noeud4,correspondid,topo,node1,node3,node4,mai2,origine);
2601  tripeau->change_nouveau_numero(0);
2602  tri4->change_nouveau_numero(0);
2603  }
2604  }
2605 }
2606 for (MG_TRIANGLE* mgtri=mai2->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mai2->get_suivant_triangle(it_tri))
2607  {
2608  MG_TRIANGLE_PEAU* tripeau=(MG_TRIANGLE_PEAU*)mgtri;
2609  MG_TRIANGLE_PEAU* voisin1=recherche_voisin(tripeau->get_noeud1(),tripeau->get_noeud2(),tripeau);
2610  MG_TRIANGLE_PEAU* voisin2=recherche_voisin(tripeau->get_noeud2(),tripeau->get_noeud3(),tripeau);
2611  MG_TRIANGLE_PEAU* voisin3=recherche_voisin(tripeau->get_noeud3(),tripeau->get_noeud1(),tripeau);
2612  tripeau->change_voisin1(voisin1);
2613  tripeau->change_voisin2(voisin2);
2614  tripeau->change_voisin3(voisin3);
2615  }
2616 int fin;
2617 do
2618  {
2619  fin=1;
2620  for (MG_TRIANGLE* mgtri=mai2->get_premier_triangle(it_tri);mgtri!=NULL;mgtri=mai2->get_suivant_triangle(it_tri))
2621  {
2622  MG_TRIANGLE_PEAU *tripeau=(MG_TRIANGLE_PEAU*)mgtri;
2623  if (tripeau->get_nouveau_numero()==0)
2624  {
2625  fin=0;
2626  std::vector<MG_TRIANGLE_PEAU*> *peau=new std::vector<MG_TRIANGLE_PEAU*>;
2627  lst_peau.push_back(peau);
2628  tripeau->change_nouveau_numero(1);
2629  peau->push_back(tripeau);
2630  determine_peau(peau);
2631  }
2632  }
2633  }
2634 while (fin==0);
2635 nbpeau=lst_peau.size();
2636 LISTE_MG_SEGMENT::iterator itseg;
2637 for (MG_SEGMENT* seg=mai2->get_premier_segment(itseg);seg!=NULL;seg=mai2->get_suivant_segment(itseg))
2638  seg->change_nouveau_numero(0);
2639 TPL_MAP_ENTITE<MG_SEGMENT*> nonmanifoldarete;
2640 TPL_MAP_ENTITE<MG_NOEUD*> nonmanifoldnoeud;
2641 TPL_MAP_ENTITE<MG_NOEUD*> nonmanifoldnoeuddepuisarete;
2642 nbpeau=lst_peau.size();
2643 for (int i=0;i<nbpeau;i++)
2644  {
2645  int nbtri=lst_peau[i]->size();
2646  for (int j=0;j<nbtri;j++)
2647  {
2648  MG_TRIANGLE_PEAU* tripeau=(*lst_peau[i])[j];
2649  tripeau->get_segment1()->change_nouveau_numero(tripeau->get_segment1()->get_nouveau_numero()+1);
2650  tripeau->get_segment2()->change_nouveau_numero(tripeau->get_segment2()->get_nouveau_numero()+1);
2651  tripeau->get_segment3()->change_nouveau_numero(tripeau->get_segment3()->get_nouveau_numero()+1);
2652  if (tripeau->get_segment1()->get_nouveau_numero()>2)
2653  nonmanifoldarete.ajouter(tripeau->get_segment1());
2654  if (tripeau->get_segment2()->get_nouveau_numero()>2)
2655  nonmanifoldarete.ajouter(tripeau->get_segment2());
2656  if (tripeau->get_segment3()->get_nouveau_numero()>2)
2657  nonmanifoldarete.ajouter(tripeau->get_segment3());
2658  }
2659  }
2660 
2661 int nbnonmanifoldarete=nonmanifoldarete.get_nb();
2662 for (int i=0;i<nbnonmanifoldarete;i++)
2663  {
2664  MG_SEGMENT* seg=nonmanifoldarete.get(i);
2665  MG_NOEUD* n1=seg->get_noeud1();
2666  MG_NOEUD* n2=seg->get_noeud2();
2667  nonmanifoldnoeuddepuisarete.ajouter(n1);
2668  nonmanifoldnoeuddepuisarete.ajouter(n2);
2669  }
2670 LISTE_MG_NOEUD::iterator itnoeud;
2671 for (MG_NOEUD* no=mai2->get_premier_noeud(itnoeud);no!=NULL;no=mai2->get_suivant_noeud(itnoeud))
2672  {
2673  if (nonmanifoldnoeuddepuisarete.existe(no)) continue;
2674  if (est_non_manifold(no)) nonmanifoldnoeud.ajouter(no);
2675  }
2676 
2677 nbmaniare = nonmanifoldarete.get_nb();
2678 nbmanino = nonmanifoldnoeud.get_nb();
2679 
2680 for (int i=0;i<nbnonmanifoldarete;i++)
2681  {
2682  MG_SEGMENT* segment=nonmanifoldarete.get(i);
2683  MG_NOEUD* noeud1 = mg_mai->get_mg_noeudid(segment->get_noeud1()->get_nouveau_numero());
2684  MG_NOEUD* noeud2 = mg_mai->get_mg_noeudid(segment->get_noeud2()->get_nouveau_numero());
2685  int nb_tetra = noeud1->get_lien_tetra()->get_nb();
2686  for (int j=0;j<nb_tetra;j++)
2687  {
2688  MG_TETRA* mgtet =noeud1->get_lien_tetra()->get(j);
2689  int originetet=mgtet->get_origine();
2690  if (originetet == MAGIC::ORIGINE::MAILLEUR_AUTO)
2691  {
2692  //On reactive le tetra si l'autre noeud du segment lui appartient aussi
2693  MG_NOEUD* no1 = mgtet->get_noeud1();
2694  MG_NOEUD* no2 = mgtet->get_noeud2();
2695  MG_NOEUD* no3 = mgtet->get_noeud3();
2696  MG_NOEUD* no4 = mgtet->get_noeud4();
2697  if((no1 == noeud2) ||(no2 == noeud2) || (no3 == noeud2) || (no4 == noeud2))
2698  mgtet->change_origine(MAGIC::ORIGINE::OPTIMISE);
2699  }
2700  }
2701  }
2702 
2703 int nbnonmanifoldnoeud=nonmanifoldnoeud.get_nb();
2704 for (int i=0;i<nbnonmanifoldnoeud;i++)
2705  {
2706  MG_NOEUD* noeud=mg_mai->get_mg_noeudid(nonmanifoldnoeud.get(i)->get_nouveau_numero());
2707  int nb_tetra = noeud->get_lien_tetra()->get_nb();
2708  for (int j = 0;j<nb_tetra;j++)
2709  {
2710  MG_TETRA* mgtet =noeud->get_lien_tetra()->get(j);
2711  int originetet=mgtet->get_origine();
2712  if (originetet == MAGIC::ORIGINE::MAILLEUR_AUTO)
2713  {
2714  mgtet->change_origine(MAGIC::ORIGINE::OPTIMISE);
2715  }
2716  }
2717  }
2718 *mai2_id = mai2->get_id();
2719 if ((nbnonmanifoldarete != 0) || (nbnonmanifoldnoeud != 0))
2720  {
2721  for (int i=0;i<lst_peau.size();i++)
2722  {
2723  delete lst_peau[i];
2724  }
2725  lst_peau.clear();
2726  gest2.supprimer_mg_maillageid(*mai2_id);
2727  return 0;
2728  }
2729 
2730 return 1;
2731 }
2732 
2733 
2734 int MGOPT_POSTTRAITEMENT::cardinalite(MG_MAILLAGE* mgmai, int cardinalite_iter)
2735 {
2736 for (int i=0;i<cardinalite_iter;i++)
2737  {
2738  TPL_MAP_ENTITE<MG_NOEUD*> lst;
2739  LISTE_MG_NOEUD::iterator it;
2740  for (MG_NOEUD* no=mgmai->get_premier_noeud(it);no!=NULL;no=mgmai->get_suivant_noeud(it))
2741  if (no->get_lien_triangle()->get_nb()==3)
2742  {
2743  if (no->get_lien_triangle()->get(0)->get_origine()!=MAGIC::ORIGINE::IMPOSE)
2744  if (no->get_lien_triangle()->get(1)->get_origine()!=MAGIC::ORIGINE::IMPOSE)
2745  if (no->get_lien_triangle()->get(2)->get_origine()!=MAGIC::ORIGINE::IMPOSE)
2746  lst.ajouter(no);
2747  }
2748  int nbcas=lst.get_nb();
2749  char message[255];
2750  sprintf(message," Itération %d, nombre de noeuds de cardinalite 3 : %d",i+1,nbcas);
2751  affiche(message);
2752  if (nbcas==0) return i;
2753  for (int j=0;j<nbcas;j++)
2754  {
2755  MG_NOEUD* no=lst.get(j);
2756  TPL_MAP_ENTITE<MG_NOEUD*> lstno;
2757  lstno.ajouter(no->get_lien_triangle()->get(0)->get_noeud1());
2758  lstno.ajouter(no->get_lien_triangle()->get(0)->get_noeud2());
2759  lstno.ajouter(no->get_lien_triangle()->get(0)->get_noeud3());
2760  lstno.ajouter(no->get_lien_triangle()->get(1)->get_noeud1());
2761  lstno.ajouter(no->get_lien_triangle()->get(1)->get_noeud2());
2762  lstno.ajouter(no->get_lien_triangle()->get(1)->get_noeud3());
2763  lstno.ajouter(no->get_lien_triangle()->get(2)->get_noeud1());
2764  lstno.ajouter(no->get_lien_triangle()->get(2)->get_noeud2());
2765  lstno.ajouter(no->get_lien_triangle()->get(2)->get_noeud3());
2766  lstno.supprimer(no);
2767  MG_ELEMENT_TOPOLOGIQUE* topo=no->get_lien_triangle()->get(0)->get_lien_topologie();
2768  int origine=no->get_lien_triangle()->get(0)->get_origine();
2769  OT_VECTEUR_3D normal;
2770  for (int k=0;k<3;k++)
2771  {
2772  MG_TRIANGLE* tri=no->get_lien_triangle()->get(k);
2773  MG_NOEUD *no1=tri->get_noeud1();
2774  MG_NOEUD *no2=tri->get_noeud2();
2775  MG_NOEUD *no3=tri->get_noeud3();
2776  OT_VECTEUR_3D vec1(no1->get_coord(),no2->get_coord());
2777  OT_VECTEUR_3D vec2(no1->get_coord(),no3->get_coord());
2778  OT_VECTEUR_3D vec3=vec1&vec2;
2779  vec3.norme();
2780  normal=normal+vec3;
2781  }
2782  normal.norme();
2783  mgmai->supprimer_mg_triangleid(no->get_lien_triangle()->get(2)->get_id());
2784  mgmai->supprimer_mg_triangleid(no->get_lien_triangle()->get(1)->get_id());
2785  mgmai->supprimer_mg_triangleid(no->get_lien_triangle()->get(0)->get_id());
2786  mgmai->supprimer_mg_noeudid(no->get_id());
2787  MG_NOEUD *no1=lstno.get(0);
2788  MG_NOEUD *no2=lstno.get(1);
2789  MG_NOEUD *no3=lstno.get(2);
2790  OT_VECTEUR_3D vec1(no1->get_coord(),no2->get_coord());
2791  OT_VECTEUR_3D vec2(no1->get_coord(),no3->get_coord());
2792  OT_VECTEUR_3D vec3=vec1&vec2;
2793  vec3.norme();
2794  if (vec3*normal>0) insere_triangle(topo,no1,no2,no3,mgmai,origine);
2795  else insere_triangle(topo,no2,no1,no3,mgmai,origine);
2796  }
2797 
2798  }
2799 
2800 return cardinalite_iter;
2801 
2802 }
2803 
2804 
2805 
2806 void MGOPT_POSTTRAITEMENT::rmimpose(MG_MAILLAGE* mgmai, char* nom)
2807 {
2808  MG_GESTIONNAIRE gest2;
2809  MG_MAILLAGE* mgmai3=new MG_MAILLAGE(NULL);
2810  gest2.ajouter_mg_maillage(mgmai3);
2811  TPL_MAP_ENTITE<MG_TRIANGLE*> lsttri;
2812  TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR it_lsttri;
2813  TPL_MAP_ENTITE<MG_NOEUD*> lstno;
2814  TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR it_lstno;
2815 
2816  LISTE_MG_TRIANGLE::iterator itt;
2817  LISTE_MG_NOEUD::iterator itn;
2818  for (MG_TRIANGLE *tri=mgmai->get_premier_triangle(itt);tri!=NULL;tri=mgmai->get_suivant_triangle(itt))
2819  {
2820  if (tri->get_origine() != MAGIC::ORIGINE::IMPOSE)
2821  {
2822  lsttri.ajouter(tri);
2823  lstno.ajouter(tri->get_noeud1());
2824  lstno.ajouter(tri->get_noeud2());
2825  lstno.ajouter(tri->get_noeud3());
2826  }
2827  }
2828  // Creation des noeuds du non_design dans le nouveau maillage mg_mai4
2829  for(MG_NOEUD* mgnoeud=lstno.get_premier(it_lstno);mgnoeud;mgnoeud=lstno.get_suivant(it_lstno))
2830  {
2831  double x = mgnoeud->get_x();
2832  double y = mgnoeud->get_y();
2833  double z = mgnoeud->get_z();
2834  MG_NOEUD* node = new MG_NOEUD(NULL,x,y,z,MAGIC::ORIGINE::TRIANGULATION);
2835  node->change_nouveau_numero(mgnoeud->get_id());
2836  mgmai3->ajouter_mg_noeud(node);
2837  }
2838  for(MG_TRIANGLE* mgtri=lsttri.get_premier(it_lsttri);mgtri;mgtri=lsttri.get_suivant(it_lsttri))
2839  {
2840  MG_NOEUD* noeud1 = mgtri->get_noeud1();
2841  MG_NOEUD* noeud2 = mgtri->get_noeud2();
2842  MG_NOEUD* noeud3 = mgtri->get_noeud3();
2843  MG_NOEUD* no1 = NULL;
2844  MG_NOEUD* no2 = NULL;
2845  MG_NOEUD* no3 = NULL;
2846  for (MG_NOEUD* mgnoeud=mgmai3->get_premier_noeud(itn);mgnoeud!=NULL;mgnoeud=mgmai3->get_suivant_noeud(itn))
2847  {
2848  if (mgnoeud->get_nouveau_numero() == noeud1->get_id()) no1 = mgnoeud;
2849  if (mgnoeud->get_nouveau_numero() == noeud2->get_id()) no2 = mgnoeud;
2850  if (mgnoeud->get_nouveau_numero() == noeud3->get_id()) no3 = mgnoeud;
2851  }
2852  MG_TRIANGLE* tri = mgmai3->ajouter_mg_triangle(NULL,no1,no2,no3,mgtri->get_origine());
2853  }
2854 
2855 gest2.enregistrer(nom);
2856 }
2857 
2858 void MGOPT_POSTTRAITEMENT::determine_peau(std::vector<MG_TRIANGLE_PEAU*> * peau)
2859 {
2860 int num=0;
2861 while (num!=peau->size())
2862  {
2863  MG_TRIANGLE_PEAU* p=(*peau)[num];
2864  if (p->get_voisin1()->get_nouveau_numero()==0)
2865  {
2866  peau->push_back(p->get_voisin1());
2867  p->get_voisin1()->change_nouveau_numero(1);
2868  }
2869  if (p->get_voisin2()->get_nouveau_numero()==0)
2870  {
2871  peau->push_back(p->get_voisin2());
2872  p->get_voisin2()->change_nouveau_numero(1);
2873  }
2874  if (p->get_voisin3()->get_nouveau_numero()==0)
2875  {
2876  peau->push_back(p->get_voisin3());
2877  p->get_voisin3()->change_nouveau_numero(1);
2878  }
2879  num++;
2880  }
2881 }
2882 
2883 MG_TRIANGLE_PEAU* MGOPT_POSTTRAITEMENT::insere_triangle(MG_GEOMETRIE* geo,MG_MAILLAGE* maiori,MG_NOEUD* n1ori,MG_NOEUD* n2ori,MG_NOEUD* n3ori,std::map<unsigned long,unsigned long> &correspondid,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,MG_MAILLAGE* mg_maillage,int origine)
2884 {
2885 MG_SEGMENT* mgsegment1=mg_maillage->get_mg_segment(mgnoeud1->get_id(),mgnoeud2->get_id());
2886 MG_SEGMENT* mgsegment2=mg_maillage->get_mg_segment(mgnoeud2->get_id(),mgnoeud3->get_id());
2887 MG_SEGMENT* mgsegment3=mg_maillage->get_mg_segment(mgnoeud3->get_id(),mgnoeud1->get_id());
2888 if (mgsegment1==NULL)
2889  {
2890  MG_SEGMENT* seg=maiori->get_mg_segment(n1ori->get_id(),n2ori->get_id());
2891  MG_ELEMENT_TOPOLOGIQUE* toposeg=seg->get_lien_topologie();
2892  MG_ELEMENT_TOPOLOGIQUE* toposegn=topo;
2893  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(toposeg->get_id());
2894  if (it!=correspondid.end())
2895  toposegn=geo->get_mg_areteid(it->second);
2896  mgsegment1=mg_maillage->ajouter_mg_segment(toposegn,mgnoeud1,mgnoeud2,origine);
2897  }
2898 if (mgsegment2==NULL)
2899  {
2900  MG_SEGMENT* seg=maiori->get_mg_segment(n2ori->get_id(),n3ori->get_id());
2901  MG_ELEMENT_TOPOLOGIQUE* toposeg=seg->get_lien_topologie();
2902  MG_ELEMENT_TOPOLOGIQUE* toposegn=topo;
2903  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(toposeg->get_id());
2904  if (it!=correspondid.end())
2905  toposegn=geo->get_mg_areteid(it->second);
2906  mgsegment2=mg_maillage->ajouter_mg_segment(toposegn,mgnoeud2,mgnoeud3,origine);
2907  }
2908 if (mgsegment3==NULL)
2909  {
2910  MG_SEGMENT* seg=maiori->get_mg_segment(n3ori->get_id(),n1ori->get_id());
2911  MG_ELEMENT_TOPOLOGIQUE* toposeg=seg->get_lien_topologie();
2912  MG_ELEMENT_TOPOLOGIQUE* toposegn=topo;
2913  std::map<unsigned long,unsigned long>::iterator it=correspondid.find(toposeg->get_id());
2914  if (it!=correspondid.end())
2915  toposegn=geo->get_mg_areteid(it->second);
2916  mgsegment3=mg_maillage->ajouter_mg_segment(toposegn,mgnoeud3,mgnoeud1,origine);
2917  }
2918 MG_TRIANGLE_PEAU* mtriangle=new MG_TRIANGLE_PEAU(topo,mgnoeud1,mgnoeud2,mgnoeud3,mgsegment1,mgsegment2,mgsegment3,origine);
2919 mg_maillage->ajouter_mg_triangle(mtriangle);
2920 return mtriangle;
2921 }
2922 
2923 MG_TRIANGLE_PEAU* MGOPT_POSTTRAITEMENT::insere_triangle(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,MG_MAILLAGE* mg_maillage,int origine)
2924 {
2925 MG_SEGMENT* mgsegment1=mg_maillage->get_mg_segment(mgnoeud1->get_id(),mgnoeud2->get_id());
2926 MG_SEGMENT* mgsegment2=mg_maillage->get_mg_segment(mgnoeud2->get_id(),mgnoeud3->get_id());
2927 MG_SEGMENT* mgsegment3=mg_maillage->get_mg_segment(mgnoeud3->get_id(),mgnoeud1->get_id());
2928 if (mgsegment1==NULL)
2929  mgsegment1=mg_maillage->ajouter_mg_segment(topo,mgnoeud1,mgnoeud2,origine);
2930 if (mgsegment2==NULL)
2931  mgsegment2=mg_maillage->ajouter_mg_segment(topo,mgnoeud2,mgnoeud3,origine);
2932 if (mgsegment3==NULL)
2933  mgsegment3=mg_maillage->ajouter_mg_segment(topo,mgnoeud3,mgnoeud1,origine);
2934 MG_TRIANGLE_PEAU* mtriangle=new MG_TRIANGLE_PEAU(topo,mgnoeud1,mgnoeud2,mgnoeud3,mgsegment1,mgsegment2,mgsegment3,origine);
2935 mg_maillage->ajouter_mg_triangle(mtriangle);
2936 return mtriangle;
2937 }
2938 MG_TRIANGLE_PEAU* MGOPT_POSTTRAITEMENT::recherche_voisin(MG_NOEUD* mg_noeud1,MG_NOEUD* mg_noeud2,MG_TRIANGLE_PEAU* triref)
2939 {
2940 MG_TRIANGLE_PEAU* trisol=NULL;
2941 double angleref=4.*M_PI;
2942 int nb1=mg_noeud1->get_lien_triangle()->get_nb();
2943 int nb2=mg_noeud2->get_lien_triangle()->get_nb();
2944 for (int i=0;i<nb1;i++)
2945 for (int j=0;j<nb2;j++)
2946 if (mg_noeud1->get_lien_triangle()->get(i)==mg_noeud2->get_lien_triangle()->get(j))
2947  if ((MG_TRIANGLE_PEAU*)mg_noeud1->get_lien_triangle()->get(i)!=triref)
2948  {
2949  double angle=calcul_angle(triref,(MG_TRIANGLE_PEAU*)mg_noeud1->get_lien_triangle()->get(i));
2950  if (angle<angleref)
2951  {
2952  angleref=angle;
2953  trisol=(MG_TRIANGLE_PEAU*)mg_noeud1->get_lien_triangle()->get(i);
2954  }
2955  }
2956 return trisol;
2957 }
2958 
2959 int MGOPT_POSTTRAITEMENT::est_non_manifold(MG_NOEUD* no)
2960 {
2961 static int compteur=0;
2962 compteur++;
2963 int nb_tri=no->get_lien_triangle()->get_nb();
2964 TPL_MAP_ENTITE<MG_TRIANGLE*> lst;
2965 for (int i=0;i<nb_tri;i++)
2966  lst.ajouter(no->get_lien_triangle()->get(i));
2967 MG_TRIANGLE_PEAU* premier_triangle=(MG_TRIANGLE_PEAU*)lst.get(0);
2968 lst.supprimer(premier_triangle);
2969 MG_TRIANGLE_PEAU* tricour=(MG_TRIANGLE_PEAU*)premier_triangle;
2970 int i=0;
2971 do
2972  {
2973  if (lst.existe(tricour->get_voisin1()) || ((tricour->get_voisin1()==premier_triangle)&& (i>1)))
2974  {
2975  tricour=tricour->get_voisin1();
2976  lst.supprimer(tricour);
2977  }
2978  else if (lst.existe(tricour->get_voisin2()) || ((tricour->get_voisin2()==premier_triangle)&& (i>1)))
2979  {
2980  tricour=tricour->get_voisin2();
2981  lst.supprimer(tricour);
2982  }
2983  else if (lst.existe(tricour->get_voisin3()) || ((tricour->get_voisin3()==premier_triangle)&& (i>1)))
2984  {
2985  tricour=tricour->get_voisin3();
2986  lst.supprimer(tricour);
2987  }
2988  i++;
2989  }
2990 while (tricour!=premier_triangle);
2991 if (lst.get_nb()>0)
2992  return 1;
2993 return 0;
2994 }
2995 
2996 double MGOPT_POSTTRAITEMENT::calcul_angle(MG_TRIANGLE_PEAU* ft1,MG_TRIANGLE_PEAU* ft2)
2997 {
2998  MG_NOEUD* noeud1=ft1->get_noeud1();
2999  MG_NOEUD* noeud2=ft1->get_noeud2();
3000  MG_NOEUD* noeud3=ft1->get_noeud3();
3001  MG_NOEUD* noeud4=ft2->get_noeud1();
3002  MG_NOEUD* noeud5=ft2->get_noeud2();
3003  MG_NOEUD* noeud6=ft2->get_noeud3();
3004  double angle=get_angle_par_noeud<MG_NOEUD*>(noeud1,noeud2,noeud3,noeud4,noeud5,noeud6);
3005  return angle;
3006 }
3007 
3008 double MGOPT_POSTTRAITEMENT::ponderation_gaussian(double s,double sigma)
3009 {
3010  double w_s;
3011  w_s = exp(-(s*s)/(2.*sigma*sigma));
3012  return w_s;
3013 }
3014 
3015 double MGOPT_POSTTRAITEMENT::ponderation_laplacian(double s,double sigma)
3016 {
3017  double w_s;
3018  w_s = exp(-(sqrt(2.)*fabs(s))/sigma);
3019  return w_s;
3020 }
3021 
3022 double MGOPT_POSTTRAITEMENT::ponderation_elfallahford(double s,double sigma)
3023 {
3024  double w_s;
3025  w_s = 1./sqrt(1+pow((s/sigma),2));
3026  return w_s;
3027 }
3028 
3029 
3030 
3031 int passage_non_manifold(MG_NOEUD** no,std::map<int,MG_NOEUD*>* lst_no_voisins, MG_GEOMETRIE* geo, std::vector<MG_NOEUD*>* arete)
3032 {
3033  MG_SEGMENT* seg=NULL;
3034  MG_NOEUD* no_voisin=NULL;
3035  std::map<int,MG_NOEUD*>::iterator it_map;
3036 
3037  for(int i=0;i<(*no)->get_lien_segment()->get_nb();i++)
3038  {
3039  seg=(*no)->get_lien_segment()->get(i);
3040  if((seg->get_lien_triangle()->get(0)->get_lien_topologie()==geo->get_mg_face(geo->get_nb_mg_face()-2))&&
3041  (seg->get_lien_triangle()->get(1)->get_lien_topologie()==geo->get_mg_face(geo->get_nb_mg_face()-2)))
3042  {
3043  if(seg->get_noeud1()!=*no) (*lst_no_voisins)[i]=seg->get_noeud1();
3044  else (*lst_no_voisins)[i]=seg->get_noeud2();
3045  }
3046  }
3047  no_voisin=(*arete)[arete->size()-2];
3048  int k,j=0;
3049  for(int i=0;i<lst_no_voisins->size();i++)
3050  {
3051  bool find=false;
3052  while((j<no_voisin->get_lien_segment()->get_nb())&&!find)
3053  {
3054  seg=no_voisin->get_lien_segment()->get(j);
3055  bool seg_valide=(seg->get_lien_triangle()->get(0)->get_lien_topologie()==geo->get_mg_face(geo->get_nb_mg_face()-2))||
3056  (seg->get_lien_triangle()->get(1)->get_lien_topologie()==geo->get_mg_face(geo->get_nb_mg_face()-2));
3057  j++;
3058  for(it_map=lst_no_voisins->begin();it_map!=lst_no_voisins->end();it_map++)
3059  if((it_map->second->get_lien_segment()->est_dans_la_liste(seg))&&seg_valide)
3060  {
3061  no_voisin=it_map->second;
3062  k=it_map->first;
3063  lst_no_voisins->erase(it_map);
3064  j=0;
3065  find=true;
3066  break;
3067  }
3068  }
3069  }
3070  arete->push_back(no_voisin);
3071  *no=no_voisin;
3072  return k;
3073 }
3074 
3075 
3076 
3077 void recherche_voisins(MG_NOEUD* no,std::vector<MG_NOEUD*>* lst_no_1090_1091,std::vector<MG_NOEUD*>* arete,std::map<int,MG_NOEUD*>* lst_no_voisins,bool arete_ouverte,std::vector<MG_NOEUD*>* lst_no_extr)
3078 {
3079  MG_SEGMENT* seg=NULL;
3080  MG_NOEUD* no_voisin=NULL;
3081 
3082  for(int j=0;j<no->get_lien_segment()->get_nb();j++)
3083  {
3084  seg=no->get_lien_segment()->get(j);
3085  bool seg_bord=seg->get_lien_triangle()->get(0)->get_lien_topologie()!=seg->get_lien_triangle()->get(1)->get_lien_topologie();
3086  if(seg->get_noeud1()!=no) no_voisin=seg->get_noeud1();
3087  else no_voisin=seg->get_noeud2();
3088  for(int k=0;k<lst_no_1090_1091->size();k++)
3089  if(((*lst_no_1090_1091)[k]==no_voisin)&&seg_bord&&(no_voisin!=(*arete)[arete->size()-2]))
3090  {
3091  (*lst_no_voisins)[k]=no_voisin;
3092  break;
3093  }
3094  if(arete_ouverte&&(no_voisin->get_origine()==MAGIC::ORIGINE::IMPOSE)&&(arete->size()>2)&&seg_bord)
3095  for(int k=0;k<lst_no_extr->size();k++)
3096  if(((*lst_no_extr)[k]==no_voisin))
3097  {
3098  arete->push_back(no_voisin);
3099  lst_no_extr->erase(lst_no_extr->begin()+k);
3100  break;
3101  }
3102  }
3103 }
TPL_MAP_ENTITE::supprimer
virtual void supprimer(X x)
Definition: tpl_map_entite.h:69
MGOPT_POSTTRAITEMENT::posttraite
void posttraite(class FEM_SOLUTION *sol, class MG_GESTIONNAIRE &gest2, char *params, char *nomout)
Definition: mgopt_posttraitement.cpp:890
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
TPL_MAP_ENTITE::get_premier
virtual X get_premier(ITERATEUR &it)
Definition: tpl_map_entite.h:112
MG_ELEMENT_MAILLAGE::change_solution
virtual void change_solution(double val, int num=0)
Definition: mg_element_maillage.cpp:107
MG_TRIANGLE::get_segment1
virtual MG_SEGMENT * get_segment1(void)
Definition: mg_triangle.cpp:142
FEM_SOLUTION
Definition: fem_solution.h:40
MG_SEGMENT
Definition: mg_segment.h:38
MG_TRIANGLE_PEAU::inverse_sens
void inverse_sens(void)
Definition: mg_triangle_peau.cpp:89
MG_TRIANGLE_PEAU::calcul_normal
OT_VECTEUR_3D calcul_normal(void)
Definition: mg_triangle_peau.cpp:99
FEM_MAILLAGE::get_suivant_element3
FEM_ELEMENT3 * get_suivant_element3(LISTE_FEM_ELEMENT3::iterator &it)
Definition: fem_maillage.cpp:680
tpl_fonctions_generiques.h
MGOPT_POSTTRAITEMENT::copieorigine
void copieorigine(class FEM_MAILLAGE *mai)
Definition: mgopt_posttraitement.cpp:133
MG_TETRA::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_tetra.cpp:148
MG_MAILLAGE::get_premier_noeud
MG_NOEUD * get_premier_noeud(LISTE_MG_NOEUD::iterator &it)
Definition: mg_maillage.cpp:548
fct_taille.h
gestionversion.h
MG_TRIANGLE_PEAU::get_voisin1
MG_TRIANGLE_PEAU * get_voisin1(void)
Definition: mg_triangle_peau.cpp:59
MGOPT_POSTTRAITEMENT::~MGOPT_POSTTRAITEMENT
~MGOPT_POSTTRAITEMENT()
Definition: mgopt_posttraitement.cpp:98
MG_TRIANGLE_PEAU::change_voisin2
void change_voisin2(MG_TRIANGLE_PEAU *tri)
Definition: mg_triangle_peau.cpp:79
MG_MAILLAGE::ajouter_mg_segment
MG_SEGMENT * ajouter_mg_segment(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, int origine, double longue=0.0, unsigned long num=0)
Definition: mg_maillage.cpp:565
MGOPT_POSTTRAITEMENT::active_affichage
void active_affichage(void(*fonc)(char *))
Definition: mgopt_posttraitement.cpp:104
MG_GEOMETRIE::change_valeur_unite
void change_valeur_unite(double val)
Definition: mg_geometrie.cpp:2657
TPL_MAP_ENTITE
Definition: tpl_map_entite.h:35
OT_PARAMETRES::get_valeur
double get_valeur(std::string chaine, int num=0)
Definition: ot_parametres.cpp:191
fem_solution.h
mg_gestionnaire.h
MG_GEOMETRIE::get_mg_areteid
MG_ARETE * get_mg_areteid(unsigned long num)
Definition: mg_geometrie.cpp:775
MG_SEGMENT::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_segment.cpp:113
MGOPT_POSTTRAITEMENT::determine_peau
void determine_peau(std::vector< MG_TRIANGLE_PEAU * > *peau)
Definition: mgopt_posttraitement.cpp:2858
MG_NOEUD::get_z
virtual double get_z(void)
Definition: mg_noeud.cpp:87
MG_NOEUD::get_lien_triangle
TPL_LISTE_ENTITE< class MG_TRIANGLE * > * get_lien_triangle(void)
Definition: mg_noeud.cpp:153
MG_IDENTIFICATEUR::get_id
unsigned long get_id()
Definition: mg_identificateur.cpp:53
MG_TETRA::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_tetra.cpp:143
MG_MAILLAGE::get_nb_mg_triangle
unsigned int get_nb_mg_triangle(void)
Definition: mg_maillage.cpp:814
MGOPT_POSTTRAITEMENT::MGOPT_POSTTRAITEMENT
MGOPT_POSTTRAITEMENT()
Definition: mgopt_posttraitement.cpp:53
MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3_NOEUD
@ ENTITE_ELEMENT3_NOEUD
Definition: mg_definition.h:86
MGOPT_POSTTRAITEMENT::cycle_taubin1995
int cycle_taubin1995(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double lambda, double nu)
Definition: mgopt_posttraitement.cpp:1695
MGOPT_POSTTRAITEMENT::lissage_chen2005
int lissage_chen2005(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double epsilon, double sigma, int iter_max)
Definition: mgopt_posttraitement.cpp:1292
FEM_SOLUTION::ecrire
void ecrire(double val, int i, int j, int coord=0, int num_no=0)
Definition: fem_solution.cpp:411
fem_maillage.h
MG_GEOMETRIE::MG_GEOMETRIE
MG_GEOMETRIE(char *type, const char *nom=NULL, double unite=1.0, double eps=1e-6)
Definition: mg_geometrie.cpp:39
robustPredicates::epsilon
static REAL epsilon
Definition: robustpredicates.cc:371
MG_MAILLAGE::get_premier_tetra
MG_TETRA * get_premier_tetra(LISTE_MG_TETRA::iterator &it)
Definition: mg_maillage.cpp:1374
MGOPT_POSTTRAITEMENT::test_du_point_milieu
int test_du_point_milieu(class MG_NOEUD *no1, MG_NOEUD *no2, class FEM_ELEMENT3 *tet)
Definition: mgopt_posttraitement.cpp:779
MGOPT_POSTTRAITEMENT::lissage_chen2008
int lissage_chen2008(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double sigma, double gamma, double epsilon, int iter_max)
Definition: mgopt_posttraitement.cpp:1518
MG_GEOMETRIE::ajouter_mg_volume
virtual int ajouter_mg_volume(MG_VOLUME *mgvol)
Definition: mg_geometrie.cpp:1642
OT_PARAMETRES::STRING
@ STRING
Definition: ot_parametres.h:38
m3d_triangle.h
MGOPT_POSTTRAITEMENT::lissage_Taubin1995
int lissage_Taubin1995(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double lambda, double nu, int iter_max)
Definition: mgopt_posttraitement.cpp:1815
MG_GEOMETRIE::get_premier_face
MG_FACE * get_premier_face(LISTE_MG_FACE::iterator &it)
Definition: mg_geometrie.cpp:1338
MG_TRIANGLE::get_segment2
virtual MG_SEGMENT * get_segment2(void)
Definition: mg_triangle.cpp:147
MGOPT_POSTTRAITEMENT::suppression_peaux_isoles
void suppression_peaux_isoles(class MG_MAILLAGE *mgmai)
Definition: mgopt_posttraitement.cpp:691
OT_PARAMETRES::ajouter
void ajouter(std::string chaine, double valeur, int typep, std::string aide="")
Definition: ot_parametres.cpp:61
mg_arete_element.h
MG_TRIANGLE_PEAU::change_voisin1
void change_voisin1(MG_TRIANGLE_PEAU *tri)
Definition: mg_triangle_peau.cpp:74
MG_TRIANGLE_PEAU
Definition: mg_triangle_peau.h:32
FEM_ELEMENT3
Definition: fem_element3.h:34
FEM_MAILLAGE::get_premier_noeud
FEM_NOEUD * get_premier_noeud(LISTE_FEM_NOEUD::iterator &it)
Definition: fem_maillage.cpp:174
FEM_MAILLAGE::get_mg_geometrie
MG_GEOMETRIE * get_mg_geometrie(void)
Definition: fem_maillage.cpp:88
MG_ELEMENT_TOPOLOGIQUE::get_dimension
virtual int get_dimension(void)=0
TPL_MAP_ENTITE::existe
virtual int existe(X x)
Definition: tpl_map_entite.h:61
mailleur_analyse.h
MGOPT_POSTTRAITEMENT::calcul_angle
double calcul_angle(MG_TRIANGLE_PEAU *ft1, MG_TRIANGLE_PEAU *ft2)
Definition: mgopt_posttraitement.cpp:2996
MGOPT_POSTTRAITEMENT::etat
int etat[10]
Definition: mgopt_posttraitement.h:80
MAGIC::ORIGINE::MODIFICATION
@ MODIFICATION
Definition: mg_definition.h:79
MG_TRIANGLE
Definition: mg_triangle.h:38
MG_GESTIONNAIRE
Definition: mg_gestionnaire.h:57
OT_VECTEUR_3D::get_x
virtual double get_x(void) const
Definition: ot_mathematique.cpp:417
MG_TRIANGLE::get_segment3
virtual MG_SEGMENT * get_segment3(void)
Definition: mg_triangle.cpp:152
MG_NOEUD::change_z
virtual void change_z(double zz)
Definition: mg_noeud.cpp:128
MG_MAILLAGE::get_premier_segment
MG_SEGMENT * get_premier_segment(LISTE_MG_SEGMENT::iterator &)
Definition: mg_maillage.cpp:630
FEM_SOLUTION::get_maillage
FEM_MAILLAGE * get_maillage(void)
Definition: fem_solution.cpp:472
MG_GESTIONNAIRE::ajouter_fem_solution
int ajouter_fem_solution(FEM_SOLUTION *mgsol)
Definition: mg_gestionnaire.cpp:902
MG_TETRA
Definition: mg_tetra.h:37
MG_GEOMETRIE::ajouter_mg_sommet
virtual int ajouter_mg_sommet(MG_SOMMET *mgsom)
Definition: mg_geometrie.cpp:497
MGOPT_POSTTRAITEMENT::est_non_manifold
int est_non_manifold(MG_NOEUD *no)
Definition: mgopt_posttraitement.cpp:2959
FEM_MAILLAGE::get_fem_noeudid
FEM_NOEUD * get_fem_noeudid(unsigned long num)
Definition: fem_maillage.cpp:150
FEM_ELEMENT2
Definition: fem_element2.h:34
MGOPT_POSTTRAITEMENT::extract_skin_maille_entiere
class MG_MAILLAGE * extract_skin_maille_entiere(FEM_MAILLAGE *mai, MG_GESTIONNAIRE &gest2)
Definition: mgopt_posttraitement.cpp:1111
MG_TRIANGLE::get_lien_tetra
TPL_LISTE_ENTITE< class MG_TETRA * > * get_lien_tetra(void)
Definition: mg_triangle.cpp:177
FEM_MAILLAGE::get_mg_maillage
MG_MAILLAGE * get_mg_maillage(void)
Definition: fem_maillage.cpp:93
MG_MAILLAGE_OUTILS
Definition: mg_maillage_outils.h:47
FEM_MAILLAGE::get_premier_element2
FEM_ELEMENT2 * get_premier_element2(LISTE_FEM_ELEMENT2::iterator &it)
Definition: fem_maillage.cpp:561
MG_MAILLAGE::get_suivant_tetra
MG_TETRA * get_suivant_tetra(LISTE_MG_TETRA::iterator &it)
Definition: mg_maillage.cpp:1382
MG_ELEMENT_TOPOLOGIQUE
Definition: mg_element_topologique.h:51
MGOPT_POSTTRAITEMENT::calcul_volume_ini
void calcul_volume_ini(class MG_MAILLAGE *mg_mai, double *volumetot, double *volumenondesign)
Definition: mgopt_posttraitement.cpp:144
MG_MAILLAGE_OUTILS::get_noeud_voisin
void get_noeud_voisin(MG_NOEUD *no, TPL_MAP_ENTITE< MG_NOEUD * > &liste, int niveau)
Definition: mg_maillage_outils.cpp:3129
MG_GEOMETRIE::get_suivant_sommet
MG_SOMMET * get_suivant_sommet(LISTE_MG_SOMMET::iterator &it)
Definition: mg_geometrie.cpp:632
TPL_LISTE_ENTITE::est_dans_la_liste
virtual int est_dans_la_liste(X x)
Definition: tpl_liste_entite.h:82
MG_NOEUD::change_y
virtual void change_y(double yy)
Definition: mg_noeud.cpp:123
FEM_NOEUD::get_y
virtual double get_y(double coef=0.)
Definition: fem_noeud.cpp:210
MG_ELEMENT_TOPOLOGIQUE::copie_ccf
virtual void copie_ccf(MG_ELEMENT_TOPOLOGIQUE &a1)
Definition: mg_element_topologique.cpp:267
MG_GESTIONNAIRE::ajouter_mg_maillage
int ajouter_mg_maillage(MG_MAILLAGE *mgmai)
Definition: mg_gestionnaire.cpp:521
FEM_NOEUD::get_coord
virtual double * get_coord(void)
Definition: fem_noeud.cpp:254
MGOPT_POSTTRAITEMENT::adapte_seuil
void adapte_seuil(class FEM_MAILLAGE *fem, FEM_SOLUTION *solution)
Definition: mgopt_posttraitement.cpp:1147
MG_ELEMENT_MAILLAGE::get_nouveau_numero
virtual int get_nouveau_numero(void)
Definition: mg_element_maillage.cpp:81
MG_ARETE_ELEMENT
Definition: mg_arete_element.h:32
MGOPT_POSTTRAITEMENT::liste_wij
void liste_wij(double w_ij)
MAGIC::ORIGINE::OPTIMISE
@ OPTIMISE
Definition: mg_definition.h:79
mg_maillage_outils.h
mg_segment.h
FEM_ELEMENT_MAILLAGE::get_solution
virtual double get_solution(int num=0)
Definition: fem_element_maillage.cpp:113
FEM_SOLUTION::active_solution
void active_solution(int num)
Definition: fem_solution.cpp:490
MAILLEUR_ANALYSE::change_borne
virtual void change_borne(double val1, double val2, double val3)
Definition: mailleur_analyse.cpp:61
mgopt_posttraitement.h
MG_GESTIONNAIRE::vide
virtual void vide(void)
Definition: mg_gestionnaire.cpp:56
mg_volume_element.h
MG_NOEUD::change_x
virtual void change_x(double xx)
Definition: mg_noeud.cpp:118
MG_MAILLAGE::get_premier_triangle
MG_TRIANGLE * get_premier_triangle(LISTE_MG_TRIANGLE::iterator &it)
Definition: mg_maillage.cpp:912
mg_export.h
FEM_NOEUD::get_solution
virtual double get_solution(int num=0)
Definition: fem_noeud.cpp:364
MG_ELEMENT_MAILLAGE::get_solution
virtual double get_solution(int num=0)
Definition: mg_element_maillage.cpp:112
MG_GESTIONNAIRE::ajouter_mg_geometrie
int ajouter_mg_geometrie(MG_GEOMETRIE *mggeo)
Definition: mg_gestionnaire.cpp:306
MGOPT_POSTTRAITEMENT::interpole_segment
int interpole_segment(class FEM_MAILLAGE *fem, class FEM_NOEUD *no1, FEM_NOEUD *no2, std::vector< class MG_NOEUD * > *tab, double limit, class MG_MAILLAGE *mai, int creation=1)
Definition: mgopt_posttraitement.cpp:794
MG_MAILLAGE::ajouter_mg_triangle
MG_TRIANGLE * ajouter_mg_triangle(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:731
MG_SEGMENT::get_lien_triangle
TPL_LISTE_ENTITE< class MG_TRIANGLE * > * get_lien_triangle(void)
Definition: mg_segment.cpp:243
MG_SEGMENT::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_segment.cpp:108
OT_PARAMETRES::get_nom
std::string get_nom(std::string chaine)
Definition: ot_parametres.cpp:266
MG_NOEUD::get_lien_segment
TPL_LISTE_ENTITE< class MG_SEGMENT * > * get_lien_segment(void)
Definition: mg_noeud.cpp:141
FEM_MAILLAGE
Definition: fem_maillage.h:66
OT_PARAMETRES::DOUBLE
@ DOUBLE
Definition: ot_parametres.h:38
MG_MAILLAGE::supprimer_mg_triangleid
int supprimer_mg_triangleid(unsigned long num)
Definition: mg_maillage.cpp:820
MGOPT_POSTTRAITEMENT::lissage_jiao2012
int lissage_jiao2012(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, int iter_max)
Definition: mgopt_posttraitement.cpp:1453
TPL_MAP_ENTITE::get_nb
virtual int get_nb(void)
Definition: tpl_map_entite.h:83
MG_TRIANGLE_PEAU::get_voisin3
MG_TRIANGLE_PEAU * get_voisin3(void)
Definition: mg_triangle_peau.cpp:69
MGOPT_POSTTRAITEMENT::extract_skin_par_decoupage
class MG_MAILLAGE * extract_skin_par_decoupage(class FEM_SOLUTION *sol, double limit, MG_GESTIONNAIRE &gest2, std::string nom="")
Definition: mgopt_posttraitement.cpp:230
MG_EXPORT::gmsh
void gmsh(class MG_MAILLAGE *mai, std::string fichier)
Definition: mg_export.cpp:803
MG_NOEUD
Definition: mg_noeud.h:41
MGOPT_POSTTRAITEMENT::lst_peau
std::vector< std::vector< MG_TRIANGLE_PEAU * > * > lst_peau
Definition: mgopt_posttraitement.h:63
MAGIC::ORIGINE::IMPOSE
@ IMPOSE
Definition: mg_definition.h:79
FEM_ELEMENT_MAILLAGE::get_mg_element_maillage
virtual class MG_ELEMENT_MAILLAGE * get_mg_element_maillage(void)
Definition: fem_element_maillage.cpp:81
MG_MAILLAGE::get_suivant_segment
MG_SEGMENT * get_suivant_segment(LISTE_MG_SEGMENT::iterator &)
Definition: mg_maillage.cpp:638
TPL_LISTE_ENTITE::ajouter
virtual void ajouter(X x)
Definition: tpl_liste_entite.h:38
MG_MAILLAGE_OUTILS::get_volume
double get_volume(MG_MAILLAGE *mai)
Definition: mg_maillage_outils.cpp:3186
MGOPT_POSTTRAITEMENT::passage_non_manifold
int passage_non_manifold(MG_NOEUD **no, std::map< int, MG_NOEUD * > *lst_no_voisins, MG_GEOMETRIE *geo, std::vector< MG_NOEUD * > *arete)
MG_NOEUD::get_coord
virtual double * get_coord(void)
Definition: mg_noeud.cpp:92
TPL_MAP_ENTITE::ITERATEUR
std::map< unsigned long, X, std::less< unsigned long > >::iterator ITERATEUR
Definition: tpl_map_entite.h:38
MG_TETRA::get_triangle1
virtual MG_TRIANGLE * get_triangle1(void)
Definition: mg_tetra.cpp:163
MG_TRIANGLE_PEAU::get_voisin2
MG_TRIANGLE_PEAU * get_voisin2(void)
Definition: mg_triangle_peau.cpp:64
MGOPT_POSTTRAITEMENT::extract_skin
int extract_skin(class MG_MAILLAGE *mg_mai, class MG_GESTIONNAIRE &gest2, int &nbpeau, int &nbmaniare, int &nbmanino, int *mai2_id)
Definition: mgopt_posttraitement.cpp:2369
mg_face_element.h
FEM_ELEMENT3::get_jacobien
virtual double get_jacobien(double *jac, double *uv, double unite=1.)
Definition: fem_element3.cpp:144
FEM_MAILLAGE::get_nb_fem_element3
unsigned int get_nb_fem_element3(void)
Definition: fem_maillage.cpp:605
MG_ELEMENT_MAILLAGE::change_origine
virtual void change_origine(int)
Definition: mg_element_maillage.cpp:86
MAGIC::ORIGINE::TRIANGULATION_ARETE
@ TRIANGULATION_ARETE
Definition: mg_definition.h:79
MG_ELEMENT_MAILLAGE::change_nouveau_numero
virtual void change_nouveau_numero(int num)
Definition: mg_element_maillage.cpp:76
MG_TRIANGLE_PEAU::change_voisin3
void change_voisin3(MG_TRIANGLE_PEAU *tri)
Definition: mg_triangle_peau.cpp:84
mg_sommet_noeud.h
TPL_LISTE_ENTITE::get_nb
virtual int get_nb(void)
Definition: tpl_liste_entite.h:67
MAGIC::ORIGINE::TRIANGULATION_ARETEORIGINE
@ TRIANGULATION_ARETEORIGINE
Definition: mg_definition.h:79
node
#define node(i, j)
OT_VECTEUR_3D::norme
virtual void norme(void)
Definition: ot_mathematique.cpp:494
FEM_MAILLAGE::get_suivant_element2
FEM_ELEMENT2 * get_suivant_element2(LISTE_FEM_ELEMENT2::iterator &it)
Definition: fem_maillage.cpp:569
MGOPT_POSTTRAITEMENT::rmimpose
void rmimpose(MG_MAILLAGE *mgmai, char *nomsortie)
Definition: mgopt_posttraitement.cpp:2806
MG_TRIANGLE::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_triangle.cpp:131
MG_GEOMETRIE::get_mg_face
MG_FACE * get_mg_face(unsigned int num)
Definition: mg_geometrie.cpp:1251
MG_GEOMETRIE::get_premier_sommet
MG_SOMMET * get_premier_sommet(LISTE_MG_SOMMET::iterator &it)
Definition: mg_geometrie.cpp:624
passage_non_manifold
int passage_non_manifold(MG_NOEUD **no, std::map< int, MG_NOEUD * > *lst_no_voisins, MG_GEOMETRIE *geo, std::vector< MG_NOEUD * > *arete)
Definition: mgopt_posttraitement.cpp:3031
MAGIC::ORIGINE::DUPLIQUER
@ DUPLIQUER
Definition: mg_definition.h:79
MG_NOEUD::get_lien_tetra
TPL_LISTE_ENTITE< class MG_TETRA * > * get_lien_tetra(void)
Definition: mg_noeud.cpp:175
MGOPT_POSTTRAITEMENT::recherche_voisins
void recherche_voisins(MG_NOEUD *no, std::vector< MG_NOEUD * > *lst_no_1090_1091, std::vector< MG_NOEUD * > *arete, std::map< int, MG_NOEUD * > *lst_no_voisins, bool arete_ouverte, std::vector< MG_NOEUD * > *lst_no_extr)
MAILLEUR_ANALYSE
Definition: mailleur_analyse.h:38
TPL_LISTE_ENTITE::get
virtual X get(int num)
Definition: tpl_liste_entite.h:72
MGOPT_POSTTRAITEMENT::conserve
void conserve(int origine)
Definition: mgopt_posttraitement.cpp:127
MG_TETRA::get_triangle2
virtual MG_TRIANGLE * get_triangle2(void)
Definition: mg_tetra.cpp:168
FEM_NOEUD::get_x
virtual double get_x(double coef=0.)
Definition: fem_noeud.cpp:205
MG_VOLUME_ELEMENT
Definition: mg_volume_element.h:32
MGOPT_POSTTRAITEMENT::ponderation_laplacian
double ponderation_laplacian(double s, double sigma)
Definition: mgopt_posttraitement.cpp:3015
MGOPT_POSTTRAITEMENT::affichageactif
int affichageactif
Definition: mgopt_posttraitement.h:84
FEM_NOEUD
Definition: fem_noeud.h:35
MG_GEOMETRIE::ajouter_mg_face
virtual int ajouter_mg_face(MG_FACE *mgface)
Definition: mg_geometrie.cpp:1210
OT_VECTEUR_3D::get_y
virtual double get_y(void) const
Definition: ot_mathematique.cpp:423
MGOPT_POSTTRAITEMENT::lissage_McKenzie2016
int lissage_McKenzie2016(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double lambda, double nu, double epsilon, double sigma, double gamma_, int filtre, int iter_max, int itr_taubin)
Definition: mgopt_posttraitement.cpp:1938
MG_MAILLAGE::get_mg_noeudid
MG_NOEUD * get_mg_noeudid(unsigned long num)
Definition: mg_maillage.cpp:451
MGOPT_POSTTRAITEMENT::params
OT_PARAMETRES params
Definition: mgopt_posttraitement.h:93
MG_GEOMETRIE::get_nb_mg_face
unsigned int get_nb_mg_face(void)
Definition: mg_geometrie.cpp:1264
OT_PARAMETRES::enregistrer
void enregistrer(char *nom)
Definition: ot_parametres.cpp:132
MG_NOEUD::get_x
virtual double get_x(void)
Definition: mg_noeud.cpp:77
acos
double2 acos(double2 &val)
Definition: ot_doubleprecision.cpp:224
MG_MAILLAGE::get_mg_segment
MG_SEGMENT * get_mg_segment(unsigned int num)
Definition: mg_maillage.cpp:619
MG_GEOMETRIE::get_premier_arete
MG_ARETE * get_premier_arete(LISTE_MG_ARETE::iterator &it)
Definition: mg_geometrie.cpp:907
OT_VECTEUR_3D
Definition: ot_mathematique.h:94
TPL_MAP_ENTITE::ajouter
virtual void ajouter(X x)
Definition: tpl_map_entite.h:55
MGOPT_POSTTRAITEMENT::affiche
void(* affiche)(char *mess)
Definition: mgopt_posttraitement.h:42
MG_TRIANGLE::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_triangle.cpp:126
MG_GESTIONNAIRE::supprimer_fem_solution
int supprimer_fem_solution(unsigned int num)
Definition: mg_gestionnaire.cpp:984
MGOPT_POSTTRAITEMENT::ponderation_elfallahford
double ponderation_elfallahford(double s, double sigma)
Definition: mgopt_posttraitement.cpp:3022
mg_maillage.h
MG_TETRA::get_noeud4
virtual MG_NOEUD * get_noeud4(void)
Definition: mg_tetra.cpp:158
MG_GEOMETRIE::ajouter_mg_arete
virtual int ajouter_mg_arete(MG_ARETE *mgarete)
Definition: mg_geometrie.cpp:759
FEM_NOEUD::get_z
virtual double get_z(double coef=0.)
Definition: fem_noeud.cpp:215
FEM_MAILLAGE_OUTILS
Definition: fem_maillage_outils.h:56
sqrt
double2 sqrt(double2 &val)
Definition: ot_doubleprecision.cpp:345
MG_MAILLAGE::get_gestionnaire
MG_GESTIONNAIRE * get_gestionnaire(void)
Definition: mg_maillage.cpp:2658
MG_MAILLAGE::supprimer_mg_noeudid
int supprimer_mg_noeudid(unsigned long num)
Definition: mg_maillage.cpp:482
MG_MAILLAGE::get_mg_geometrie
MG_GEOMETRIE * get_mg_geometrie(void)
Definition: mg_maillage.cpp:410
MGOPT_POSTTRAITEMENT::varience_McKenzie2016
void varience_McKenzie2016(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double *vari0, double *vari1, double *vari2)
Definition: mgopt_posttraitement.cpp:1832
MG_GESTIONNAIRE::get_mg_maillageid
MG_MAILLAGE * get_mg_maillageid(unsigned long num)
Definition: mg_gestionnaire.cpp:538
MG_GEOMETRIE::get_valeur_unite
double get_valeur_unite(void)
Definition: mg_geometrie.cpp:2652
FEM_MAILLAGE_OUTILS::estdansletetra
int estdansletetra(class XFEM_ELEMENT3 *tet, double x, double y, double z)
Definition: fem_maillage_outils.cpp:158
MG_ELEMENT_MAILLAGE::get_lien_topologie
MG_ELEMENT_TOPOLOGIQUE * get_lien_topologie(void)
Definition: mg_element_maillage.cpp:51
MG_GEOMETRIE::get_mg_faceid
MG_FACE * get_mg_faceid(unsigned long num)
Definition: mg_geometrie.cpp:1226
ot_algorithme_geometrique.h
TPL_MAP_ENTITE::get
virtual X get(int num)
Definition: tpl_map_entite.h:89
mg_geometrie_outils.h
MG_TRIANGLE::get_noeud3
virtual MG_NOEUD * get_noeud3(void)
Definition: mg_triangle.cpp:137
MG_TETRA::get_noeud3
virtual MG_NOEUD * get_noeud3(void)
Definition: mg_tetra.cpp:153
MAILLEUR_ANALYSE::analyse_qualite_maillage_2D
virtual void analyse_qualite_maillage_2D(class MG_SOLUTION *sol, double &qualmin, double &qualmax, double &qualmoy, int *tab)
Definition: mailleur_analyse.cpp:458
MAILLEUR_ANALYSE::change_eps_angle_retourne
virtual void change_eps_angle_retourne(double val)
Definition: mailleur_analyse.cpp:75
OT_VECTEUR_3D::get_z
virtual double get_z(void) const
Definition: ot_mathematique.cpp:429
MG_GEOMETRIE
Definition: mg_geometrie.h:84
OT_PARAMETRES::lire
int lire(char *nom)
Definition: ot_parametres.cpp:144
MGOPT_POSTTRAITEMENT::lire_params
void lire_params(char *fichier)
Definition: mgopt_posttraitement.cpp:885
MG_MAILLAGE::get_suivant_triangle
MG_TRIANGLE * get_suivant_triangle(LISTE_MG_TRIANGLE::iterator &it)
Definition: mg_maillage.cpp:920
OT_VECTEUR_3D::get_longueur
virtual double get_longueur(void) const
Definition: ot_mathematique.cpp:483
recherche_voisins
void recherche_voisins(MG_NOEUD *no, std::vector< MG_NOEUD * > *lst_no_1090_1091, std::vector< MG_NOEUD * > *arete, std::map< int, MG_NOEUD * > *lst_no_voisins, bool arete_ouverte, std::vector< MG_NOEUD * > *lst_no_extr)
Definition: mgopt_posttraitement.cpp:3077
MG_MAILLAGE
Definition: mg_maillage.h:62
FEM_MAILLAGE::get_suivant_noeud
FEM_NOEUD * get_suivant_noeud(LISTE_FEM_NOEUD::iterator &it)
Definition: fem_maillage.cpp:182
TPL_LISTE_ENTITE< MG_TRIANGLE * >
MG_FACE_ELEMENT
Definition: mg_face_element.h:32
MGOPT_POSTTRAITEMENT::lissage_aretes2017
void lissage_aretes2017(MG_MAILLAGE *mg_mai, MG_GESTIONNAIRE &gest2, double lambda, int nb_iter)
Definition: mgopt_posttraitement.cpp:1165
MG_TETRA::get_triangle4
virtual MG_TRIANGLE * get_triangle4(void)
Definition: mg_tetra.cpp:178
MGOPT_POSTTRAITEMENT::reactivation
void reactivation(class MG_MAILLAGE *mg_mai, class MG_GESTIONNAIRE &gest2)
Definition: mgopt_posttraitement.cpp:180
MGOPT_POSTTRAITEMENT::ponderation_gaussian
double ponderation_gaussian(double s, double sigma)
Definition: mgopt_posttraitement.cpp:3008
MG_GESTIONNAIRE::supprimer_mg_maillageid
int supprimer_mg_maillageid(unsigned long num)
Definition: mg_gestionnaire.cpp:585
MG_ARETE
Definition: mg_arete.h:36
MG_FACE
Definition: mg_face.h:34
MG_GESTIONNAIRE::get_nb_fem_solution
unsigned int get_nb_fem_solution(void)
Definition: mg_gestionnaire.cpp:960
MGOPT_POSTTRAITEMENT::insere_triangle
class MG_TRIANGLE_PEAU * insere_triangle(class MG_GEOMETRIE *geo, class MG_MAILLAGE *maiori, class MG_NOEUD *n1ori, MG_NOEUD *n2ori, MG_NOEUD *n3ori, std::map< unsigned long, unsigned long > &correspondid, class MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_MAILLAGE *mg_maillage, int origine)
Definition: mgopt_posttraitement.cpp:2883
MG_ELEMENT_MAILLAGE::get_origine
virtual int get_origine(void)
Definition: mg_element_maillage.cpp:91
MAGIC::TYPE_SOLUTION::SCALAIRE
@ SCALAIRE
Definition: mg_definition.h:93
TPL_MAP_ENTITE::get_suivant
virtual X get_suivant(ITERATEUR &it)
Definition: tpl_map_entite.h:120
mg_triangle_peau.h
MG_SOMMET
Definition: mg_sommet.h:35
MGOPT_POSTTRAITEMENT::get_noeud_peau
MG_NOEUD * get_noeud_peau(FEM_NOEUD *no, MG_MAILLAGE *mai, std::map< unsigned long, unsigned long > &correspondid, MG_GEOMETRIE *geo)
Definition: mgopt_posttraitement.cpp:753
MG_GEOMETRIE::gest
MG_GESTIONNAIRE * gest
Definition: mg_geometrie.h:349
MAGIC::ORIGINE::TRIANGULATION
@ TRIANGULATION
Definition: mg_definition.h:79
MG_SOMMET_NOEUD
Definition: mg_sommet_noeud.h:33
MG_GEOMETRIE::get_suivant_face
MG_FACE * get_suivant_face(LISTE_MG_FACE::iterator &it)
Definition: mg_geometrie.cpp:1346
MAGIC::ORIGINE::MAILLEUR_AUTO
@ MAILLEUR_AUTO
Definition: mg_definition.h:79
MG_GEOMETRIE::get_mg_sommetid
MG_SOMMET * get_mg_sommetid(unsigned long num)
Definition: mg_geometrie.cpp:513
MG_GESTIONNAIRE::get_mg_geometrie
MG_GEOMETRIE * get_mg_geometrie(unsigned int num)
Definition: mg_gestionnaire.cpp:331
FEM_SOLUTION::change_legende
void change_legende(int num, std::string val)
Definition: fem_solution.cpp:457
MG_MAILLAGE::get_suivant_noeud
MG_NOEUD * get_suivant_noeud(LISTE_MG_NOEUD::iterator &it)
Definition: mg_maillage.cpp:556
MGOPT_POSTTRAITEMENT::oriente_tri
void oriente_tri(MG_TRIANGLE_PEAU *tri, double *xyz)
Definition: mgopt_posttraitement.cpp:736
MGOPT_POSTTRAITEMENT::recherche_voisin
MG_TRIANGLE_PEAU * recherche_voisin(MG_NOEUD *mg_noeud1, MG_NOEUD *mg_noeud2, MG_TRIANGLE_PEAU *triref)
Definition: mgopt_posttraitement.cpp:2938
MG_GEOMETRIE::get_mg_volume
MG_VOLUME * get_mg_volume(unsigned int num)
Definition: mg_geometrie.cpp:1683
MG_TETRA::get_triangle3
virtual MG_TRIANGLE * get_triangle3(void)
Definition: mg_tetra.cpp:173
MG_GEOMETRIE::get_suivant_arete
MG_ARETE * get_suivant_arete(LISTE_MG_ARETE::iterator &it)
Definition: mg_geometrie.cpp:915
OT_VECTEUR_3D::change_x
virtual void change_x(double x)
Definition: ot_mathematique.cpp:434
FEM_MAILLAGE::get_premier_element3
FEM_ELEMENT3 * get_premier_element3(LISTE_FEM_ELEMENT3::iterator &it)
Definition: fem_maillage.cpp:672
fem_maillage_outils.h
MG_NOEUD::get_y
virtual double get_y(void)
Definition: mg_noeud.cpp:82
MG_MAILLAGE::ajouter_mg_noeud
MG_NOEUD * ajouter_mg_noeud(MG_ELEMENT_TOPOLOGIQUE *topo, double xx, double yy, double zz, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:421
MGOPT_POSTTRAITEMENT::cardinalite
int cardinalite(MG_MAILLAGE *mgmai, int cardinalite_iter)
Definition: mgopt_posttraitement.cpp:2734