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

File Contents

# User Rev Content
1 francois 120 //---------------------------------------------------------------------------
2    
3     #include "gestionversion.h"
4     #include <math.h>
5     #include "mailleur_bloc.h"
6     #include "mg_gestionnaire.h"
7     #include "mailleur3d.h"
8     #include "mailleur0d.h"
9     #include "mailleur1d.h"
10     #include "mailleur2d.h"
11     #include "ot_mathematique.h"
12 francois 174 #include "mg_geometrie_outils.h"
13 francois 149
14 francois 355
15 francois 357
16 francois 120 //---------------------------------------------------------------------------
17     #pragma package(smart_init)
18    
19    
20    
21    
22    
23 francois 494 MAILLEUR_BLOC::MAILLEUR_BLOC(class MG_GESTIONNAIRE* gentier,MG_GESTIONNAIRE* gbloc,int numgeoentier,int numgeobloc,class FCT_TAILLE* fct_taille,bool save):MAILLEUR(save),gestentier(gentier),gestbloc(gbloc),carte(fct_taille)
24 francois 120 {
25 francois 433 if (numgeoentier==0) geoentier=gestentier->get_mg_geometrie(numgeoentier);
26     else geoentier=gestentier->get_mg_geometrieid(numgeoentier);
27     if (numgeobloc==0) geobloc=gestbloc->get_mg_geometrie(numgeobloc);
28     else geobloc=gestbloc->get_mg_geometrieid(numgeobloc);
29 francois 120 }
30    
31     MAILLEUR_BLOC::~MAILLEUR_BLOC()
32     {
33     delete octreeentier;
34     delete octreebloc;
35 francois 174 /*int nbface=maientier->get_mg_geometrie()->get_nb_mg_face();
36 francois 124 for (int i=0;i<nbface;i++) delete quadentier[i];
37     delete [] quadentier;
38     nbface=maibloc->get_mg_geometrie()->get_nb_mg_face();
39     for (int i=0;i<nbface;i++) delete quadbloc[i];
40     delete [] quadbloc;
41     int nbseg=lstsegfrontentier.get_nb();
42     for (int i=0;i<nbseg;i++) delete lstsegfrontentier.get(i);
43     nbseg=lstsegfrontbloc.get_nb();
44 francois 174 for (int i=0;i<nbseg;i++) delete lstsegfrontbloc.get(i);*/
45 francois 124
46 francois 120 }
47    
48    
49 francois 210 void MAILLEUR_BLOC::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
50 francois 120 {
51 francois 123 maille(20);
52     }
53    
54     void MAILLEUR_BLOC::maille(int etape)
55     {
56 francois 120 //maillage 1d temporaire pour fonctionnement et initialisation
57 francois 124 //maitemp=new MG_MAILLAGE(geobloc);
58 francois 120 maibloc=new MG_MAILLAGE(geobloc);
59     maientier=new MG_MAILLAGE(geoentier);
60 francois 124 //gestbloc->ajouter_mg_maillage(maitemp);
61 francois 120 gestbloc->ajouter_mg_maillage(maibloc);
62     gestentier->ajouter_mg_maillage(maientier);
63 francois 124 //MAILLEUR0D m0d(maitemp,geobloc);
64     //m0d.maille();
65     //MAILLEUR1D m1d(maitemp,geobloc,NULL,carte);
66     //m1d.maille();
67     //cree_octree(maitemp,&octreebloc);
68 francois 120 // etape 1 maillage 0d du modele entier
69 francois 272 affiche((char*)" MAILLAGE 0D du modele entier");
70 francois 120 MAILLEUR0D m0d_entier(maientier,geoentier);
71     m0d_entier.maille();
72 francois 123 if (etape<2) return;
73 francois 120 // etape 2 transfert noeud vers bloc
74     //int nbaretebloc=geobloc->get_nb_mg_arete();
75     //LISTE_NOEUD_ADD_ARETE *lst_noeuds_bloc=new LISTE_NOEUD_ADD_ARETE[nbaretebloc];
76     int nbnoeudentier=maientier->get_nb_mg_noeud();
77     for (int i=0;i<nbnoeudentier;i++)
78     {
79     MG_NOEUD* noeud=maientier->get_mg_noeud(i);
80     double *xyz=noeud->get_coord();
81     MG_SOMMET* som=verif_noeud_sur_sommet(xyz, geobloc);
82     if (som!=NULL)
83     {
84 francois 791 MG_NOEUD *nvnoeud=new MG_NOEUD(som, xyz[0],xyz[1],xyz[2], MAGIC::ORIGINE::IMPOSE);
85 francois 120 maibloc->ajouter_mg_noeud(nvnoeud);
86 francois 124 //octreebloc->inserer(nvnoeud);
87 francois 120 }
88     /* else
89     {
90     int num;
91     double t;
92     MG_ARETE* are=verif_noeud_sur_arete(xyz, geobloc, &num,&t);
93     if (are!=NULL)
94     {
95     MG_NOEUD_ADDITIONNEL_ARETE noeud_add;
96     noeud_add.noeud=noeud;
97     noeud_add.t=t;
98     std::pair<double,MG_NOEUD_ADDITIONNEL_ARETE> tmp(t,noeud_add);
99     lst_noeuds_bloc[num].insert(tmp);
100     }
101     }*/
102    
103    
104     }
105 francois 123 if (etape<3) return;
106 francois 120 // etape 3 maillage 0d du modele bloc
107 francois 272 affiche((char*)" MAILLAGE 0D du modele bloc");
108 francois 120 int nbnoeudblocavantm0d=maibloc->get_nb_mg_noeud();
109     MAILLEUR0D m0d_bloc(maibloc,geobloc);
110     m0d_bloc.adapte();
111 francois 123 if (etape<4) return;
112 francois 120 // etape 4 transfert noeud vers entier
113     int nbnouveaunoeudbloc=maibloc->get_nb_mg_noeud()-nbnoeudblocavantm0d;
114     int nbareteentier=geoentier->get_nb_mg_arete();
115     LISTE_NOEUD_ADD_ARETE *lst_noeuds_entier=new LISTE_NOEUD_ADD_ARETE[nbareteentier];
116     for (int i=0;i<nbnouveaunoeudbloc;i++)
117     {
118     MG_NOEUD *noeud=maibloc->get_mg_noeud(i+nbnoeudblocavantm0d);
119 francois 124 // octreebloc->inserer(noeud);
120 francois 120 double *xyz=noeud->get_coord();
121     int num;double t;
122     MG_ARETE* are=verif_noeud_sur_arete(xyz, geoentier, &num,&t);
123     if (are!=NULL)
124     {
125     MG_NOEUD_ADDITIONNEL_ARETE noeud_add;
126     noeud_add.noeud=noeud;
127     noeud_add.t=t;
128 couturad 951 std::pair<double,MG_NOEUD_ADDITIONNEL_ARETE > tmp(t,noeud_add);
129 francois 120 lst_noeuds_entier[num].insert(tmp);
130     }
131     }
132 francois 123 if (etape<5) return;
133 francois 120 // etape 5 Maillage 1D de entier
134 francois 272 affiche((char*)" MAILLAGE 1D du modele entier");
135 francois 120 for (int i=0;i<nbareteentier;i++)
136     {
137     MG_ARETE* are=geoentier->get_mg_arete(i);
138     int nbnoeudcontraint=lst_noeuds_entier[i].size();
139     MG_NOEUD* noeuddepart;
140     int numsom=are->get_cosommet1()->get_sommet()->get_lien_maillage()->get_nb();
141     for (int j=0;j<numsom;j++)
142     if (maientier->get_mg_noeudid(are->get_cosommet1()->get_sommet()->get_lien_maillage()->get(j)->get_id())!=NULL) noeuddepart=(MG_NOEUD*)are->get_cosommet1()->get_sommet()->get_lien_maillage()->get(j);
143     MG_NOEUD* noeudarrivee;
144     numsom=are->get_cosommet2()->get_sommet()->get_lien_maillage()->get_nb();
145     for (int j=0;j<numsom;j++)
146     if (maientier->get_mg_noeudid(are->get_cosommet2()->get_sommet()->get_lien_maillage()->get(j)->get_id())!=NULL) noeudarrivee=(MG_NOEUD*)are->get_cosommet2()->get_sommet()->get_lien_maillage()->get(j);
147     MG_NOEUD* navant;
148     double tavant;
149     IT_LISTE_NOEUD_ADD_ARETE it=lst_noeuds_entier[i].begin();
150     for (int j=0;j<nbnoeudcontraint+1;j++)
151     {
152     MG_NOEUD* n1,*n2;
153     double t1,t2;
154     if (j==0) {n1=noeuddepart;t1=are->get_tmin();} else {n1=navant;t1=tavant;}
155     if (j==nbnoeudcontraint) {n2=noeudarrivee;t2=are->get_tmax();}
156     else
157     {
158     double *xyz=(*it).second.noeud->get_coord();
159 francois 791 n2=new MG_NOEUD(are, xyz[0],xyz[1],xyz[2], MAGIC::ORIGINE::IMPOSE);
160 francois 120 maientier->ajouter_mg_noeud(n2);
161     t2=(*it).second.t;
162     it++;
163     }
164 francois 446 MAILLEUR1D m1d(maientier, geoentier, carte,are);
165 francois 532 m1d.change_pas_integration(pas);
166 francois 120 m1d.maille(are,t1,n1,t2,n2);
167     tavant=t2;
168     navant=n2;
169     }
170     }
171 francois 124 delete [] lst_noeuds_entier;
172     cree_octree(maientier,&octreeentier);
173     cree_octree(octreeentier,&octreebloc);
174 francois 174 //cree_quadtree(maientier,quadentier,&lstsegfrontentier);
175 francois 146 int nbnoeudtmp=maientier->get_nb_mg_noeud();
176 francois 120 for (int i=0;i<nbnoeudtmp;i++)
177     octreeentier->inserer(maientier->get_mg_noeud(i));
178 francois 146 nbnoeudtmp=maibloc->get_nb_mg_noeud();
179 francois 124 for (int i=0;i<nbnoeudtmp;i++)
180     octreebloc->inserer(maibloc->get_mg_noeud(i));
181 francois 146 if (etape<6) return;
182 francois 120 //etape 6 transfert des segments vers le maillage bloc
183     //int nbfacebloc=geobloc->get_nb_mg_face();
184     //LISTE_SEGMENT_ADD_FACE *lstsegmentbloc=new LISTE_SEGMENT_ADD_FACE[nbfacebloc];
185     int nbsegment=maientier->get_nb_mg_segment();
186     for (int i=0;i<nbsegment;i++)
187     {
188     MG_SEGMENT* seg=maientier->get_mg_segment(i);
189     MG_NOEUD* noeud1=seg->get_noeud1();
190     MG_NOEUD* noeud2=seg->get_noeud2();
191     int dim1;
192     int dim2;
193     MG_NOEUD* n1=chercher(noeud1->get_coord(),*octreebloc);
194     MG_NOEUD* n2=chercher(noeud2->get_coord(),*octreebloc);
195     MG_ARETE* are1ref;
196     MG_FACE* face1ref;
197     MG_ARETE* are2ref;
198     MG_FACE* face2ref;
199     int num1,num2;
200     double t1,t2;
201     if (n1==NULL)
202     {
203     are1ref=verif_noeud_sur_arete(noeud1->get_coord(),geobloc,&num1,&t1);
204 francois 355 if (are1ref==NULL) dim1=2; else dim1=1;
205     }
206 francois 120 else
207     {
208     dim1=n1->get_lien_topologie()->get_dimension();
209     if (dim1==1) are1ref=(MG_ARETE*)n1->get_lien_topologie();
210     }
211     if (n2==NULL)
212     {
213     are2ref=verif_noeud_sur_arete(noeud2->get_coord(),geobloc,&num2,&t2);
214 francois 355 if (are2ref==NULL) dim2=2; else dim2=1;
215 francois 120 }
216     else
217     {
218     dim2=n2->get_lien_topologie()->get_dimension();
219     if (dim2==1) are2ref=(MG_ARETE*)n2->get_lien_topologie();
220     }
221 francois 355 if ((dim1==1) || (dim2==1))
222 francois 120 {
223 francois 355 if (dim1>1) continue;
224     if (dim2>1) continue;
225 francois 120 MG_ARETE* ref;
226     if (dim1==1) ref=are1ref; else ref=are2ref;
227     if (n1==NULL)
228     {
229 francois 791 n1=new MG_NOEUD(ref,noeud1->get_coord()[0],noeud1->get_coord()[1],noeud1->get_coord()[2], MAGIC::ORIGINE::IMPOSE);
230 francois 120 maibloc->ajouter_mg_noeud(n1);
231     octreebloc->inserer(n1);
232     }
233     if (n2==NULL)
234     {
235 francois 791 n2=new MG_NOEUD(ref,noeud2->get_coord()[0],noeud2->get_coord()[1],noeud2->get_coord()[2], MAGIC::ORIGINE::IMPOSE);
236 francois 120 maibloc->ajouter_mg_noeud(n2);
237     octreebloc->inserer(n2);
238     }
239 francois 357 double *xyz1=n1->get_coord();
240     double *xyz2=n2->get_coord();
241     OT_VECTEUR_3D vec1(xyz1,xyz2);
242     double t;
243     ref->inverser(t,xyz1);
244     double dxyz[3];
245     ref->deriver(t,dxyz);
246     OT_VECTEUR_3D vec2(dxyz[0],dxyz[1],dxyz[2]);
247     vec1.norme();
248     vec2.norme();
249     double ps=vec1*vec2;
250     MG_SEGMENT *nvsegment;
251 francois 791 if (ps>0) nvsegment=new MG_SEGMENT(ref,n1,n2,MAGIC::ORIGINE::IMPOSE);
252     else nvsegment=new MG_SEGMENT(ref,n2,n1,MAGIC::ORIGINE::IMPOSE);
253 francois 357 maibloc->ajouter_mg_segment(nvsegment);
254 francois 120 }
255 francois 355 else if ((dim1==0) && (dim2==0))
256 francois 120 {
257 francois 355 MG_ARETE* ref=NULL;
258     MG_SOMMET* som1=(MG_SOMMET*)n1->get_lien_topologie();
259     MG_SOMMET* som2=(MG_SOMMET*)n2->get_lien_topologie();
260     int nb_are=geobloc->get_nb_mg_arete();
261     for ( int i=0 ; i < nb_are ; i++)
262     {
263     MG_ARETE *arete=geobloc->get_mg_arete(i);
264     if ((arete->get_cosommet1()->get_sommet()==som1) && (arete->get_cosommet2()->get_sommet()==som2)) ref=arete;
265     if ((arete->get_cosommet1()->get_sommet()==som2) && (arete->get_cosommet2()->get_sommet()==som1)) ref=arete;
266     }
267     if (ref!=NULL)
268     {
269 francois 357 double *xyz1=n1->get_coord();
270     double *xyz2=n2->get_coord();
271     OT_VECTEUR_3D vec1(xyz1,xyz2);
272     double t;
273     ref->inverser(t,xyz1);
274     double dxyz[3];
275     ref->deriver(t,dxyz);
276     OT_VECTEUR_3D vec2(dxyz[0],dxyz[1],dxyz[2]);
277     vec1.norme();
278     vec2.norme();
279     double ps=vec1*vec2;
280     MG_SEGMENT *nvsegment;
281 francois 791 if (ps>0) nvsegment=new MG_SEGMENT(ref,n1,n2,MAGIC::ORIGINE::IMPOSE);
282     else nvsegment=new MG_SEGMENT(ref,n2,n1,MAGIC::ORIGINE::IMPOSE);
283 francois 357 maibloc->ajouter_mg_segment(nvsegment);
284 francois 355 }
285     }
286 francois 120 }
287 francois 123 if (etape<7) return;
288 francois 120 //etape 7 maillage 1D de bloc
289 francois 272 affiche((char*)" MAILLAGE 1D du modele bloc");
290 francois 120 int nbaretebloc=geobloc->get_nb_mg_arete();
291     int nbsegmentblocavant=maibloc->get_nb_mg_segment();
292     for (int i=0;i<nbaretebloc;i++)
293     {
294 francois 446 MAILLEUR1D m1d_bloc(maibloc,geobloc,carte,geobloc->get_mg_arete(i));
295 francois 532 m1d_bloc.change_pas_integration(pas);
296 francois 120 m1d_bloc.adapte();
297     }
298 francois 174 //cree_quadtree(maibloc,quadbloc,&lstsegfrontbloc);
299 francois 123 if (etape<8) return;
300 francois 120 // etape 8 transfert des segment vers entier
301     int nbfaceentier=geoentier->get_nb_mg_face();
302     TPL_LISTE_ENTITE<MG_SEGMENT*> *lstsegcontraint=new TPL_LISTE_ENTITE<MG_SEGMENT*>[nbfaceentier];
303     int nbsegmentbloc=maibloc->get_nb_mg_segment();
304     for (int i=nbsegmentblocavant;i<nbsegmentbloc;i++)
305     {
306     MG_SEGMENT* seg=maibloc->get_mg_segment(i);
307     int num;
308 francois 174 MG_FACE* face=seg_sur_face(seg,geoentier,&num);
309 francois 120 if (face!=NULL)
310     lstsegcontraint[num].ajouter(seg);
311     /*MG_NOEUD* noeud1=seg->get_noeud1();
312     MG_NOEUD* noeud2=seg->get_noeud2();
313     int dim1;
314     int dim2;
315     MG_NOEUD* n1=chercher(noeud1->get_coord(),*octreeentier);
316     MG_NOEUD* n2=chercher(noeud2->get_coord(),*octreeentier);
317     MG_FACE* face1ref;
318     MG_FACE* face2ref;
319     int num1,num2;
320     if (n1==NULL)
321     {
322     face1ref=verif_noeud_sur_face(noeud1->get_coord(),geoentier,&num1,octreeentierseg);
323     if (face1ref==NULL) dim1=3; else dim1=2;
324     }
325     else
326     dim1=n1->get_lien_topologie()->get_dimension();
327     if (n2==NULL)
328     {
329     face2ref=verif_noeud_sur_face(noeud2->get_coord(),geoentier,&num2,octreeentierseg);
330     if (face2ref==NULL) dim2=3; else dim2=2;
331     }
332     else
333     dim2=n2->get_lien_topologie()->get_dimension();
334     if ((dim1==3) || (dim2==3)) continue;
335     if ((dim1==2) || (dim2==2))
336     {
337     int num;
338     if (dim1==2) num=num1;
339     else if (dim2==2) num=num2;
340     lstsegcontraint[num].ajouter(seg);
341     } */
342     }
343 francois 123 if (etape<9) return;
344 francois 120 //etape 9 maillage 2D de entier
345 francois 272 affiche((char*)" MAILLAGE 2D du modele entier");
346 francois 120 for (int i=0;i<nbfaceentier;i++)
347     {
348     MG_FACE* face=geoentier->get_mg_face(i);
349 francois 446 MAILLEUR2D m2d(maientier,geoentier,carte,face);
350 francois 123 char mess[50];
351 francois 532 m2d.change_pas_integration(pas);
352 francois 123 sprintf(mess," Face %i identificateur %lu",i,face->get_id());
353     affiche(mess);
354 francois 532 m2d.maille(face,&(lstsegcontraint[i]));
355 francois 146 }
356 francois 122 delete [] lstsegcontraint;
357 francois 123 if (etape<10) return;
358 francois 120 //etape 10 transfert des triangle vers bloc
359     int nbfacebloc=geobloc->get_nb_mg_face();
360     TPL_LISTE_ENTITE<MG_TRIANGLE*> *lsttricontraint=new TPL_LISTE_ENTITE<MG_TRIANGLE*>[nbfacebloc];
361     int nbtrientier=maientier->get_nb_mg_triangle();
362     for (int i=0;i<nbtrientier;i++)
363     {
364     MG_TRIANGLE* tri=maientier->get_mg_triangle(i);
365     int num;
366 francois 174 MG_FACE* face=tri_sur_face(tri,geobloc,&num);
367 francois 120 if (face!=NULL)
368     lsttricontraint[num].ajouter(tri);
369     }
370 francois 123 if (etape<11) return;
371 francois 120 //etape 11 maillage 2D de bloc
372 francois 272 affiche((char*)" MAILLAGE 2D du modele bloc");
373 francois 120 for (int i=0;i<nbfacebloc;i++)
374     {
375     MG_FACE* face=geobloc->get_mg_face(i);
376 francois 446 MAILLEUR2D m2d(maibloc,geobloc,carte,face);
377 francois 123 char mess[50];
378 francois 532 m2d.change_pas_integration(pas);
379 francois 123 sprintf(mess," Face %i identificateur %lu",i,face->get_id());
380     affiche(mess);
381 francois 120 m2d.maille(face,NULL,&(lsttricontraint[i]));
382 francois 146 }
383 francois 122 delete [] lsttricontraint;
384 francois 123 if (etape<12) return;
385 francois 120 //etape 12 maillage 3D de bloc
386 francois 272 affiche((char*)" MAILLAGE 3D du modele bloc");
387 francois 120 int nbvolumebloc=geobloc->get_nb_mg_volume();
388     for (int i=0;i<nbvolumebloc;i++)
389     {
390     MG_VOLUME *vol=geobloc->get_mg_volume(i);
391 francois 494 MAILLEUR3D m3d(maibloc,geobloc,carte,false,vol);
392 francois 493 if (affichageactif==1) m3d.active_affichage(affiche2);
393 francois 532 m3d.change_pas_integration(pas);
394 francois 120 m3d.maille(vol);
395     }
396 francois 123 if (etape<13) return;
397 francois 120 //etape 13 transfert des tetra vers entier
398     TPL_LISTE_ENTITE<MG_TETRA*> lsttetra;
399     LISTE_MG_TETRA::iterator it;
400     for (MG_TETRA* tet=maibloc->get_premier_tetra(it);tet!=NULL;tet=maibloc->get_suivant_tetra(it))
401     lsttetra.ajouter(tet);
402     //etape 14 maillage 3D de entier
403 francois 339 if (etape<14) return;
404 francois 272 affiche((char*)" MAILLAGE 3D du modele entier");
405 francois 120 MG_VOLUME *vol=geoentier->get_mg_volume(0);
406 francois 494 MAILLEUR3D m3d(maientier,geoentier,carte,savedbg,vol,LIMITEDETRUIRE);
407 francois 532 m3d.change_pas_integration(pas);
408 francois 494 if (savedbg) m3d.change_nom_fichierdbg(nomfichierdbg);
409 francois 493 if (affichageactif==1) m3d.active_affichage(affiche2);
410     m3d.maille(vol,NULL,&lsttetra);
411 francois 120 }
412    
413     MG_NOEUD* MAILLEUR_BLOC::chercher(double *xyz,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> &octree)
414     {
415     TPL_MAP_ENTITE<MG_NOEUD*> lst;
416     octree.rechercher(xyz[0],xyz[1],xyz[2],1e-5,lst);
417     int nb=lst.get_nb();
418     for (int i=0;i<nb;i++)
419     {
420     OT_VECTEUR_3D vec(xyz,lst.get(i)->get_coord());
421     double metrique[9];
422     carte->evaluer(xyz,metrique);
423     double eps=(1./sqrt(metrique[0])*1e-10);
424     if (vec.get_longueur()<eps) return lst.get(i);
425     }
426     return NULL;
427     }
428    
429    
430     MG_SOMMET* MAILLEUR_BLOC::verif_noeud_sur_sommet(double *xyz, MG_GEOMETRIE *geo)
431     {
432     int nbsom=geo->get_nb_mg_sommet();
433     for (int i=0;i<nbsom;i++)
434     {
435     MG_SOMMET *sommet=geo->get_mg_sommet(i);
436     double xyzsom[3];
437     sommet->get_point()->evaluer(xyzsom);
438     double metrique[9];
439     carte->evaluer(xyz,metrique);
440 francois 124 double eps=(1./sqrt(metrique[0])*1e-6);
441 francois 120 OT_VECTEUR_3D vec(xyz,xyzsom);
442     if (vec.get_longueur()<eps) return sommet;
443     }
444     return NULL;
445     }
446    
447    
448     MG_ARETE* MAILLEUR_BLOC::verif_noeud_sur_arete(double *xyz, MG_GEOMETRIE *geo,int *num, double *t)
449     {
450     int nb_are=geo->get_nb_mg_arete();
451     for ( int i=0 ; i < nb_are ; i++)
452     {
453     MG_ARETE *arete=geo->get_mg_arete(i);
454     arete->inverser((*t),xyz);
455     if (arete->get_courbe()->est_periodique())
456     if (*t< arete->get_tmin()) *t=*t+arete->get_courbe()->get_periode();
457     double xyztmp[3];
458     arete->evaluer( *t,xyztmp );
459     double metrique[9];
460     carte->evaluer(xyz,metrique);
461 francois 124 double eps=(1./sqrt(metrique[0])*1e-6);
462 francois 120 OT_VECTEUR_3D vec(xyz,xyztmp);
463     if (vec.get_longueur()<eps)
464     if ((*t>arete->get_tmin()) && (*t<arete->get_tmax()))
465     {
466     *num=i;
467     return arete;
468     }
469     }
470     return NULL;
471     }
472    
473 francois 174 MG_FACE* MAILLEUR_BLOC::seg_sur_face(MG_SEGMENT* seg,MG_GEOMETRIE* geo,int *num)
474 francois 120 {
475     double *xyz1=seg->get_noeud1()->get_coord();
476     double *xyz2=seg->get_noeud2()->get_coord();
477     int nbface=geo->get_nb_mg_face();
478     for (int i=0;i<nbface;i++)
479     {
480     MG_FACE *face=geo->get_mg_face(i);
481     double metrique[9];
482     carte->evaluer(xyz1,metrique);
483 francois 123 double eps=(1./sqrt(metrique[0])*1e-6);
484 francois 120 double uv1[2],xyz1bis[3];
485     face->inverser(uv1,xyz1);
486     face->evaluer(uv1,xyz1bis);
487     OT_VECTEUR_3D vec1(xyz1,xyz1bis);
488     if (vec1.get_longueur()<eps)
489     {
490     double uv2[2],xyz2bis[3];
491     face->inverser(uv2,xyz2);
492     face->evaluer(uv2,xyz2bis);
493     OT_VECTEUR_3D vec2(xyz2,xyz2bis);
494     if (vec2.get_longueur()<eps)
495     {
496     double xyz[3];
497     xyz[0]=0.5*(xyz1[0]+xyz2[0]);
498     xyz[1]=0.5*(xyz1[1]+xyz2[1]);
499     xyz[2]=0.5*(xyz1[2]+xyz2[2]);
500     double uv[2];
501     face->inverser(uv,xyz);
502 francois 174 double dist=otentier.calcule_distance_contour_face_uv(uv,face);
503 francois 120 if (dist>0.) {*num=i;return face;}
504     }
505     }
506     }
507     return NULL;
508     }
509    
510 francois 174 MG_FACE* MAILLEUR_BLOC::tri_sur_face(MG_TRIANGLE* tri,MG_GEOMETRIE* geo,int *num)
511 francois 120 {
512     double *xyz1=tri->get_noeud1()->get_coord();
513     double *xyz2=tri->get_noeud2()->get_coord();
514     double *xyz3=tri->get_noeud3()->get_coord();
515     int nbface=geo->get_nb_mg_face();
516     for (int i=0;i<nbface;i++)
517     {
518     MG_FACE *face=geo->get_mg_face(i);
519     double metrique[9];
520     carte->evaluer(xyz1,metrique);
521 francois 123 double eps=(1./sqrt(metrique[0])*1e-6);
522 francois 120 double uv1[2],xyz1bis[3];
523     face->inverser(uv1,xyz1);
524     face->evaluer(uv1,xyz1bis);
525     OT_VECTEUR_3D vec1(xyz1,xyz1bis);
526     if (vec1.get_longueur()<eps)
527     {
528     double uv2[2],xyz2bis[3];
529     face->inverser(uv2,xyz2);
530     face->evaluer(uv2,xyz2bis);
531     OT_VECTEUR_3D vec2(xyz2,xyz2bis);
532     if (vec2.get_longueur()<eps)
533     {
534     double uv3[2],xyz3bis[3];
535     face->inverser(uv3,xyz3);
536     face->evaluer(uv3,xyz3bis);
537     OT_VECTEUR_3D vec3(xyz3,xyz3bis);
538     if (vec3.get_longueur()<eps)
539     {
540     double xyz[3];
541     double uv[2];
542 francois 124 OT_DECALAGE_PARAMETRE deca(face->get_surface()->get_periode_u(),face->get_surface()->get_periode_v());
543     double du=deca.calcul_decalage_parametre_u(uv1[0]);
544     double dv=deca.calcul_decalage_parametre_v(uv1[1]);
545    
546     uv[0]=0.333333333333333333*(deca.decalage_parametre_u(uv1[0],du)+deca.decalage_parametre_u(uv2[0],du)+deca.decalage_parametre_u(uv3[0],du));
547     uv[1]=0.333333333333333333*(deca.decalage_parametre_v(uv1[1],dv)+deca.decalage_parametre_v(uv2[1],dv)+deca.decalage_parametre_v(uv3[1],dv));
548     uv[0]=deca.decalage_parametre_u(uv[0],-du);
549     uv[1]=deca.decalage_parametre_v(uv[1],-dv);
550 francois 174 double dist=otbloc.calcule_distance_contour_face_uv(uv,face);
551 francois 120 if (dist>0.) {*num=i;return face;}
552     }
553     }
554     }
555     }
556     return NULL;
557     }
558    
559    
560 francois 124 void MAILLEUR_BLOC::cree_octree(MG_MAILLAGE* mai,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> **octree)
561 francois 120 {
562     double xmin=1e300,ymin=1e300,zmin=1e300;
563     double xmax=-1e300,ymax=-1e300,zmax=-1e300;
564     TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
565     int nb_noeud=mai->get_nb_mg_noeud();
566     for (int i=0;i<nb_noeud;i++)
567     {
568     MG_NOEUD* mgnoeud=mai->get_mg_noeud(i);
569     lstnoeud.ajouter(mgnoeud);
570     xmin=std::min(xmin,mgnoeud->get_x());
571     ymin=std::min(ymin,mgnoeud->get_y());
572     zmin=std::min(zmin,mgnoeud->get_z());
573     xmax=std::max(xmax,mgnoeud->get_x());
574     ymax=std::max(ymax,mgnoeud->get_y());
575     zmax=std::max(zmax,mgnoeud->get_z());
576     }
577     double xdiff=xmax-xmin;
578     double ydiff=ymax-ymin;
579     double zdiff=zmax-zmin;
580     xmin=xmin-0.125*xdiff;
581     xmax=xmax+0.125*xdiff;
582     ymin=ymin-0.125*ydiff;
583     ymax=ymax+0.125*ydiff;
584     zmin=zmin-0.125*zdiff;
585     zmax=zmax+0.125*zdiff;
586     (*octree)=new TPL_OCTREE<MG_NOEUD*,MG_NOEUD*>;
587 francois 124 (*octree)->initialiser(&lstnoeud,1,xmin,ymin,zmin,xmax,ymax,zmax);
588     }
589 francois 120
590 francois 124 void MAILLEUR_BLOC::cree_octree(TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> *octree1,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> **octree2)
591     {
592     (*octree2)=new TPL_OCTREE<MG_NOEUD*,MG_NOEUD*>;
593     (*octree2)->initialiser(octree1);
594     }
595 francois 120
596 francois 124
597 francois 120
598