MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
mailleur3d_outil.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 //####// mailleur3d_outil.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:58:56 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 
23 
24 #include "gestionversion.h"
25 
26 
27 
28 #include <math.h>
29 #include "mailleur3d.h"
30 #include "mailleur3d_front.h"
31 #include "ot_mathematique.h"
32 #include "ot_boite_3d.h"
33 #include "m3d_noeud.h"
34 #include "m3d_tetra.h"
35 #include "m3d_triangle.h"
36 #include "mg_geometrie_outils.h"
37 #include "tpl_fonctions_generiques.h"
38 
39 
40 
41 
42 
43 
44 
45 
46 
47 double MAILLEUR3D::angle_front(MG_FRONT_3D* ft1,MG_FRONT_3D* ft2)
48 {
49  MG_NOEUD* noeud1=ft1->get_noeud1();
50  MG_NOEUD* noeud2=ft1->get_noeud2();
51  MG_NOEUD* noeud3=ft1->get_noeud3();
52  MG_NOEUD* noeud4=ft2->get_noeud1();
53  MG_NOEUD* noeud5=ft2->get_noeud2();
54  MG_NOEUD* noeud6=ft2->get_noeud3();
55  return get_angle_par_noeud<MG_NOEUD*>(noeud1,noeud2,noeud3,noeud4,noeud5,noeud6);
56 }
57 
58 
59 
60 double MAILLEUR3D::angle_front(MG_FRONT_3D* ft,MG_SEGMENT* seg)
61 {
62  MG_NOEUD* noeud1;
63  MG_NOEUD* noeud2;
64  MG_NOEUD* noeud3;
65  MG_NOEUD* noeud4;
66 
67 
68  if (seg->get_noeud1()==ft->get_noeud1())
69  {
70  noeud1=ft->get_noeud1();
71  noeud2=ft->get_noeud2();
72  noeud3=ft->get_noeud3();
73  noeud4=seg->get_noeud2();
74  }
75  if (seg->get_noeud1()==ft->get_noeud2())
76  {
77  noeud1=ft->get_noeud2();
78  noeud2=ft->get_noeud3();
79  noeud3=ft->get_noeud1();
80  noeud4=seg->get_noeud2();
81  }
82  if (seg->get_noeud1()==ft->get_noeud3())
83  {
84  noeud1=ft->get_noeud3();
85  noeud2=ft->get_noeud1();
86  noeud3=ft->get_noeud2();
87  noeud4=seg->get_noeud2();
88  }
89  if (seg->get_noeud2()==ft->get_noeud1())
90  {
91  noeud1=ft->get_noeud1();
92  noeud2=ft->get_noeud2();
93  noeud3=ft->get_noeud3();
94  noeud4=seg->get_noeud1();
95  }
96  if (seg->get_noeud2()==ft->get_noeud2())
97  {
98  noeud1=ft->get_noeud2();
99  noeud2=ft->get_noeud3();
100  noeud3=ft->get_noeud1();
101  noeud4=seg->get_noeud1();
102  }
103  if (seg->get_noeud2()==ft->get_noeud3())
104  {
105  noeud1=ft->get_noeud3();
106  noeud2=ft->get_noeud1();
107  noeud3=ft->get_noeud2();
108  noeud4=seg->get_noeud1();
109  }
110 
111  OT_VECTEUR_3D n1n2(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
112  OT_VECTEUR_3D n1n3(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
113  OT_VECTEUR_3D n1n4(noeud4->get_x()-noeud1->get_x(),noeud4->get_y()-noeud1->get_y(),noeud4->get_z()-noeud1->get_z());
114  OT_VECTEUR_3D n1n=n1n2&n1n3;
115  OT_MATRICE_3D mat(n1n2,n1n3,n1n);
116  OT_MATRICE_3D matx(n1n4,n1n3,n1n);
117  OT_MATRICE_3D maty(n1n2,n1n4,n1n);
118  OT_MATRICE_3D matz(n1n2,n1n3,n1n4);
119  double det=mat.get_determinant();
120  double xsi=matx.get_determinant()/det;
121  double eta=maty.get_determinant()/det;
122  double psi=matz.get_determinant()/det;
123 
124  double proj[3];
125  proj[0]=(1.-xsi-eta)*noeud1->get_x()+xsi*noeud2->get_x()+eta*noeud3->get_x();
126  proj[1]=(1.-xsi-eta)*noeud1->get_y()+xsi*noeud2->get_y()+eta*noeud3->get_y();
127  proj[2]=(1.-xsi-eta)*noeud1->get_z()+xsi*noeud2->get_z()+eta*noeud3->get_z();
128  OT_VECTEUR_3D n1nproj(noeud1->get_x()-proj[0],noeud1->get_y()-proj[1],noeud1->get_z()-proj[2]);
129  //n1n4.norme();
130  //n1nproj.norme();
131  double ps=n1n4*n1nproj;
132  if (!(OPERATEUR::egal(ps,0.0,0.0001))) ps=ps/n1n4.get_longueur()/n1nproj.get_longueur();
133  else ps=0.;
134  if (ps>1.) ps=1.;
135  if (ps<-1.) ps=-1.;
136  double angle=acos(ps);
137  if ((xsi<0.) || (eta<0.) ) angle=angle+M_PI/2.;
138  if (psi<0.) angle=2*M_PI-angle;
139  return angle;
140 
141 }
142 
143 
144 
145 
146 
147 class MG_TETRA* MAILLEUR3D::insere_tetra(class MG_ELEMENT_TOPOLOGIQUE* mgvol,class MG_FRONT_3D* ft,MG_NOEUD* noeud4,int type,TPL_MAP_ENTITE<class MG_TRIANGLE*>& liste_intersection)
148 {
149  liste_intersection.vide();
150  MG_NOEUD* noeud1=ft->get_noeud1();
151  MG_NOEUD* noeud2=ft->get_noeud2();
152  MG_NOEUD* noeud3=ft->get_noeud3();
153 
154  MG_NOEUD* noeud;
155  MG_TETRA* tet=mg_maillage->get_mg_tetra(noeud1,noeud2,noeud3,noeud4);
156  if (tet!=NULL)
157  return NULL;
158  TPL_MAP_ENTITE<MG_FRONT_3D*> liste;
159  double x=0.25*(noeud1->get_x()+noeud2->get_x()+noeud3->get_x()+noeud4->get_x());
160  double y=0.25*(noeud1->get_y()+noeud2->get_y()+noeud3->get_y()+noeud4->get_y());
161  double z=0.25*(noeud1->get_z()+noeud2->get_z()+noeud3->get_z()+noeud4->get_z());
162  double longueur=1.2*sqrt((x-noeud1->get_x())*(x-noeud1->get_x())+(y-noeud1->get_y())*(y-noeud1->get_y())+(z-noeud1->get_z())*(z-noeud1->get_z()));
163  ntree_de_front->rechercher(x,y,z,longueur,liste);
164  int nb_liste=liste.get_nb();
165  for (int i=0;i<nb_liste;i++)
166  {
167  MG_FRONT_3D* fttmp=liste.get(i);
168  /*if (passetmp>=256957)
169  if (i==32)
170  {
171  double *xyz1=noeud1->get_coord();
172  double *xyz2=noeud2->get_coord();
173  double *xyz3=noeud3->get_coord();
174  double *xyz4=noeud4->get_coord();
175  double *xyz4bis=fttmp->get_noeud3()->get_coord();
176  double xx=fttmp->get_noeud3()->get_x();
177  double yy=fttmp->get_noeud3()->get_y();
178  double zz=fttmp->get_noeud3()->get_z();
179  double xx2=noeud4->get_x();
180  double yy2=noeud4->get_y();
181  double zz2=noeud4->get_z();
182  int res=OPERATEUR::estdansletetra(xyz1,xyz2,xyz3,xyz4,xx,yy,zz);
183  int res2=OPERATEUR::estdansletetra(xyz1,xyz2,xyz4bis,xyz3,xx2,yy2,zz2);
184  }*/
185  int inter=inter_tetra_triangle(noeud1,noeud2,noeud3,noeud4,fttmp->get_noeud1(),fttmp->get_noeud2(),fttmp->get_noeud3());
186 
187  if (inter==true)
188  liste_intersection.ajouter(fttmp->get_triangle());
189  }
190  int nb_inter=liste_intersection.get_nb();
191  if (nb_inter>0)
192  return NULL;
193  MG_TRIANGLE* triangle1=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud3->get_id(),noeud2->get_id());
194  MG_TRIANGLE* triangle2=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud2->get_id(),noeud4->get_id());
195  MG_TRIANGLE* triangle3=mg_maillage->get_mg_triangle(noeud2->get_id(),noeud3->get_id(),noeud4->get_id());
196  MG_TRIANGLE* triangle4=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud4->get_id(),noeud3->get_id());
197  double vol1=-1.;
198  double vol2=-1.;
199  double vol3=-1.;
200  double vol4=-1.;
201  if (type==MAGIC::MAILLEURFRONTALETAT::GENERATION_NOEUD)
202  {
203  if (triangle1!=NULL)
204  if (triangle1->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
205  {
206  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle1;
207  MG_TETRA* tet=tri->get_voisin(0);
208  if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
209  {
210  M3D_TETRA* mtet=(M3D_TETRA*)tet;
211  vol1=mtet->get_volume();
212  }
213  }
214  if (triangle2!=NULL)
215  if (triangle2->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
216  {
217  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle2;
218  MG_TETRA* tet=tri->get_voisin(0);
219  if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
220  {
221  M3D_TETRA* mtet=(M3D_TETRA*)tet;
222  vol2=mtet->get_volume();
223  }
224  }
225  if (triangle3!=NULL)
226  if (triangle3->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
227  {
228  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle3;
229  MG_TETRA* tet=tri->get_voisin(0);
230  if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
231  {
232  M3D_TETRA* mtet=(M3D_TETRA*)tet;
233  vol3=mtet->get_volume();
234  }
235  }
236  if (triangle4!=NULL)
237  if (triangle4->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
238  {
239  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle4;
240  MG_TETRA* tet=tri->get_voisin(0);
241  if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
242  {
243  M3D_TETRA* mtet=(M3D_TETRA*)tet;
244  vol4=mtet->get_volume();
245  }
246  }
247  double vol=calcule_volume(noeud1,noeud2,noeud3,noeud4);
248  // calcul du vol du tetra ideal
249  OT_VECTEUR_3D ab(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
250  OT_VECTEUR_3D ac(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
251  OT_VECTEUR_3D da(noeud1->get_x()-noeud4->get_x(),noeud1->get_y()-noeud4->get_y(),noeud1->get_z()-noeud4->get_z());
252  OT_VECTEUR_3D vec=ab&ac;
253  vec.norme();
254  double lg_tet_ideal=fabs(vec*da*ft->get_ifail()*sqrt(3./2.));
255  double vol_ideal=sqrt(2.)/12.*lg_tet_ideal*lg_tet_ideal*lg_tet_ideal;
256  if (vol<0.1*vol_ideal)
257  {
258  if ((vol1>0.) && (vol1<0.1*vol_ideal))
259  return NULL;
260  if ((vol2>0.) && (vol2<0.1*vol_ideal))
261  return NULL;
262  if ((vol3>0.) && (vol3<0.1*vol_ideal))
263  return NULL;
264  if ((vol4>0.) && (vol4<0.1*vol_ideal))
265  return NULL;
266 
267  }
268  }
269 return insere_tetra(mgvol,noeud1,noeud2,noeud3,noeud4,triangle1,triangle2,triangle3,triangle4);
270 }
271 
272 class MG_TETRA* MAILLEUR3D::insere_tetra(class MG_ELEMENT_TOPOLOGIQUE* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4,MG_TRIANGLE* triangle1,MG_TRIANGLE* triangle2,MG_TRIANGLE* triangle3,MG_TRIANGLE* triangle4)
273  {
274  if (triangle1==NULL) triangle1=insere_triangle(mgvol,noeud1,noeud3,noeud2,MAGIC::ORIGINE::MAILLEUR_AUTO);
275  if (triangle2==NULL) triangle2=insere_triangle(mgvol,noeud1,noeud2,noeud4,MAGIC::ORIGINE::MAILLEUR_AUTO);
276  if (triangle3==NULL) triangle3=insere_triangle(mgvol,noeud2,noeud3,noeud4,MAGIC::ORIGINE::MAILLEUR_AUTO);
277  if (triangle4==NULL) triangle4=insere_triangle(mgvol,noeud1,noeud4,noeud3,MAGIC::ORIGINE::MAILLEUR_AUTO);
278  MG_TETRA* tetra=cree_tetra(mgvol,noeud1,noeud2,noeud3,noeud4,triangle1,triangle2,triangle3,triangle4,MAGIC::ORIGINE::MAILLEUR_AUTO);
279  mg_maillage->ajouter_mg_tetra(tetra);
280  if (triangle1->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
281  {
282  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle1;
283  tri->ajouter_voisin(tetra);
284  }
285  if (triangle2->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
286  {
287  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle2;
288  tri->ajouter_voisin(tetra);
289  }
290  if (triangle3->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
291  {
292  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle3;
293  tri->ajouter_voisin(tetra);
294  }
295  if (triangle4->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
296  {
297  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle4;
298  tri->ajouter_voisin(tetra);
299  }
300 
301  return tetra;
302 
303 }
304 
305 
306 
307 class MG_TRIANGLE* MAILLEUR3D::insere_triangle(class MG_ELEMENT_TOPOLOGIQUE* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,int origine)
308 {
309  // existence du triangle
310  MG_TRIANGLE* triangle=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud3->get_id(),noeud2->get_id());
311  if (triangle!=NULL) return triangle;
312  MG_SEGMENT* segment1=mg_maillage->get_mg_segment(noeud1->get_id(),noeud2->get_id());
313  MG_SEGMENT* segment2=mg_maillage->get_mg_segment(noeud1->get_id(),noeud3->get_id());
314  MG_SEGMENT* segment3=mg_maillage->get_mg_segment(noeud2->get_id(),noeud3->get_id());
315  if (segment1==NULL) segment1=cree_segment(mgvol,noeud1,noeud2,origine);
316  if (segment2==NULL) segment2=cree_segment(mgvol,noeud1,noeud3,origine);
317  if (segment3==NULL) segment3=cree_segment(mgvol,noeud2,noeud3,origine);
318  MG_TRIANGLE* tri=cree_triangle(mgvol,noeud1,noeud2,noeud3,segment1,segment2,segment3,origine);
319  return tri;
320 }
321 
322 
323 
324 class MG_SEGMENT* MAILLEUR3D::insere_segment(class MG_ELEMENT_TOPOLOGIQUE* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,int origine)
325 {
326 
327  MG_SEGMENT* segment=mg_maillage->get_mg_segment(noeud1->get_id(),noeud2->get_id());
328  if (segment!=NULL) return NULL;
329  MG_SEGMENT* seg=cree_segment(mgvol,noeud1,noeud2,origine);
330  return seg;
331 }
332 
333 
334 
335 
336 MG_TETRA* MAILLEUR3D::cree_tetra(class MG_ELEMENT_TOPOLOGIQUE* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4,MG_TRIANGLE* triangle1,MG_TRIANGLE* triangle2,MG_TRIANGLE* triangle3,MG_TRIANGLE* triangle4,int origine)
337 {
338  M3D_TETRA* tetra=new M3D_TETRA(mgvol,noeud1,noeud2,noeud3,noeud4,triangle1,triangle2,triangle3,triangle4,origine);
339  mg_maillage->ajouter_mg_tetra(tetra);
340  return tetra;
341 }
342 
343 
344 MG_TRIANGLE* MAILLEUR3D::cree_triangle(class MG_ELEMENT_TOPOLOGIQUE* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_SEGMENT* segment1,MG_SEGMENT* segment2,MG_SEGMENT* segment3,int origine)
345 {
346  M3D_TRIANGLE* tri=new M3D_TRIANGLE(mgvol,noeud1,noeud2,noeud3,segment1,segment2,segment3,origine);
347  mg_maillage->ajouter_mg_triangle(tri);
348  return tri;
349 }
350 
351 
352 
353 MG_SEGMENT* MAILLEUR3D::cree_segment(class MG_ELEMENT_TOPOLOGIQUE* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,int origine)
354 {
355  MG_SEGMENT* seg=mg_maillage->ajouter_mg_segment(mgvol,noeud1,noeud2,origine);
356  return seg;
357 }
358 
359 
360 
361 double MAILLEUR3D::calcule_volume(MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4)
362 {
363  OT_VECTEUR_3D ab(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
364  OT_VECTEUR_3D ac(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
365  OT_VECTEUR_3D da(noeud1->get_x()-noeud4->get_x(),noeud1->get_y()-noeud4->get_y(),noeud1->get_z()-noeud4->get_z());
366 
367  OT_VECTEUR_3D pvec=ab&ac;
368  double volume=pvec*da;
369  volume=fabs(volume)/3.;
370  return volume;
371 }
372 
373 
374 
375 double MAILLEUR3D::calcule_longueur_caracteristique(MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4)
376 {
377 
378  OT_VECTEUR_3D ab(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
379  double lg=ab.get_longueur();
380  int nb=1;
381  if (noeud3!=NULL)
382  {
383  OT_VECTEUR_3D ac(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
384  OT_VECTEUR_3D bc(noeud3->get_x()-noeud2->get_x(),noeud3->get_y()-noeud2->get_y(),noeud3->get_z()-noeud2->get_z());
385  lg=lg+ac.get_longueur()+bc.get_longueur();
386  nb=3;
387  }
388  if (noeud4!=NULL)
389  {
390  OT_VECTEUR_3D da(noeud1->get_x()-noeud4->get_x(),noeud1->get_y()-noeud4->get_y(),noeud1->get_z()-noeud4->get_z());
391  OT_VECTEUR_3D bd(noeud4->get_x()-noeud2->get_x(),noeud4->get_y()-noeud2->get_y(),noeud4->get_z()-noeud2->get_z());
392  OT_VECTEUR_3D cd(noeud4->get_x()-noeud3->get_x(),noeud4->get_y()-noeud3->get_y(),noeud4->get_z()-noeud3->get_z());
393  lg=lg+da.get_longueur()+bd.get_longueur()+cd.get_longueur();
394  nb=6;
395  }
396  lg=lg*1./nb;
397  return lg;
398 
399 }
400 
401 double MAILLEUR3D::calcul_distance_metrique_segment(MG_SEGMENT *seg,int pas)
402 {
403 double l;
404 bool res=seg->get_distance_metrique(&l);
405 if (res==false)
406  {
407  l=metrique->calcul_distance_metrique(seg,pas);
408  seg->change_distance_metrique(l);
409  }
410 return l;
411 }
412 
413 
414 int MAILLEUR3D::genere_noeud(MG_VOLUME* mgvol,MG_FRONT_3D* ft,TPL_MAP_ENTITE<MG_NOEUD*> &liste_noeud,std::vector<CAS_FRONT*> &liste_cas)
415 {
416  MG_NOEUD* noeud1=ft->get_noeud1();
417  MG_NOEUD* noeud2=ft->get_noeud2();
418  MG_NOEUD* noeud3=ft->get_noeud3();
419  OT_VECTEUR_3D n1n2(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
420  OT_VECTEUR_3D n1n3(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
421  OT_VECTEUR_3D normalnonnorme=n1n2&n1n3;
422  OT_VECTEUR_3D normal=normalnonnorme;
423  normal.norme();
424  double xyz1[3]={noeud1->get_x(),noeud1->get_y(),noeud1->get_z()};
425  double xyz2[3]={noeud2->get_x(),noeud2->get_y(),noeud2->get_z()};
426  double xyz3[3]={noeud3->get_x(),noeud3->get_y(),noeud3->get_z()};
427  double hauteur=0.81649658*ft->get_triangle()->get_longueur();
428  double xyzg[3]={0.333333333333*(xyz1[0]+xyz2[0]+xyz3[0]),0.333333333333*(xyz1[1]+xyz2[1]+xyz3[1]),0.333333333333*(xyz1[2]+xyz2[2]+xyz3[2])};
429  double xyz4[3];
430  do
431  {
432  xyz4[0]=xyzg[0]+hauteur*normal.get_x();
433  xyz4[1]=xyzg[1]+hauteur*normal.get_y();
434  xyz4[2]=xyzg[2]+hauteur*normal.get_z();
435  hauteur=hauteur*0.9;
436  }
437  while (metrique->valide_parametre(xyz4)==0);
438  double l1=calcul_distance_metrique_segment(ft->get_triangle()->get_segment1(),pas);
439  double l2=calcul_distance_metrique_segment(ft->get_triangle()->get_segment2(),pas);
440  double l3=calcul_distance_metrique_segment(ft->get_triangle()->get_segment3(),pas);
441  double l=0.333333333333333*(l1+l2+l3);
442  double longueur_desiree=0.81649658*(priorite_metrique+(1-priorite_metrique)*l);
443  longueur_desiree=longueur_desiree/ft->get_ifail();
444  int res=metrique->ajuste_distance_metrique(xyzg,xyz4,longueur_desiree,pas);
445  if (res==0) return MAGIC::MAILLEURFRONTALETAT::PASTROUVE;
446  OT_VECTEUR_3D hauteurajustee(xyzg[0]-xyz4[0],xyzg[1]-xyz4[1],xyzg[2]-xyz4[2]);
447  hauteur=hauteurajustee.get_longueur();
448 
449  TPL_MAP_ENTITE<MG_FRONT_3D*> liste_front;
450  TPL_MAP_ENTITE<MG_FRONT_3D*> liste_front_proche;
451  ntree_de_front->rechercher(xyz4[0],xyz4[1],xyz4[2],hauteur*1.837117307,liste_front);
452  int nb_liste=liste_front.get_nb();
453  double disref=(priorite_metrique+(1-priorite_metrique)*l)/ft->get_ifail();
454  MG_NOEUD* noeudref=NULL;
455  for (int i=0;i<nb_liste;i++)
456  {
457  MG_FRONT_3D* ft2=liste_front.get(i);
458  for (int j=0;j<3;j++)
459  {
460  MG_NOEUD* noeud_tmp;
461  if (j==0) noeud_tmp=ft2->get_noeud1();
462  if (j==1) noeud_tmp=ft2->get_noeud2();
463  if (j==2) noeud_tmp=ft2->get_noeud3();
464  double *xyz_tmp=noeud_tmp->get_coord();
465  // ici il faut verifier que ;'on pogne un noeud du bon coté du front
466  OT_VECTEUR_3D vec(xyz_tmp[0]-xyzg[0],xyz_tmp[1]-xyzg[1],xyz_tmp[2]-xyzg[2]);
467  double eps=0.333333333333333*(vec.diff()+n1n2.diff()+n1n3.diff());
468  eps=6.*eps*EPS_BASE_RELATIVE;
469  if (vec*normalnonnorme<eps) continue;
470  double dis=metrique->calcul_distance_metrique(xyz_tmp,xyz4,1);
471  if (dis<disref)
472  {
473  disref=dis;
474  noeudref=noeud_tmp;
475  }
476  }
477  if (ft2!=ft)
478  {
479  double dismin=evaluer_distance_noeud_triangle(xyz4[0],xyz4[1],xyz4[2],ft2->get_triangle());
480  if (dismin<hauteur) liste_front_proche.ajouter(ft2);
481  }
482  }
483  if (noeudref!=NULL)
484  {
485  double dis2=metrique->calcul_distance_metrique(noeudref->get_coord(),xyzg,2);
486  if (dis2<longueur_desiree*1.5)
487  if (noeudref!=noeud1)
488  if (noeudref!=noeud2)
489  if (noeudref!=noeud3)
490  {
491  liste_noeud.ajouter(noeudref);
492  return MAGIC::MAILLEURFRONTALETAT::EXISTE;
493  }
494  }
495  int nb_proche=liste_front_proche.get_nb();
496  int nb_cas=liste_cas.size();
497  if (nb_proche>0)
498  {
499  for (int i=0;i<nb_proche;i++)
500  {
501  MG_FRONT_3D* fttmp=liste_front_proche.get(i);
502  int ok=0;
503  for (int j=0;j<nb_cas;j++)
504  {
505  MG_NOEUD* casnoeud=liste_cas[j]->mgnoeud;
506  if ((fttmp->get_noeud1()==casnoeud) || (fttmp->get_noeud2()==casnoeud) || (fttmp->get_noeud3()==casnoeud) )
507  {
508  ok=1;
509  break;
510  }
511  }
512  if (ok==1) continue;
513  MG_NOEUD* noeudtmp=fttmp->get_noeud1();
514  if (noeudtmp!=noeud1)
515  if (noeudtmp!=noeud2)
516  if (noeudtmp!=noeud3) liste_noeud.ajouter(noeudtmp);
517  noeudtmp=fttmp->get_noeud2();
518  if (noeudtmp!=noeud1)
519  if (noeudtmp!=noeud2)
520  if (noeudtmp!=noeud3) liste_noeud.ajouter(noeudtmp);
521  noeudtmp=fttmp->get_noeud3();
522  if (noeudtmp!=noeud1)
523  if (noeudtmp!=noeud2)
524  if (noeudtmp!=noeud3) liste_noeud.ajouter(noeudtmp);
525 
526  }
527  if (liste_noeud.get_nb()>0) return MAGIC::MAILLEURFRONTALETAT::MULTIEXISTE;
528  }
529  M3D_NOEUD* nouveau_noeud=new M3D_NOEUD(mgvol,xyz4[0],xyz4[1],xyz4[2],MAGIC::ORIGINE::MAILLEUR_AUTO);
530  mg_maillage->ajouter_mg_noeud(nouveau_noeud);
531  liste_noeud.ajouter(nouveau_noeud);
532  return MAGIC::MAILLEURFRONTALETAT::CREATION;
533 }
534 
535 
536 
537 double MAILLEUR3D::evaluer_distance_noeud_triangle(double x,double y,double z,MG_TRIANGLE* tri)
538 {
539  double eps=0.0001;
540  MG_NOEUD* noeud1=tri->get_noeud1();
541  MG_NOEUD* noeud2=tri->get_noeud2();
542  MG_NOEUD* noeud3=tri->get_noeud3();
543  OT_VECTEUR_3D n1n2(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
544  OT_VECTEUR_3D n1n3(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
545  OT_VECTEUR_3D n1n4(x-noeud1->get_x(),y-noeud1->get_y(),z-noeud1->get_z());
546  OT_VECTEUR_3D n1n=n1n2&n1n3;
547  OT_MATRICE_3D matbase(n1n2,n1n3,n1n);
548  OT_MATRICE_3D matxsi(n1n4,n1n3,n1n);
549  OT_MATRICE_3D mateta(n1n2,n1n4,n1n);
550  double xsi=matxsi.get_determinant()/matbase.get_determinant();
551  double eta=mateta.get_determinant()/matbase.get_determinant();
552  double dis;
553  if ((eta>-eps) && (xsi>-eps) && (eta+xsi<1.0+eps))
554  {
555  double xproj=(1-xsi-eta)*noeud1->get_x()+xsi*noeud2->get_x()+eta*noeud3->get_x();
556  double yproj=(1-xsi-eta)*noeud1->get_y()+xsi*noeud2->get_y()+eta*noeud3->get_y();
557  double zproj=(1-xsi-eta)*noeud1->get_z()+xsi*noeud2->get_z()+eta*noeud3->get_z();
558  OT_VECTEUR_3D vec(x-xproj,y-yproj,z-zproj);
559  dis=vec.get_longueur();
560  }
561  else
562  {
563  OT_VECTEUR_3D nn1(x-noeud1->get_x(),y-noeud1->get_y(),z-noeud1->get_z());
564  OT_VECTEUR_3D nn2(x-noeud2->get_x(),y-noeud2->get_y(),z-noeud2->get_z());
565  OT_VECTEUR_3D nn3(x-noeud3->get_x(),y-noeud3->get_y(),z-noeud3->get_z());
566  dis=0.3333333333333*(nn1.get_longueur()+nn2.get_longueur()+nn3.get_longueur());
567  }
568  return dis;
569 }
570 
571 
572 void MAILLEUR3D::detruit_tetra(MG_TRIANGLE* tri)
573 {
574 
575  M3D_TRIANGLE* mtri;
576  mtri=(M3D_TRIANGLE*)tri;
577 
578  M3D_TETRA* tet=(M3D_TETRA*)mtri->get_voisin(0);
579  M3D_TRIANGLE* mtriangle1=(M3D_TRIANGLE*)tet->get_triangle1();
580  M3D_TRIANGLE* mtriangle2=(M3D_TRIANGLE*)tet->get_triangle2();
581  M3D_TRIANGLE* mtriangle3=(M3D_TRIANGLE*)tet->get_triangle3();
582  M3D_TRIANGLE* mtriangle4=(M3D_TRIANGLE*)tet->get_triangle4();
583  tet->etat_detruit();
584  lsttet_a_detruire.ajouter(tet);
585  TPL_MAP_ENTITE<MG_FRONT_3D*> liste_de_front;
586  TPL_MAP_ENTITE<MG_FRONT_3D*> liste_de_front2;
587  MG_FRONT_3D* fttet1=NULL;
588  MG_FRONT_3D* fttet2=NULL;
589  MG_FRONT_3D* fttet3=NULL;
590  MG_FRONT_3D* fttet4=NULL;
591 
592  if (mtriangle1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
593  {
594  MG_FRONT_3D* fttmp=mtriangle1->get_mgfront();
595  fttet1=fttmp;
596  liste_de_front.ajouter(fttmp->get_front_voisin(0));
597  liste_de_front.ajouter(fttmp->get_front_voisin(1));
598  liste_de_front.ajouter(fttmp->get_front_voisin(2));
599  //supprimer_front_en_reculant(fttmp);
600  mtriangle1->supprimer_voisin(tet);
601  }
602  else
603  {
604  MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud1(),tet->get_noeud2(),tet->get_noeud3(),mtriangle1);
605  ftn1->incremente_ifail();
606  mtriangle1->supprimer_voisin(tet);
607  liste_de_front2.ajouter(ftn1);
608  }
609  if (mtriangle2->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
610  {
611  MG_FRONT_3D* fttmp=mtriangle2->get_mgfront();
612  fttet2=fttmp;
613  liste_de_front.ajouter(fttmp->get_front_voisin(0));
614  liste_de_front.ajouter(fttmp->get_front_voisin(1));
615  liste_de_front.ajouter(fttmp->get_front_voisin(2));
616  //supprimer_front_en_reculant(fttmp);
617  mtriangle2->supprimer_voisin(tet);
618  }
619  else
620  {
621  MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud1(),tet->get_noeud4(),tet->get_noeud2(),mtriangle2);
622  ftn1->incremente_ifail();
623  mtriangle2->supprimer_voisin(tet);
624  liste_de_front2.ajouter(ftn1);
625  }
626  if (mtriangle3->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
627  {
628  MG_FRONT_3D* fttmp=mtriangle3->get_mgfront();
629  fttet3=fttmp;
630  liste_de_front.ajouter(fttmp->get_front_voisin(0));
631  liste_de_front.ajouter(fttmp->get_front_voisin(1));
632  liste_de_front.ajouter(fttmp->get_front_voisin(2));
633  //supprimer_front_en_reculant(fttmp);
634  mtriangle3->supprimer_voisin(tet);
635  }
636  else
637  {
638  MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud2(),tet->get_noeud4(),tet->get_noeud3(),mtriangle3);
639  ftn1->incremente_ifail();
640  mtriangle3->supprimer_voisin(tet);
641  liste_de_front2.ajouter(ftn1);
642  }
643  if (mtriangle4->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
644  {
645  MG_FRONT_3D* fttmp=mtriangle4->get_mgfront();
646  fttet4=fttmp;
647  liste_de_front.ajouter(fttmp->get_front_voisin(0));
648  liste_de_front.ajouter(fttmp->get_front_voisin(1));
649  liste_de_front.ajouter(fttmp->get_front_voisin(2));
650  //supprimer_front_en_reculant(fttmp);
651  mtriangle4->supprimer_voisin(tet);
652  }
653  else
654  {
655  MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud1(),tet->get_noeud3(),tet->get_noeud4(),mtriangle4);
656  ftn1->incremente_ifail();
657  mtriangle4->supprimer_voisin(tet);
658  liste_de_front2.ajouter(ftn1);
659  }
660 
661  if (fttet1!=NULL)
662  {
663  liste_de_front.supprimer(fttet1);
664  supprimer_front_en_reculant(fttet1);
665  }
666  if (fttet2!=NULL)
667  {
668  liste_de_front.supprimer(fttet2);
669  supprimer_front_en_reculant(fttet2);
670  }
671  if (fttet3!=NULL)
672  {
673  liste_de_front.supprimer(fttet3);
674  supprimer_front_en_reculant(fttet3);
675  }
676  if (fttet4!=NULL)
677  {
678  liste_de_front.supprimer(fttet4);
679  supprimer_front_en_reculant(fttet4);
680  }
681  int nb_liste1=liste_de_front.get_nb();
682  for (int i=0;i<nb_liste1;i++)
683  if (liste_de_front.get(i)!=NULL)
684  mise_a_jour_voisin_front(liste_de_front.get(i));
685  int nb_liste2=liste_de_front2.get_nb();
686  for (int i=0;i<nb_liste2;i++)
687  {
688  mise_a_jour_voisin_front(liste_de_front2.get(i));
689  mise_a_jour_voisin_front(liste_de_front2.get(i)->get_front_voisin(0));
690  mise_a_jour_voisin_front(liste_de_front2.get(i)->get_front_voisin(1));
691  mise_a_jour_voisin_front(liste_de_front2.get(i)->get_front_voisin(2));
692  }
693 
694  for (int k=0;k<4;k++)
695  {
696  MG_NOEUD* noeud;
697  if (k==0) noeud=tet->get_noeud1();
698  if (k==1) noeud=tet->get_noeud2();
699  if (k==2) noeud=tet->get_noeud3();
700  if (k==3) noeud=tet->get_noeud4();
701  int nb_tet=noeud->get_lien_tetra()->get_nb();
702 
703  if (noeud->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_NOEUD)
704  {
705  int test=false;
706  M3D_NOEUD* mnoeud=(M3D_NOEUD*)noeud;
707  for (int i=0;i<nb_tet;i++)
708  {
709  MG_TETRA* tet=noeud->get_lien_tetra()->get(i);
710  if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
711  {
712  M3D_TETRA* mtet=(M3D_TETRA*)tet;
713  if (mtet->get_etat()==MAGIC::MAILLEURFRONTALETAT::ACTIF) test=true;
714  }
715  else test=true;
716  }
717  if (test==false)
718  {
719  mnoeud->etat_detruit();
720  lstnoeud_a_detruire.ajouter(mnoeud);
721  }
722  }
723  }
724 
725 }
726 
727 
728 
729 
730 
731 void MAILLEUR3D::detruit_element_inactif(void)
732 {
733  /* LISTE_MG_TETRA::iterator it;
734 
735  for (MG_TETRA* tet=mg_maillage->get_premier_tetra(it);tet!=NULL;tet=mg_maillage->get_suivant_tetra(it))
736  {
737  M3D_TETRA* mtet=(M3D_TETRA*)tet;
738  if (mtet->get_etat()==DETRUIT)
739  lsttet.ajouter(tet);
740  }
741  LISTE_MG_NOEUD::iterator it2;
742  for (MG_NOEUD* noeud=mg_maillage->get_premier_noeud(it2);noeud!=NULL;noeud=mg_maillage->get_suivant_noeud(it2))
743  {
744  if (noeud->get_type_entite()==IDM3D_NOEUD)
745  {
746  M3D_NOEUD* mnoeud=(M3D_NOEUD*)noeud;
747  if (mnoeud->get_etat()==DETRUIT)
748  lstnoeud.ajouter(noeud);
749  }
750  }*/
751  TPL_MAP_ENTITE<MG_TETRA*>::ITERATEUR it3;
752  for (MG_TETRA* tet=lsttet_a_detruire.get_premier(it3);tet!=NULL;tet=lsttet_a_detruire.get_suivant(it3))
753  supprimer_mg_tetra(tet);
754  TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR it4;
755  for (MG_NOEUD* noeud=lstnoeud_a_detruire.get_premier(it4);noeud!=NULL;noeud=lstnoeud_a_detruire.get_suivant(it4))
756  mg_maillage->supprimer_mg_noeudid(noeud->get_id());
757  lstnoeud_a_detruire.vide();
758  lsttet_a_detruire.vide();
759 
760 }
761 
762 
763 
764 
765 
766 void MAILLEUR3D::analyse_maillage_obtenu(double &vol,int *tab,double borne1,double borne2,double borne3)
767 {
768  vol=0.;tab[0]=0;tab[1]=0;tab[2]=0;tab[3]=0;
769  LISTE_MG_TETRA::iterator it;
770  for (MG_TETRA* tet=mg_maillage->get_premier_tetra(it);tet!=NULL;tet=mg_maillage->get_suivant_tetra(it))
771  {
772  vol=vol+metrique->calcul_volume_tetra_metrique(tet);
773  double qual=OPERATEUR::qualite_tetra(tet->get_noeud1()->get_coord(),tet->get_noeud2()->get_coord(),tet->get_noeud3()->get_coord(),tet->get_noeud4()->get_coord());
774  if (qual>=borne3) tab[3]++;
775  else if (qual>=borne2) tab[2]++;
776  else if (qual>=borne1) tab[1]++;
777  else tab[0]++;
778  }
779 }
780 
781 
782 void MAILLEUR3D::insere_contrainte_tetra(MG_VOLUME* mgvol,TPL_LISTE_ENTITE<MG_TETRA*> *lsttet)
783 {
784  std::map<long,long,std::less<long> > lstcorrespondancenoeud;
785  int nbtet=lsttet->get_nb();
786  for (int i=0;i<nbtet;i++)
787  {
788  M3D_TETRA* tet=(M3D_TETRA*)lsttet->get(i);
789  double *xyz1=tet->get_noeud1()->get_coord();
790  double *xyz2=tet->get_noeud2()->get_coord();
791  double *xyz3=tet->get_noeud3()->get_coord();
792  double *xyz4=tet->get_noeud4()->get_coord();
793  double xyz[3];
794  xyz[0]=(xyz1[0]+xyz2[0]+xyz3[0]+xyz4[0])*0.25;
795  xyz[1]=(xyz1[1]+xyz2[1]+xyz3[1]+xyz4[1])*0.25;
796  xyz[2]=(xyz1[2]+xyz2[2]+xyz3[2]+xyz4[2])*0.25;
797  TPL_MAP_ENTITE<MG_FRONT_3D*> liste_trouvee;
798  OT_VECTEUR_3D vec1(xyz,xyz1);
799  OT_VECTEUR_3D vec2(xyz,xyz2);
800  OT_VECTEUR_3D vec3(xyz,xyz3);
801  OT_VECTEUR_3D vec4(xyz,xyz4);
802  double rayonrecherche=vec1.get_longueur();
803  if (vec2.get_longueur()>rayonrecherche) rayonrecherche=vec2.get_longueur();
804  if (vec3.get_longueur()>rayonrecherche) rayonrecherche=vec3.get_longueur();
805  if (vec4.get_longueur()>rayonrecherche) rayonrecherche=vec4.get_longueur();
806  rayonrecherche=rayonrecherche*1.1;
807  ntree_de_front->rechercher(xyz[0],xyz[1],xyz[2],rayonrecherche,liste_trouvee);
808  MG_NOEUD* noeudref1=NULL;
809  if (lstcorrespondancenoeud.find(tet->get_noeud1()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
810  noeudref1=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud1()->get_nouveau_numero()]);
811  MG_NOEUD* noeudref2=NULL;
812  if (lstcorrespondancenoeud.find(tet->get_noeud2()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
813  noeudref2=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud2()->get_nouveau_numero()]);
814  MG_NOEUD* noeudref3=NULL;
815  if (lstcorrespondancenoeud.find(tet->get_noeud3()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
816  noeudref3=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud3()->get_nouveau_numero()]);
817  MG_NOEUD* noeudref4=NULL;
818  if (lstcorrespondancenoeud.find(tet->get_noeud4()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
819  noeudref4=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud4()->get_nouveau_numero()]);
820  int nbtrouve=liste_trouvee.get_nb();
821  for (int j=0;j<nbtrouve;j++)
822  {
823  if ((noeudref1!=NULL) && (noeudref2!=NULL) && (noeudref3!=NULL) && (noeudref4!=NULL) ) break;
824  MG_FRONT_3D* ft=liste_trouvee.get(j);
825  TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
826  lstnoeud.ajouter(ft->get_noeud1());
827  lstnoeud.ajouter(ft->get_noeud2());
828  lstnoeud.ajouter(ft->get_noeud3());
829  if (noeudref1==NULL)
830  {
831  int nb=lstnoeud.get_nb();
832  for (int k=0;k<nb;k++)
833  {
834  double *xyztmp=lstnoeud.get(k)->get_coord();
835  OT_VECTEUR_3D vec(xyztmp,xyz1);
836  double longueur=vec.get_longueur();
837  if (longueur<1e-6*rayonrecherche)
838  {
839  noeudref1=lstnoeud.get(k);
840  lstnoeud.supprimer(lstnoeud.get(k));
841  break;
842  }
843  }
844  }
845  if (noeudref2==NULL)
846  {
847  int nb=lstnoeud.get_nb();
848  for (int k=0;k<nb;k++)
849  {
850  double *xyztmp=lstnoeud.get(k)->get_coord();
851  OT_VECTEUR_3D vec(xyztmp,xyz2);
852  double longueur=vec.get_longueur();
853  if (longueur<1e-6*rayonrecherche)
854  {
855  noeudref2=lstnoeud.get(k);
856  lstnoeud.supprimer(lstnoeud.get(k));
857  break;
858  }
859  }
860  }
861  if (noeudref3==NULL)
862  {
863  int nb=lstnoeud.get_nb();
864  for (int k=0;k<nb;k++)
865  {
866  double *xyztmp=lstnoeud.get(k)->get_coord();
867  OT_VECTEUR_3D vec(xyztmp,xyz3);
868  double longueur=vec.get_longueur();
869  if (longueur<1e-6*rayonrecherche)
870  {
871  noeudref3=lstnoeud.get(k);
872  lstnoeud.supprimer(lstnoeud.get(k));
873  break;
874  }
875  }
876  }
877  if (noeudref4==NULL)
878  {
879  int nb=lstnoeud.get_nb();
880  for (int k=0;k<nb;k++)
881  {
882  double *xyztmp=lstnoeud.get(k)->get_coord();
883  OT_VECTEUR_3D vec(xyztmp,xyz4);
884  double longueur=vec.get_longueur();
885  if (longueur<1e-6*rayonrecherche)
886  {
887  noeudref4=lstnoeud.get(k);
888  lstnoeud.supprimer(lstnoeud.get(k));
889  break;
890  }
891  }
892  }
893  }
894  if (noeudref1==NULL)
895  {
896  noeudref1=mg_maillage->ajouter_mg_noeud(mgvol,xyz1[0],xyz1[1],xyz1[2],MAGIC::ORIGINE::IMPOSE);
897  if (tet->get_noeud1()->get_nouveau_numero()!=(-1))
898  {
899  noeudref1->change_nouveau_numero(tet->get_noeud1()->get_nouveau_numero());
900  std::pair<long,long> tmp(noeudref1->get_nouveau_numero(),noeudref1->get_id());
901  lstcorrespondancenoeud.insert(tmp);
902  }
903  }
904  if (noeudref2==NULL)
905  {
906  noeudref2=mg_maillage->ajouter_mg_noeud(mgvol,xyz2[0],xyz2[1],xyz2[2],MAGIC::ORIGINE::IMPOSE);
907  if (tet->get_noeud2()->get_nouveau_numero()!=(-1))
908  {
909  noeudref2->change_nouveau_numero(tet->get_noeud2()->get_nouveau_numero());
910  std::pair<long,long> tmp(noeudref2->get_nouveau_numero(),noeudref2->get_id());
911  lstcorrespondancenoeud.insert(tmp);
912  }
913  }
914  if (noeudref3==NULL)
915  {
916  noeudref3=mg_maillage->ajouter_mg_noeud(mgvol,xyz3[0],xyz3[1],xyz3[2],MAGIC::ORIGINE::IMPOSE);
917  if (tet->get_noeud3()->get_nouveau_numero()!=(-1))
918  {
919  noeudref3->change_nouveau_numero(tet->get_noeud3()->get_nouveau_numero());
920  std::pair<long,long> tmp(noeudref3->get_nouveau_numero(),noeudref3->get_id());
921  lstcorrespondancenoeud.insert(tmp);
922  }
923  }
924  if (noeudref4==NULL)
925  {
926  noeudref4=mg_maillage->ajouter_mg_noeud(mgvol,xyz4[0],xyz4[1],xyz4[2],MAGIC::ORIGINE::IMPOSE);
927  if (tet->get_noeud4()->get_nouveau_numero()!=(-1))
928  {
929  noeudref4->change_nouveau_numero(tet->get_noeud4()->get_nouveau_numero());
930  std::pair<long,long> tmp(noeudref4->get_nouveau_numero(),noeudref4->get_id());
931  lstcorrespondancenoeud.insert(tmp);
932  }
933  }
934  M3D_TRIANGLE* triangle1=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref1->get_id(),noeudref3->get_id(),noeudref2->get_id());
935  M3D_TRIANGLE* triangle2=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref1->get_id(),noeudref2->get_id(),noeudref4->get_id());
936  M3D_TRIANGLE* triangle3=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref2->get_id(),noeudref3->get_id(),noeudref4->get_id());
937  M3D_TRIANGLE* triangle4=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref1->get_id(),noeudref4->get_id(),noeudref3->get_id());
938  if (triangle1==NULL) triangle1=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref1,noeudref3,noeudref2,MAGIC::ORIGINE::IMPOSE);
939  if (triangle2==NULL) triangle2=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref1,noeudref2,noeudref4,MAGIC::ORIGINE::IMPOSE);
940  if (triangle3==NULL) triangle3=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref2,noeudref3,noeudref4,MAGIC::ORIGINE::IMPOSE);
941  if (triangle4==NULL) triangle4=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref1,noeudref4,noeudref3,MAGIC::ORIGINE::IMPOSE);
942  MG_TETRA* tetra=cree_tetra(mgvol,noeudref1,noeudref2,noeudref3,noeudref4,triangle1,triangle2,triangle3,triangle4,MAGIC::ORIGINE::IMPOSE);
943  tetra->change_nouveau_numero(tet->get_nouveau_numero());
944  mg_maillage->ajouter_mg_tetra(tetra);
945  triangle1->ajouter_voisin(tetra);
946  triangle2->ajouter_voisin(tetra);
947  triangle3->ajouter_voisin(tetra);
948  triangle4->ajouter_voisin(tetra);
949  MG_FRONT_3D *ftref1=NULL;
950  MG_FRONT_3D *ftref2=NULL;
951  MG_FRONT_3D *ftref3=NULL;
952  MG_FRONT_3D *ftref4=NULL;
953  if (triangle1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref1=triangle1->get_mgfront();
954  if (triangle2->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref2=triangle2->get_mgfront();
955  if (triangle3->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref3=triangle3->get_mgfront();
956  if (triangle4->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref4=triangle4->get_mgfront();
957  TPL_MAP_ENTITE<MG_FRONT_3D*> lstfront;
958  MG_FRONT_3D *ft1=NULL;
959  MG_FRONT_3D *ft2=NULL;
960  MG_FRONT_3D *ft3=NULL;
961  MG_FRONT_3D *ft4=NULL;
962  if (ftref1==NULL) ft1=mise_a_jour_front(tetra,0,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
963  else
964  {
965  lstfront.ajouter(ftref1->get_front_voisin(0));
966  lstfront.ajouter(ftref1->get_front_voisin(1));
967  lstfront.ajouter(ftref1->get_front_voisin(2));
968  supprimer_front_en_avancant_sans_delete(ftref1);
969  }
970  if (ftref2==NULL) ft2=mise_a_jour_front(tetra,1,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
971  else
972  {
973  lstfront.ajouter(ftref2->get_front_voisin(0));
974  lstfront.ajouter(ftref2->get_front_voisin(1));
975  lstfront.ajouter(ftref2->get_front_voisin(2));
976  supprimer_front_en_avancant_sans_delete(ftref2);
977  }
978  if (ftref3==NULL) ft3=mise_a_jour_front(tetra,2,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
979  else
980  {
981  lstfront.ajouter(ftref3->get_front_voisin(0));
982  lstfront.ajouter(ftref3->get_front_voisin(1));
983  lstfront.ajouter(ftref3->get_front_voisin(2));
984  supprimer_front_en_avancant_sans_delete(ftref3);
985  }
986  if (ftref4==NULL) ft4=mise_a_jour_front(tetra,3,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
987  else
988  {
989  lstfront.ajouter(ftref4->get_front_voisin(0));
990  lstfront.ajouter(ftref4->get_front_voisin(1));
991  lstfront.ajouter(ftref4->get_front_voisin(2));
992  supprimer_front_en_avancant_sans_delete(ftref4);
993  }
994  if (ftref1!=NULL) {
995  lstfront.supprimer(ftref1);
996  delete ftref1;
997  }
998  if (ftref2!=NULL) {
999  lstfront.supprimer(ftref2);
1000  delete ftref2;
1001  }
1002  if (ftref3!=NULL) {
1003  lstfront.supprimer(ftref3);
1004  delete ftref3;
1005  }
1006  if (ftref4!=NULL) {
1007  lstfront.supprimer(ftref4);
1008  delete ftref4;
1009  }
1010  if (ft1!=NULL)
1011  {
1012  mise_a_jour_voisin_front(ft1);
1013  lstfront.ajouter(ft1->get_front_voisin(0));
1014  lstfront.ajouter(ft1->get_front_voisin(1));
1015  lstfront.ajouter(ft1->get_front_voisin(2));
1016  }
1017  if (ft2!=NULL)
1018  {
1019  mise_a_jour_voisin_front(ft2);
1020  lstfront.ajouter(ft2->get_front_voisin(0));
1021  lstfront.ajouter(ft2->get_front_voisin(1));
1022  lstfront.ajouter(ft2->get_front_voisin(2));
1023  }
1024  if (ft3!=NULL)
1025  {
1026  mise_a_jour_voisin_front(ft3);
1027  lstfront.ajouter(ft3->get_front_voisin(0));
1028  lstfront.ajouter(ft3->get_front_voisin(1));
1029  lstfront.ajouter(ft3->get_front_voisin(2));
1030  }
1031  if (ft4!=NULL)
1032  {
1033  mise_a_jour_voisin_front(ft4);
1034  lstfront.ajouter(ft4->get_front_voisin(0));
1035  lstfront.ajouter(ft4->get_front_voisin(1));
1036  lstfront.ajouter(ft4->get_front_voisin(2));
1037  }
1038 
1039  for (int l=0;l<lstfront.get_nb();l++) mise_a_jour_voisin_front(lstfront.get(l));
1040 
1041  }
1042 }
1043 
1044 void MAILLEUR3D::insere_contrainte_triangle(MG_VOLUME* mgvol,TPL_LISTE_ENTITE<MG_TRIANGLE*> *lsttri)
1045 {
1046  int nbtri=lsttri->get_nb();
1047  for (int i=0;i<nbtri;i++)
1048  {
1049  M3D_TRIANGLE* tri=(M3D_TRIANGLE*)lsttri->get(i);
1050  double *xyz1=tri->get_noeud1()->get_coord();
1051  double *xyz2=tri->get_noeud2()->get_coord();
1052  double *xyz3=tri->get_noeud3()->get_coord();
1053  double xyz[3];
1054  xyz[0]=(xyz1[0]+xyz2[0]+xyz3[0])/3.;
1055  xyz[1]=(xyz1[1]+xyz2[1]+xyz3[1])/3.;
1056  xyz[2]=(xyz1[2]+xyz2[2]+xyz3[2])/3.;
1057  TPL_MAP_ENTITE<MG_FRONT_3D*> liste_trouvee;
1058  OT_VECTEUR_3D vec1(xyz,xyz1);
1059  OT_VECTEUR_3D vec2(xyz,xyz2);
1060  OT_VECTEUR_3D vec3(xyz,xyz3);
1061  double rayonrecherche=vec1.get_longueur();
1062  if (vec2.get_longueur()>rayonrecherche) rayonrecherche=vec2.get_longueur();
1063  if (vec3.get_longueur()>rayonrecherche) rayonrecherche=vec3.get_longueur();
1064  rayonrecherche=rayonrecherche*1.1;
1065  ntree_de_front->rechercher(xyz[0],xyz[2],xyz[2],rayonrecherche,liste_trouvee);
1066  MG_NOEUD* noeudref1=NULL;
1067  MG_NOEUD* noeudref2=NULL;
1068  MG_NOEUD* noeudref3=NULL;
1069  int nbtrouve=liste_trouvee.get_nb();
1070  for (int j=0;j<nbtrouve;j++)
1071  {
1072  MG_FRONT_3D* ft=liste_trouvee.get(j);
1073  TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
1074  lstnoeud.ajouter(ft->get_noeud1());
1075  lstnoeud.ajouter(ft->get_noeud2());
1076  lstnoeud.ajouter(ft->get_noeud3());
1077  int nb=lstnoeud.get_nb();
1078  for (int k=0;k<nb;k++)
1079  {
1080  double *xyztmp=lstnoeud.get(k)->get_coord();
1081  OT_VECTEUR_3D vec(xyztmp,xyz1);
1082  double longueur=vec.get_longueur();
1083  if (longueur<1e-10*rayonrecherche)
1084  {
1085  noeudref1=lstnoeud.get(k);
1086  lstnoeud.supprimer(lstnoeud.get(k));
1087  break;
1088  }
1089  }
1090  nb=lstnoeud.get_nb();
1091  for (int k=0;k<nb;k++)
1092  {
1093  double *xyztmp=lstnoeud.get(k)->get_coord();
1094  OT_VECTEUR_3D vec(xyztmp,xyz2);
1095  double longueur=vec.get_longueur();
1096  if (longueur<1e-10*rayonrecherche)
1097  {
1098  noeudref2=lstnoeud.get(k);
1099  lstnoeud.supprimer(lstnoeud.get(k));
1100  break;
1101  }
1102  }
1103  nb=lstnoeud.get_nb();
1104  for (int k=0;k<nb;k++)
1105  {
1106  double *xyztmp=lstnoeud.get(k)->get_coord();
1107  OT_VECTEUR_3D vec(xyztmp,xyz3);
1108  double longueur=vec.get_longueur();
1109  if (longueur<1e-10*rayonrecherche)
1110  {
1111  noeudref3=lstnoeud.get(k);
1112  lstnoeud.supprimer(lstnoeud.get(k));
1113  break;
1114  }
1115  }
1116 
1117  }
1118  if (noeudref1==NULL)
1119  {
1120  noeudref1=mg_maillage->ajouter_mg_noeud(mgvol,xyz1[0],xyz1[1],xyz1[2],MAGIC::ORIGINE::IMPOSE);
1121  noeudref1->change_nouveau_numero(tri->get_noeud1()->get_nouveau_numero());
1122  }
1123  if (noeudref2==NULL)
1124  {
1125  noeudref2=mg_maillage->ajouter_mg_noeud(mgvol,xyz2[0],xyz2[1],xyz2[2],MAGIC::ORIGINE::IMPOSE);
1126  noeudref2->change_nouveau_numero(tri->get_noeud2()->get_nouveau_numero());
1127  }
1128  if (noeudref3==NULL)
1129  {
1130  noeudref3=mg_maillage->ajouter_mg_noeud(mgvol,xyz3[0],xyz3[1],xyz3[2],MAGIC::ORIGINE::IMPOSE);
1131  noeudref3->change_nouveau_numero(tri->get_noeud3()->get_nouveau_numero());
1132  }
1133 
1134  MG_SEGMENT* segment1=mg_maillage->get_mg_segment(noeudref1->get_id(),noeudref2->get_id());
1135  MG_SEGMENT* segment2=mg_maillage->get_mg_segment(noeudref1->get_id(),noeudref3->get_id());
1136  MG_SEGMENT* segment3=mg_maillage->get_mg_segment(noeudref2->get_id(),noeudref3->get_id());
1137  if (segment1==NULL) segment1=cree_segment(mgvol,noeudref1,noeudref2,MAGIC::ORIGINE::IMPOSE);
1138  if (segment2==NULL) segment2=cree_segment(mgvol,noeudref1,noeudref3,MAGIC::ORIGINE::IMPOSE);
1139  if (segment3==NULL) segment3=cree_segment(mgvol,noeudref2,noeudref3,MAGIC::ORIGINE::IMPOSE);
1140  MG_TRIANGLE* nvtri=cree_triangle(mgvol,noeudref1,noeudref2,noeudref3,segment1,segment2,segment3,MAGIC::ORIGINE::IMPOSE);
1141  MG_TRIANGLE* nvtri2=cree_triangle(mgvol,noeudref1,noeudref3,noeudref2,segment1,segment2,segment3,MAGIC::ORIGINE::IMPOSE);
1142  //MG_TRIANGLE* nvtri=insere_triangle(mgvol,noeudref1,noeudref2,noeudref3,IMPOSE);
1143  //MG_TRIANGLE* nvtri2=insere_triangle(mgvol,noeudref1,noeudref3,noeudref2,IMPOSE);
1144  MG_FRONT_3D *ft=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,noeudref1,noeudref2,noeudref3,nvtri);
1145  MG_FRONT_3D *ft2=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,noeudref1,noeudref3,noeudref2,nvtri2);
1146  mise_a_jour_voisin_front(ft);
1147  mise_a_jour_voisin_front(ft2);
1148  mise_a_jour_voisin_front(ft->get_front_voisin(0));
1149  mise_a_jour_voisin_front(ft->get_front_voisin(1));
1150  mise_a_jour_voisin_front(ft->get_front_voisin(2));
1151  mise_a_jour_voisin_front(ft2->get_front_voisin(0));
1152  mise_a_jour_voisin_front(ft2->get_front_voisin(1));
1153  mise_a_jour_voisin_front(ft2->get_front_voisin(2));
1154 
1155  }
1156 }
1157 
1158 int MAILLEUR3D::supprimer_mg_tetra(MG_TETRA* mgtetra)
1159 {
1160  //MG_TETRA* mgtetra=mg_maillage->get_mg_tetra(num);
1161  if (mgtetra==NULL)
1162  {
1163  return FAIL;
1164  }
1165  MG_IDENTIFICATEUR* id=mgtetra;
1166  LISTE_ENTITE::iterator i=mg_maillage->lst_entite.find(id);
1167  mg_maillage->lst_entite.erase(i);
1168  LISTE_MG_TETRA::iterator j=mg_maillage->lst_mg_tetra.find(id->get_id());
1169  mg_maillage->lst_mg_tetra.erase(j);
1170  M3D_TRIANGLE* triangle1=(M3D_TRIANGLE*)mgtetra->get_triangle1();
1171  M3D_TRIANGLE* triangle2=(M3D_TRIANGLE*)mgtetra->get_triangle2();
1172  M3D_TRIANGLE* triangle3=(M3D_TRIANGLE*)mgtetra->get_triangle3();
1173  M3D_TRIANGLE* triangle4=(M3D_TRIANGLE*)mgtetra->get_triangle4();
1174  delete mgtetra;
1175  if (triangle1->get_nb_reference()==0)
1176  if (triangle1->get_lien_topologie()!=NULL)
1177  {
1178  if (triangle1->get_lien_topologie()->get_dimension()>2) mg_maillage->supprimer_mg_triangleid(triangle1->get_id());
1179  }
1180  else if (triangle1->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle1->get_id());
1181  if (triangle2->get_nb_reference()==0)
1182  if (triangle2->get_lien_topologie()!=NULL)
1183  {
1184  if (triangle2->get_lien_topologie()->get_dimension()>2) mg_maillage->supprimer_mg_triangleid(triangle2->get_id());
1185  }
1186  else if (triangle2->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle2->get_id());
1187  if (triangle3->get_nb_reference()==0)
1188  if (triangle3->get_lien_topologie()!=NULL)
1189  {
1190  if (triangle3->get_lien_topologie()->get_dimension()>2) mg_maillage->supprimer_mg_triangleid(triangle3->get_id());
1191  }
1192  else if (triangle3->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle3->get_id());
1193  if (triangle4->get_nb_reference()==0)
1194  if (triangle4->get_lien_topologie()!=NULL)
1195  {
1196  if (triangle4->get_lien_topologie()->get_dimension()>2) mg_maillage->supprimer_mg_triangleid(triangle4->get_id());
1197  }
1198  else if (triangle4->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle4->get_id());
1199  return OK;
1200 }
1201 
1202 
1203 
1204 
TPL_MAP_ENTITE::supprimer
virtual void supprimer(X x)
Definition: tpl_map_entite.h:69
MG_TETRA::noeud4
class MG_NOEUD * noeud4
Definition: mg_tetra.h:72
MAILLEUR3D::supprimer_mg_tetra
int supprimer_mg_tetra(MG_TETRA *mgtetra)
Definition: mailleur3d_outil.cpp:1158
MG_TETRA::noeud1
class MG_NOEUD * noeud1
Definition: mg_tetra.h:69
MG_MAILLAGE::ajouter_mg_tetra
MG_TETRA * ajouter_mg_tetra(MG_ELEMENT_TOPOLOGIQUE *topo, class MG_NOEUD *mgnoeud1, class MG_NOEUD *mgnoeud2, class MG_NOEUD *mgnoeud3, class MG_NOEUD *mgnoeud4, int origine, unsigned long num=0)
Definition: mg_maillage.cpp:1158
TPL_MAP_ENTITE::get_premier
virtual X get_premier(ITERATEUR &it)
Definition: tpl_map_entite.h:112
MG_TRIANGLE::get_segment1
virtual MG_SEGMENT * get_segment1(void)
Definition: mg_triangle.cpp:142
MAILLEUR3D::calcule_volume
virtual double calcule_volume(MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3, MG_NOEUD *noeud4)
Definition: mailleur3d_outil.cpp:361
MG_SEGMENT
Definition: mg_segment.h:38
OT_MATRICE_3D::get_determinant
double get_determinant()
Definition: ot_mathematique.cpp:735
MAILLEUR3D::ajouter_front_courant
virtual MG_FRONT_3D * ajouter_front_courant(int numero_front, MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3, MG_TRIANGLE *triangle)
Definition: mailleur3d.cpp:267
M3D_NOEUD
Definition: m3d_noeud.h:32
MAGIC::TYPE_ENTITE::IDM3D_TETRA
@ IDM3D_TETRA
Definition: mg_definition.h:69
MG_TRIANGLE::get_longueur
virtual double get_longueur(void)
Definition: mg_triangle.cpp:172
tpl_fonctions_generiques.h
MG_TETRA::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_tetra.cpp:148
gestionversion.h
MAILLEUR3D::mise_a_jour_voisin_front
virtual void mise_a_jour_voisin_front(MG_FRONT_3D *ft)
Definition: mailleur3d_front.cpp:710
MG_FRONT_3D
Definition: CAD4FE_mg_front_3d.h:42
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
TPL_MAP_ENTITE
Definition: tpl_map_entite.h:35
FAIL
const int FAIL
Definition: mg_definition.h:39
MG_TETRA::noeud3
class MG_NOEUD * noeud3
Definition: mg_tetra.h:71
MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE
@ PRIORITAIRE
Definition: mg_definition.h:114
MG_SEGMENT::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_segment.cpp:113
MAILLEUR3D::inter_tetra_triangle
virtual int inter_tetra_triangle(MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3, MG_NOEUD *noeud4, MG_NOEUD *noeud5, MG_NOEUD *noeud6, MG_NOEUD *noeud7)
Definition: mailleur3d_intersection.cpp:36
MG_NOEUD::get_z
virtual double get_z(void)
Definition: mg_noeud.cpp:87
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
M3D_TETRA::get_volume
virtual double get_volume(void)
Definition: m3d_tetra.cpp:77
MAGIC::MAILLEURFRONTALETAT::NONFORCE
@ NONFORCE
Definition: mg_definition.h:114
MAILLEUR3D::supprimer_front_en_reculant
virtual void supprimer_front_en_reculant(MG_FRONT_3D *ft)
Definition: mailleur3d.cpp:363
M3D_TETRA::get_etat
virtual int get_etat(void)
Definition: m3d_tetra.cpp:65
MG_MAILLAGE::get_premier_tetra
MG_TETRA * get_premier_tetra(LISTE_MG_TETRA::iterator &it)
Definition: mg_maillage.cpp:1374
MAGIC::MAILLEURFRONTALETAT::ACTIF
@ ACTIF
Definition: mg_definition.h:109
M3D_TRIANGLE::ajouter_voisin
virtual int ajouter_voisin(class MG_TETRA *tet)
Definition: m3d_triangle.cpp:84
MG_TETRA::triangle4
class MG_TRIANGLE * triangle4
Definition: mg_tetra.h:77
MAILLEUR3D::detruit_tetra
virtual void detruit_tetra(MG_TRIANGLE *tri)
Definition: mailleur3d_outil.cpp:572
M3D_TRIANGLE
Definition: m3d_triangle.h:31
m3d_triangle.h
MAILLEUR3D::insere_contrainte_tetra
virtual void insere_contrainte_tetra(MG_VOLUME *mgvol, TPL_LISTE_ENTITE< MG_TETRA * > *lsttet)
Definition: mailleur3d_outil.cpp:782
MG_TRIANGLE::get_segment2
virtual MG_SEGMENT * get_segment2(void)
Definition: mg_triangle.cpp:147
M3D_TRIANGLE::get_mgfront
virtual class MG_FRONT_3D * get_mgfront(void)
Definition: m3d_triangle.cpp:78
MAGIC::MAILLEURFRONTALETAT::PASTROUVE
@ PASTROUVE
Definition: mg_definition.h:106
MG_SEGMENT::noeud2
class MG_NOEUD * noeud2
Definition: mg_segment.h:74
M3D_TRIANGLE::get_frontiere
virtual int get_frontiere(void)
Definition: m3d_triangle.cpp:160
MG_ELEMENT_TOPOLOGIQUE::get_dimension
virtual int get_dimension(void)=0
MAILLEUR3D::mg_maillage
MG_MAILLAGE * mg_maillage
Definition: mailleur3d.h:167
OK
const int OK
Definition: mg_definition.h:38
MG_TRIANGLE
Definition: mg_triangle.h:38
MG_VOLUME
Definition: mg_volume.h:33
OT_VECTEUR_3D::get_x
virtual double get_x(void) const
Definition: ot_mathematique.cpp:417
MG_TRIANGLE::noeud3
class MG_NOEUD * noeud3
Definition: mg_triangle.h:76
MG_TRIANGLE::get_segment3
virtual MG_SEGMENT * get_segment3(void)
Definition: mg_triangle.cpp:152
MAILLEUR::pas
int pas
Definition: mailleur.h:56
MG_TETRA
Definition: mg_tetra.h:37
MG_FRONT_3D::get_noeud3
MG_NOEUD * get_noeud3(void)
Definition: mg_front_3D.cpp:68
MG_TETRA::triangle1
class MG_TRIANGLE * triangle1
Definition: mg_tetra.h:74
FCT_TAILLE::valide_parametre
virtual int valide_parametre(double *param)=0
MG_TETRA::triangle3
class MG_TRIANGLE * triangle3
Definition: mg_tetra.h:76
MAILLEUR3D::cree_segment
virtual class MG_SEGMENT * cree_segment(class MG_ELEMENT_TOPOLOGIQUE *mgvol, MG_NOEUD *noeud1, MG_NOEUD *noeud2, int origine)
Definition: mailleur3d_outil.cpp:353
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
MG_FRONT_3D::get_noeud2
MG_NOEUD * get_noeud2(void)
Definition: mg_front_3D.cpp:63
OT_REFERENCE::get_nb_reference
int get_nb_reference(void)
Definition: ot_reference.cpp:50
MG_NOEUD::get_type_entite
virtual int get_type_entite()
Definition: mg_noeud.cpp:72
MG_ELEMENT_MAILLAGE::get_nouveau_numero
virtual int get_nouveau_numero(void)
Definition: mg_element_maillage.cpp:81
FCT_TAILLE::calcul_distance_metrique
virtual double calcul_distance_metrique(class MG_SEGMENT *seg, int pas=32)
Definition: fct_taille.cpp:318
MAILLEUR3D::metrique
FCT_TAILLE * metrique
Definition: mailleur3d.h:170
MAILLEUR3D::genere_noeud
virtual int genere_noeud(MG_VOLUME *mgvol, MG_FRONT_3D *ft, TPL_MAP_ENTITE< MG_NOEUD * > &liste_noeud, std::vector< class CAS_FRONT * > &liste_cas)
Definition: mailleur3d_outil.cpp:414
MG_TETRA::noeud2
class MG_NOEUD * noeud2
Definition: mg_tetra.h:70
MG_TETRA::triangle2
class MG_TRIANGLE * triangle2
Definition: mg_tetra.h:75
MAILLEUR3D::mise_a_jour_front
virtual class MG_FRONT_3D * mise_a_jour_front(MG_TETRA *tet, int cote, int numfront=MAGIC::MAILLEURFRONTALETAT::ATTENTE)
Definition: mailleur3d_front.cpp:697
MAILLEUR3D::insere_triangle
virtual class MG_TRIANGLE * insere_triangle(class MG_ELEMENT_TOPOLOGIQUE *mgvol, MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3, int origine)
Definition: mailleur3d_outil.cpp:307
MG_SEGMENT::change_distance_metrique
virtual void change_distance_metrique(double val)
Definition: mg_segment.cpp:263
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_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_segment.cpp:108
EPS_BASE_RELATIVE
#define EPS_BASE_RELATIVE
Definition: mailleur3d.h:48
M3D_TRIANGLE::get_etat_front
virtual int get_etat_front(void)
Definition: m3d_triangle.cpp:67
MG_MAILLAGE::supprimer_mg_triangleid
int supprimer_mg_triangleid(unsigned long num)
Definition: mg_maillage.cpp:820
OPERATEUR::egal
static int egal(double a, double b, double eps)
Definition: ot_mathematique.cpp:1629
TPL_MAP_ENTITE::get_nb
virtual int get_nb(void)
Definition: tpl_map_entite.h:83
MG_NOEUD
Definition: mg_noeud.h:41
OT_MATRICE_3D
Definition: ot_mathematique.h:160
FCT_TAILLE::ajuste_distance_metrique
virtual int ajuste_distance_metrique(double *xyz1, double *xyz2, double longueur_desiree, int pas=32)
Definition: fct_taille.cpp:326
MAGIC::ORIGINE::IMPOSE
@ IMPOSE
Definition: mg_definition.h:79
M3D_NOEUD::etat_detruit
virtual void etat_detruit(void)
Definition: m3d_noeud.cpp:60
TPL_OCTREE::rechercher
virtual void rechercher(BOITE_3D &boite, TPL_MAP_ENTITE< A > &liste_entite_trouve, TPL_CELLULE_OCTREE< A, CONDITION > *cellule)
Definition: tpl_octree.h:606
M3D_TETRA
Definition: m3d_tetra.h:31
MAILLEUR3D::lsttet_a_detruire
TPL_MAP_ENTITE< MG_TETRA * > lsttet_a_detruire
Definition: mailleur3d.h:162
MG_NOEUD::get_coord
virtual double * get_coord(void)
Definition: mg_noeud.cpp:92
MG_TRIANGLE::noeud2
class MG_NOEUD * noeud2
Definition: mg_triangle.h:75
MG_TRIANGLE::segment3
class MG_SEGMENT * segment3
Definition: mg_triangle.h:80
MG_TETRA::get_triangle1
virtual MG_TRIANGLE * get_triangle1(void)
Definition: mg_tetra.cpp:163
MAILLEUR3D::ntree_de_front
TPL_NTREE_FCT< MG_FRONT_3D *, FCT_TAILLE > * ntree_de_front
Definition: mailleur3d.h:179
MG_MAILLAGE::lst_mg_tetra
LISTE_MG_TETRA lst_mg_tetra
Definition: mg_maillage.h:205
MG_ELEMENT_MAILLAGE::change_nouveau_numero
virtual void change_nouveau_numero(int num)
Definition: mg_element_maillage.cpp:76
MAILLEUR3D::angle_front
virtual double angle_front(MG_FRONT_3D *ft1, MG_FRONT_3D *ft2)
Definition: mailleur3d_outil.cpp:47
MAILLEUR3D::detruit_element_inactif
virtual void detruit_element_inactif(void)
Definition: mailleur3d_outil.cpp:731
MG_TRIANGLE::segment1
class MG_SEGMENT * segment1
Definition: mg_triangle.h:78
TPL_LISTE_ENTITE::get_nb
virtual int get_nb(void)
Definition: tpl_liste_entite.h:67
OT_VECTEUR_3D::norme
virtual void norme(void)
Definition: ot_mathematique.cpp:494
MG_MAILLAGE::lst_entite
LISTE_ENTITE lst_entite
Definition: mg_maillage.h:200
FCT_TAILLE::calcul_volume_tetra_metrique
virtual double calcul_volume_tetra_metrique(class MG_TETRA *tet)
Definition: fct_taille.cpp:377
MAILLEUR3D::cree_triangle
virtual class MG_TRIANGLE * cree_triangle(class MG_ELEMENT_TOPOLOGIQUE *mgvol, MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3, MG_SEGMENT *segment1, MG_SEGMENT *segment2, MG_SEGMENT *segment3, int origine)
Definition: mailleur3d_outil.cpp:344
MG_IDENTIFICATEUR::id
unsigned long id
Definition: mg_identificateur.h:49
MG_TRIANGLE::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_triangle.cpp:131
MG_NOEUD::get_lien_tetra
TPL_LISTE_ENTITE< class MG_TETRA * > * get_lien_tetra(void)
Definition: mg_noeud.cpp:175
MAILLEUR3D::insere_segment
virtual class MG_SEGMENT * insere_segment(class MG_ELEMENT_TOPOLOGIQUE *mgvol, MG_NOEUD *noeud1, MG_NOEUD *noeud2, int origine)
Definition: mailleur3d_outil.cpp:324
TPL_LISTE_ENTITE::get
virtual X get(int num)
Definition: tpl_liste_entite.h:72
MG_TETRA::get_triangle2
virtual MG_TRIANGLE * get_triangle2(void)
Definition: mg_tetra.cpp:168
ot_mathematique.h
m3d_noeud.h
MG_FRONT_3D::get_front_voisin
MG_FRONT_3D * get_front_voisin(int num)
Definition: mg_front_3D.cpp:78
OPERATEUR::qualite_tetra
static double qualite_tetra(double *noeud1, double *noeud2, double *noeud3, double *noeud4)
Definition: ot_mathematique.cpp:1673
OT_VECTEUR_3D::get_y
virtual double get_y(void) const
Definition: ot_mathematique.cpp:423
MAILLEUR3D::cree_tetra
virtual class MG_TETRA * cree_tetra(class MG_ELEMENT_TOPOLOGIQUE *mgvol, MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3, MG_NOEUD *noeud4, MG_TRIANGLE *triangle1, MG_TRIANGLE *triangle2, MG_TRIANGLE *triangle3, MG_TRIANGLE *triangle4, int origine)
Definition: mailleur3d_outil.cpp:336
MG_MAILLAGE::get_mg_noeudid
MG_NOEUD * get_mg_noeudid(unsigned long num)
Definition: mg_maillage.cpp:451
MG_MAILLAGE::get_mg_tetra
MG_TETRA * get_mg_tetra(unsigned int num)
Definition: mg_maillage.cpp:1213
MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF
@ FRONT_ACTIF
Definition: mg_definition.h:109
MG_FRONT_3D::incremente_ifail
void incremente_ifail(void)
Definition: mg_front_3D.cpp:108
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_TRIANGLE::get_type_entite
virtual int get_type_entite(void)
Definition: mg_triangle.cpp:119
OT_VECTEUR_3D
Definition: ot_mathematique.h:94
TPL_MAP_ENTITE::ajouter
virtual void ajouter(X x)
Definition: tpl_map_entite.h:55
m3d_tetra.h
MG_SEGMENT::longueur
double longueur
Definition: mg_segment.h:75
M3D_TRIANGLE::supprimer_voisin
virtual int supprimer_voisin(class MG_TETRA *tet)
Definition: m3d_triangle.cpp:102
MG_FRONT_3D::get_triangle
MG_TRIANGLE * get_triangle(void)
Definition: mg_front_3D.cpp:73
M3D_TRIANGLE::get_voisin
virtual class MG_TETRA * get_voisin(int num)
Definition: m3d_triangle.cpp:130
MG_TRIANGLE::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_triangle.cpp:126
MAILLEUR3D::calcul_distance_metrique_segment
double calcul_distance_metrique_segment(MG_SEGMENT *seg, int pas)
Definition: mailleur3d_outil.cpp:401
MG_TETRA::get_noeud4
virtual MG_NOEUD * get_noeud4(void)
Definition: mg_tetra.cpp:158
MG_MAILLAGE::get_mg_triangle
MG_TRIANGLE * get_mg_triangle(unsigned int num)
Definition: mg_maillage.cpp:784
mailleur3d.h
MAILLEUR3D::evaluer_distance_noeud_triangle
virtual double evaluer_distance_noeud_triangle(double x, double y, double z, MG_TRIANGLE *tri)
Definition: mailleur3d_outil.cpp:537
sqrt
double2 sqrt(double2 &val)
Definition: ot_doubleprecision.cpp:345
ot_boite_3d.h
MG_MAILLAGE::supprimer_mg_noeudid
int supprimer_mg_noeudid(unsigned long num)
Definition: mg_maillage.cpp:482
MG_SEGMENT::get_distance_metrique
virtual bool get_distance_metrique(double *l)
Definition: mg_segment.cpp:257
MG_ELEMENT_MAILLAGE::get_lien_topologie
MG_ELEMENT_TOPOLOGIQUE * get_lien_topologie(void)
Definition: mg_element_maillage.cpp:51
MG_FRONT_3D::get_ifail
int get_ifail(void)
Definition: mg_front_3D.cpp:103
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
MAGIC::MAILLEURFRONTALETAT::MULTIEXISTE
@ MULTIEXISTE
Definition: mg_definition.h:114
MAILLEUR3D::insere_contrainte_triangle
virtual void insere_contrainte_triangle(MG_VOLUME *mgvol, TPL_LISTE_ENTITE< MG_TRIANGLE * > *lsttri)
Definition: mailleur3d_outil.cpp:1044
OT_VECTEUR_3D::get_z
virtual double get_z(void) const
Definition: ot_mathematique.cpp:429
OT_VECTEUR_3D::diff
virtual double diff(void)
Definition: ot_mathematique.cpp:656
OT_VECTEUR_3D::get_longueur
virtual double get_longueur(void) const
Definition: ot_mathematique.cpp:483
MG_TETRA::get_type_entite
virtual int get_type_entite(void)
Definition: mg_tetra.cpp:134
TPL_LISTE_ENTITE
Definition: tpl_liste_entite.h:32
MG_TRIANGLE::noeud1
class MG_NOEUD * noeud1
Definition: mg_triangle.h:74
MAILLEUR3D::analyse_maillage_obtenu
virtual void analyse_maillage_obtenu(double &vol, int *tab, double borne1=0.1, double borne2=0.2, double borne3=0.5)
Definition: mailleur3d_outil.cpp:766
res
#define res(i, j)
MG_TETRA::get_triangle4
virtual MG_TRIANGLE * get_triangle4(void)
Definition: mg_tetra.cpp:178
MG_SEGMENT::noeud1
class MG_NOEUD * noeud1
Definition: mg_segment.h:73
MG_TRIANGLE::segment2
class MG_SEGMENT * segment2
Definition: mg_triangle.h:79
MAILLEUR3D::calcule_longueur_caracteristique
virtual double calcule_longueur_caracteristique(MG_NOEUD *noeud1, MG_NOEUD *noeud2, MG_NOEUD *noeud3=NULL, MG_NOEUD *noeud4=NULL)
Definition: mailleur3d_outil.cpp:375
TPL_MAP_ENTITE::get_suivant
virtual X get_suivant(ITERATEUR &it)
Definition: tpl_map_entite.h:120
mailleur3d_front.h
MG_IDENTIFICATEUR
Definition: mg_identificateur.h:34
M3D_TETRA::etat_detruit
virtual void etat_detruit(void)
Definition: m3d_tetra.cpp:55
MAILLEUR::priorite_metrique
double priorite_metrique
Definition: mailleur.h:55
MAGIC::ORIGINE::MAILLEUR_AUTO
@ MAILLEUR_AUTO
Definition: mg_definition.h:79
MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE
@ IDM3D_TRIANGLE
Definition: mg_definition.h:69
TPL_MAP_ENTITE::vide
virtual void vide(void)
Definition: tpl_map_entite.h:106
MAGIC::MAILLEURFRONTALETAT::CREATION
@ CREATION
Definition: mg_definition.h:114
MAGIC::MAILLEURFRONTALETAT::EXISTE
@ EXISTE
Definition: mg_definition.h:114
MG_TETRA::get_triangle3
virtual MG_TRIANGLE * get_triangle3(void)
Definition: mg_tetra.cpp:173
MAGIC::TYPE_ENTITE::IDM3D_NOEUD
@ IDM3D_NOEUD
Definition: mg_definition.h:69
MAILLEUR3D::lstnoeud_a_detruire
TPL_MAP_ENTITE< MG_NOEUD * > lstnoeud_a_detruire
Definition: mailleur3d.h:163
MAILLEUR3D::supprimer_front_en_avancant_sans_delete
virtual void supprimer_front_en_avancant_sans_delete(MG_FRONT_3D *ft)
Definition: mailleur3d.cpp:342
MG_FRONT_3D::get_noeud1
MG_NOEUD * get_noeud1(void)
Definition: mg_front_3D.cpp:58
MAILLEUR3D::insere_tetra
virtual class MG_TETRA * insere_tetra(class MG_ELEMENT_TOPOLOGIQUE *mgvol, class MG_FRONT_3D *ft, MG_NOEUD *noeud4, int type, TPL_MAP_ENTITE< class MG_TRIANGLE * > &liste_intersection)
Definition: mailleur3d_outil.cpp:147
MAGIC::MAILLEURFRONTALETAT::GENERATION_NOEUD
@ GENERATION_NOEUD
Definition: mg_definition.h:114
MG_NOEUD::get_y
virtual double get_y(void)
Definition: mg_noeud.cpp:82
mat
#define mat(i, j)
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