MAGiC  V5.0
Mailleurs Automatiques de Géometries intégrés à la Cao
mg_maillage_outils.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 //####// mg_maillage_outils.cpp
15 //####//
16 //####//------------------------------------------------------------
17 //####//------------------------------------------------------------
18 //####// COPYRIGHT 2000-2024
19 //####// jeu 13 jun 2024 11:58:54 EDT
20 //####//------------------------------------------------------------
21 //####//------------------------------------------------------------
22 #include <math.h>
23 #include "gestionversion.h"
24 #include "mg_maillage_outils.h"
25 #include "tpl_liste_entite.h"
26 #include "mg_segment.h"
27 #include "mg_noeud.h"
28 #include "mg_maillage.h"
29 #include "ot_algorithme_geometrique.h"
30 #include "ot_decalage_parametre.h"
31 #include "fem_element3.h"
32 #include "fem_noeud.h"
33 #include "tpl_fonctions_generiques.h"
34 #include "occ_import.h"
35 #include "ot_cpu.h"
36 #include <complex>
37 #include "mg_gestionnaire.h"
38 #include "mg_solution.h"
39 #include "mg_geometrie_outils.h"
40 
41 
42 
43 int MG_MAILLAGE_OUTILS::estdansletetra(MG_TETRA *tet,double x,double y, double z)
44 {
45 double *xyz1,*xyz2,*xyz3,*xyz4;
46 xyz1=tet->get_noeud1()->get_coord();
47 xyz2=tet->get_noeud2()->get_coord();
48 xyz3=tet->get_noeud3()->get_coord();
49 xyz4=tet->get_noeud4()->get_coord();
50 return OPERATEUR::estdansletetra(xyz1,xyz2,xyz3,xyz4,x,y,z);
51 }
52 
53 int MG_MAILLAGE_OUTILS::estdansletriangle(MG_TRIANGLE *tri,double x,double y, double z)
54 {
55 double *xyz1,*xyz2,*xyz3;
56 xyz1=tri->get_noeud1()->get_coord();
57 xyz2=tri->get_noeud2()->get_coord();
58 xyz3=tri->get_noeud3()->get_coord();
59 return OPERATEUR::estdansletriangle(xyz1,xyz2,xyz3,x,y,z);
60 }
61 
62 int MG_MAILLAGE_OUTILS::projeteestdansletriangle(MG_TRIANGLE *tri,double x,double y, double z)
63 {
64 double *xyz1,*xyz2,*xyz3;
65 xyz1=tri->get_noeud1()->get_coord();
66 xyz2=tri->get_noeud2()->get_coord();
67 xyz3=tri->get_noeud3()->get_coord();
68 return OPERATEUR::projeteestdansletriangle(xyz1,xyz2,xyz3,x,y,z);
69 }
70 
71 
72 void MG_MAILLAGE_OUTILS::projetedansletriangle(MG_TRIANGLE *tri,double x,double y, double z,double &xx,double &yy,double &zz)
73 {
74 double *xyz1,*xyz2,*xyz3;
75 xyz1=tri->get_noeud1()->get_coord();
76 xyz2=tri->get_noeud2()->get_coord();
77 xyz3=tri->get_noeud3()->get_coord();
78 OPERATEUR::projetedansletriangle(xyz1,xyz2,xyz3,x,y,z,xx,yy,zz);
79 
80 }
81 
82 int MG_MAILLAGE_OUTILS::compare_etat_tetra(int etat,int valeur)
83 {
84 return OPERATEUR::compare_etat_tetra(etat,valeur);
85 }
86 
87 int MG_MAILLAGE_OUTILS::compare_etat_triangle(int etat,int valeur)
88 {
89 return OPERATEUR::compare_etat_triangle(etat,valeur);
90 }
91 
92 
93 double MG_MAILLAGE_OUTILS::get_angle(MG_TRIANGLE* ele1,MG_TRIANGLE* ele2)
94 {
95  MG_NOEUD* noeud1=ele1->get_noeud1();
96  MG_NOEUD* noeud2=ele1->get_noeud2();
97  MG_NOEUD* noeud3=ele1->get_noeud3();
98  MG_NOEUD* noeud4=ele2->get_noeud1();
99  MG_NOEUD* noeud5=ele2->get_noeud2();
100  MG_NOEUD* noeud6=ele2->get_noeud3();
101  return get_angle_par_noeud<MG_NOEUD*>(noeud1,noeud2,noeud3,noeud4,noeud5,noeud6);
102 
103 }
104 
105 
106 
107 
108 
109 void EdgeMeshStats(MG_MAILLAGE * __mesh, MG_ARETE * __edge, int & nSeg, int & nNodesVertex)
110 {
111  nSeg = 0;
112  std::set<MG_NOEUD*>setNodesTopoDimension0;
113  TPL_SET<MG_ELEMENT_MAILLAGE*>* lien_maillage = __edge->get_lien_maillage();
114  TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
115  MG_ELEMENT_MAILLAGE* element;
116  for (element = lien_maillage->get_premier(it); element; element = lien_maillage->get_suivant(it) )
117  {
118  if (__mesh->contient(element))
119  {
120  MG_SEGMENT * seg = (MG_SEGMENT*)element;
121  nSeg++;
122  MG_NOEUD * nos[2];
123  nos[0] = seg->get_noeud1();
124  nos[1] = seg->get_noeud2();
125  for (int i=0; i<2; i++)
126  {
127  if (nos[i]->get_lien_topologie() && nos[i]->get_lien_topologie()->get_dimension() == 0)
128  setNodesTopoDimension0.insert(nos[i]);
129  }
130  }
131  }
132  nNodesVertex = setNodesTopoDimension0.size();
133 }
134 
135 bool EdgeMeshHasNode(MG_MAILLAGE * __mesh, MG_ARETE * __edge, MG_NOEUD * __node)
136 {
137  TPL_SET<MG_ELEMENT_MAILLAGE*>* lien_maillage = __edge->get_lien_maillage();
138  TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
139  MG_ELEMENT_MAILLAGE* element;
140  for ( element = lien_maillage->get_premier(it); element; element = lien_maillage->get_suivant(it) )
141  {
142  if (__mesh->contient(element))
143  {
144  MG_SEGMENT * seg = (MG_SEGMENT*)element;
145  if (__node == seg->get_noeud1() || __node == seg->get_noeud2())
146  return true;
147  }
148  }
149  return false;
150 }
151 
152 /*Algorithme Ins�er un nud N' sur le segment Seg �Seg' + Seg''
153 Soient N1 et N2 les extr�it� du segment Seg
154 Soient T1 et T2 les triangles adjacents �Seg
155 Soit Nop (T1, Seg) le nud de T1 oppos�au segment Seg
156 Soit Nop (T2, Seg) le nud de T2 oppos�au segment Seg
157 Supprimer T1, T2, Seg
158 Ajouter Triangle ( N1, Nop(T1,Seg), N')
159 Ajouter Triangle ( Nop(T1,Seg), N', N2)
160 Ajouter Triangle ( N1, Nop(T2,Seg), N')
161 Ajouter Triangle ( Nop(T2,Seg), N', N2)
162 
163 Entr� :
164 MG_MAILLAGE * __mesh : le maillage contenant le segment original
165 MG_NOEUD * __node : le noeud �ins�er pour d�ouper le segment original
166 MG_SEGMENT * __originalSeg : le segment original (attention: il est detruit si __deleteOriginalSeg = true)
167 
168 Sortie:
169 MG_SEGMENT * __segs[2] : les 2 segments d�oup�
170 
171 Optionnel:
172 bool __deleteOriginalSeg (optionnel) : si le segment original doit �re supprim�ou non
173 */
174 void MG_MAILLAGE_OUTILS::inserer_noeud_segment(MG_MAILLAGE * __mesh, MG_NOEUD * __node, MG_SEGMENT * __originalSeg, MG_SEGMENT * __segs[2], bool __deleteOriginalSeg)
175 {
176  unsigned i,j,k,l;
177  MG_NOEUD * N[2];
178  MG_TRIANGLE ** T;
179  unsigned nb_triangles;
180  MG_ELEMENT_TOPOLOGIQUE * NTopo[2], * STopo;
181 
182  // Prevent original segment from automatic deletion !
183  __originalSeg->incrementer();
184 
185  N[0] = __originalSeg->get_noeud1();
186  N[1] = __originalSeg->get_noeud2();
187  for (i=0;i<2;i++) NTopo[i] = N[i]->get_lien_topologie();
188  STopo = __originalSeg->get_lien_topologie();
189 
190  TPL_LISTE_ENTITE<class MG_TRIANGLE*>* triangles = __originalSeg->get_lien_triangle();
191  printf("triangles->get_nb()=%d\n",triangles->get_nb());
192 
193  nb_triangles = triangles->get_nb();
194  T = new MG_TRIANGLE * [ nb_triangles ];
195  for (i = 0; i < nb_triangles; i++)
196  T[i] = triangles->get(i);
197 
198  for (i = 0; i < nb_triangles; i++)
199  {
200  MG_TRIANGLE * T0 = T[i];
201 
202  bool triangle_already_processed = false;
203  for (j=0; j<i; j++)
204  if (T0 == T[j])
205  {
206  printf("triangle_already_processed ! Triangle %d == Triangle %d\n", j, i);
207  triangle_already_processed = true;
208  break;
209  }
210  if (triangle_already_processed)
211  continue;
212 
213  MG_TRIANGLE * splitT [2];
214  MG_NOEUD *TN0[3], * Nop = NULL, *TN1[3], *TN2[3];
215  TN0[0] = T0->get_noeud1();
216  TN0[1] = T0->get_noeud2();
217  TN0[2] = T0->get_noeud3();
218  MG_ELEMENT_TOPOLOGIQUE * topo = T0->get_lien_topologie();
219 
220  // get the node of T opposed to segment splitSeg
221  for (j=0; j<3; j++)
222  {
223  if (TN0[j] == N[0])
224  {
225  TN1[j] = N[0];
226  TN2[j] = __node;
227  }
228  else if (TN0[j] == N[1])
229  {
230  TN1[j] = __node;
231  TN2[j] = N[1];
232  }
233  else
234  {
235  Nop = TN0[j];
236  TN1[j] = Nop;
237  TN2[j] = Nop;
238  }
239  }
240 
241  splitT[0] = __mesh->ajouter_mg_triangle(topo, TN1[0], TN1[1], TN1[2],MAGIC::ORIGINE::MODIFICATION);
242  splitT[1] = __mesh->ajouter_mg_triangle(topo, TN2[0], TN2[1], TN2[2],MAGIC::ORIGINE::MODIFICATION);
243  __mesh->supprimer_mg_triangleid(T0->get_id());
244 
245  for (l=0; l<2; l++)
246  {
247  MG_SEGMENT * segT[3];
248  segT[0] = splitT[l]->get_segment1();
249  segT[1] = splitT[l]->get_segment2();
250  segT[2] = splitT[l]->get_segment3();
251  for (k=0; k<3; k++)
252  {
253  MG_SEGMENT * segK = segT[k];
254  for (j=0; j<2; j++)
255  {
256  if ( (segK->get_noeud1() == N[j] && segK->get_noeud2() == __node)
257  || (segK->get_noeud2() == N[j] && segK->get_noeud1() == __node) )
258  {
259  __segs[j] = segK;
260  j=2;
261  k=3;
262  }
263  }
264  }
265  }
266  }
267  __originalSeg->change_lien_topologie(NULL);
268  for (i=0;i<2;i++)
269  N[i]->change_lien_topologie(NTopo[i]);
270  for (i=0;i<2;i++)
271  __segs[i]->change_lien_topologie(STopo);
272 
273  if ( __deleteOriginalSeg )
274  {
275  __originalSeg->decrementer();
276  __mesh->supprimer_mg_segmentid(__originalSeg->get_id());
277  }
278 
279  delete [] T;
280 }
281 
303 void MG_MAILLAGE_OUTILS::classe_elements_dimension1__trouver_prochains_elements(std::set <MG_SEGMENT*> & __unvisitedSegs, std::vector<MG_SEGMENT*> & __visitedSegs,
304  std::vector<MG_NOEUD*>& __visitedNodes, MG_NOEUD * & __nextNode, MG_SEGMENT * & __nextSeg)
305 {
306  __nextSeg = NULL;
307  __nextNode = NULL;
308 
309  if (__visitedNodes.size() == 0)
310  return;
311 
312  // last visited node
313  MG_NOEUD * lastNode = __visitedNodes[__visitedNodes.size()-1];
314 
315  // segments adjacent to Ni
316  TPL_LISTE_ENTITE< class MG_SEGMENT * > * adjSegs = lastNode->get_lien_segment ();
317  for (int it_seg = 0; it_seg < adjSegs->get_nb(); it_seg++)
318  {
319  MG_SEGMENT * adjSeg = adjSegs->get(it_seg);
320  if ( __unvisitedSegs.find(adjSeg) != __unvisitedSegs.end() )
321  {
322  __nextSeg = adjSeg;
323  __nextNode = __nextSeg->get_noeud1();
324  if (__nextNode == lastNode )
325  __nextNode = __nextSeg->get_noeud2();
326  break;
327  }
328  }
329 
330  if (__nextSeg == NULL)
331  {
332  double minDist = 1E99;
333  MG_SEGMENT * closestSeg = NULL;
334 
335  for (std::set<MG_SEGMENT*>::iterator it_seg = __unvisitedSegs.begin();
336  it_seg != __unvisitedSegs.end();
337  it_seg++)
338  {
339  MG_SEGMENT * seg = *it_seg;
340  double distance=OT_ALGORITHME_GEOMETRIQUE::Dist3D_Point_Segment(seg->get_noeud1()->get_coord(),seg->get_noeud2()->get_coord(),lastNode->get_coord());
341  if (distance < minDist)
342  {
343  minDist = distance;
344  closestSeg = seg;
345  }
346  }
347 
348  if (closestSeg||minDist < 1E-6)
349  {
350  __nextSeg = closestSeg;
351  MG_NOEUD * n[2];
352  n[0] = closestSeg->get_noeud1();
353  n[1] = closestSeg->get_noeud2();
354  for (int i=0;i<2;i++)
355  {
356  TPL_LISTE_ENTITE< class MG_SEGMENT * > * adjSegs = n[i]->get_lien_segment ();
357  for (int it_seg = 0; it_seg < adjSegs->get_nb(); it_seg++)
358  {
359  MG_SEGMENT * adjSeg = adjSegs->get(it_seg);
360  if ( adjSeg != closestSeg && __unvisitedSegs.find(adjSeg) != __unvisitedSegs.end() )
361  {
362  __nextNode = n[i];
363  __visitedNodes.push_back (n[i%2]);
364  i = 2;
365  break;
366  }
367  }
368  }
369  }
370  }
371 
372  if (__nextNode) __visitedNodes.push_back (__nextNode);
373  if (__nextSeg) __visitedSegs.push_back (__nextSeg);
374  if (__nextSeg) __unvisitedSegs.erase (__nextSeg);
375 
376 }
377 
381 MG_NOEUD *
382 MG_MAILLAGE_OUTILS::classe_elements_dimension1__trouver_noeud_dimension0(const std::set<MG_SEGMENT*> & __unvisitedSegs)
383 {
384  for ( std::set<MG_SEGMENT*>::const_iterator it_seg = __unvisitedSegs.begin();
385  it_seg != __unvisitedSegs.end();
386  it_seg++)
387  {
388  MG_NOEUD * V[2];
389  V[0] = (*it_seg)->get_noeud1();
390  V[1] = (*it_seg)->get_noeud2();
391  for (int i=0; i<2; i++)
392  {
393  if (V[i]->get_lien_topologie() && V[i]->get_lien_topologie()->get_dimension() == 0)
394  return V[i];
395  }
396  }
397  return NULL;
398 }
399 /*
400 
401 Cette fonction classe une liste de segments attach� �un tpologie de dimension 1
402 (ar�e) et g��e 2 listes :
403 
404 * __visitedSegs : la liste des segments plac� entre 2 noeuds li� �une topologie
405  de dimension 0 (noeuds de sommets). Les premier et dernier segments
406  de la liste sont adjacent �un sommet de la topologie.
407  La liste de segments est ordonn� par adjacence et forment une polyligne.
408 
409 * __visitedNodes : la liste des noeuds ordonn� par ordre d'adjacence,
410  en partant du noeud d'extr�it�du premier segment, et en finissant
411  par le noeud d'extremit�du dernier segment.
412 
413  __visitedNodes[i] et __visitedNodes[i+1] sont les extr�it� du segment __visitedSegs[i]
414 
415  Algorithme utilis�:
416 
417  * Trouver le premier noeud tel que la dimension de la topologie soit �ale �0
418 
419  * Faire :
420 
421  * (seg^i+1, N^i+1) = Trouver les prochains segments et noeuds ((segs), (visited_seg), (visited_N))
422 
423  * Tant que dernier(visited_N) a une dimension non �ale �0
424 
425 */
426 void
427 MG_MAILLAGE_OUTILS::classe_elements_dimension1(std::set<MG_SEGMENT*> & __unvisitedSegs, std::vector<MG_SEGMENT*> & __visitedSegs,
428  std::vector<MG_NOEUD*> & __visitedNodes )
429 {
430  MG_NOEUD * lastNode = classe_elements_dimension1__trouver_noeud_dimension0( __unvisitedSegs );
431  MG_SEGMENT * lastSeg = NULL;
432 
433  if (lastNode == NULL && __unvisitedSegs.size() )
434  lastNode = (*__unvisitedSegs.begin())->get_noeud1();
435 
436  if (lastNode == NULL)
437  return;
438 
439  __visitedNodes.push_back(lastNode);
440 
441  do
442  {
443  classe_elements_dimension1__trouver_prochains_elements( __unvisitedSegs, __visitedSegs, __visitedNodes, lastNode, lastSeg );
444  } while (lastSeg && lastNode && lastNode->get_lien_topologie() && lastNode->get_lien_topologie()->get_dimension() != 0 );
445 }
446 
447 
448 #undef _IdentifyEdge_DEBUG
449 void
450 MG_MAILLAGE_OUTILS::IdentifyEdge1(std::set <MG_SOMMET *> __vertices, std::set<MG_FACE *> & __adjacentFaces, std::set<MG_ARETE *> & __lst_edge)
451 {
452 
453  std::set<MG_ARETE*> commonEdges;
454  MG_MAILLAGE_OUTILS::FindCommonEdgesOfFaces(__adjacentFaces, commonEdges);
455 
456  if (commonEdges.size() == 1)
457  {
458  __lst_edge.insert(*commonEdges.begin()) ;
459  return;
460  }
461 
462 #ifdef _IdentifyEdge_DEBUG
463  printf("_IdentifyEdge : There is several edges candidate for this topology\n");
464  for (std::set <MG_SOMMET *>::iterator it_vertex = __vertices.begin(); it_vertex != __vertices.end(); it_vertex++)
465  printf("V[%d] = %d\n", std::distance(__vertices.begin(), it_vertex), (*it_vertex)->get_id());
466 
467  for ( std::set<MG_ARETE*>::const_iterator
468  it_edge = commonEdges.begin();
469  it_edge != commonEdges.end();
470  it_edge ++ )
471  {
472  printf("Candidate : edge ID %d, v1_ID=%d, v2_ID=%d\n", (*it_edge)->get_id(), (*it_edge)->get_cosommet1()->get_sommet()->get_id(), (*it_edge)->get_cosommet2()->get_sommet()->get_id());
473  }
474 #endif
475  for ( std::set<MG_ARETE*>::const_iterator
476  it_edge = commonEdges.begin();
477  it_edge != commonEdges.end();
478  it_edge ++ )
479  {
480  MG_ARETE * common_edge = *it_edge;
481 
482  MG_SOMMET * V[2];
483  V[0] = common_edge->get_cosommet1()->get_sommet();
484  V[1] = common_edge->get_cosommet2()->get_sommet();
485 
486  if (__vertices.find(V[0]) != __vertices.end()&&__vertices.find(V[1]) != __vertices.end())
487  {
488  __lst_edge.insert(common_edge);
489 #ifdef _IdentifyEdge_DEBUG
490  printf("Candidate edge %d has been choosen because: V1=%d V2=%d\n", common_edge->get_id(), V[0]->get_id(), V[1]->get_id());
491 #endif
492  }
493  }
494 
495 }
496 
497 void
498 MG_MAILLAGE_OUTILS::IdentifyEdge2(std::set <MG_SOMMET *> __vertices, std::set<MG_FACE *> & __adjacentFaces, std::set<MG_ARETE *> & __lst_edge, std::vector<MG_NOEUD*> & __nodes)
499 {
500 
501  std::set<MG_ARETE*> commonEdges;
502  MG_MAILLAGE_OUTILS::FindCommonEdgesOfFaces(__adjacentFaces, commonEdges);
503 
504  if (commonEdges.size() == 1)
505  {
506  __lst_edge.insert(*commonEdges.begin()) ;
507  return;
508  }
509 
510 #ifdef _IdentifyEdge_DEBUG
511  printf("_IdentifyEdge : There is several edges candidate for this topology\n");
512  for (std::set <MG_SOMMET *>::iterator it_vertex = __vertices.begin(); it_vertex != __vertices.end(); it_vertex++)
513  printf("V[%d] = %d\n", std::distance(__vertices.begin(), it_vertex), (*it_vertex)->get_id());
514 
515  for ( std::set<MG_ARETE*>::const_iterator
516  it_edge = commonEdges.begin();
517  it_edge != commonEdges.end();
518  it_edge ++ )
519  {
520  printf("Candidate : edge ID %d, v1_ID=%d, v2_ID=%d\n", (*it_edge)->get_id(), (*it_edge)->get_cosommet1()->get_sommet()->get_id(), (*it_edge)->get_cosommet2()->get_sommet()->get_id());
521  }
522 #endif
523  for ( std::set<MG_ARETE*>::const_iterator
524  it_edge = commonEdges.begin();
525  it_edge != commonEdges.end();
526  it_edge ++ )
527  {
528  MG_ARETE * common_edge = *it_edge;
529 
530  MG_SOMMET * V[2];
531  V[0] = common_edge->get_cosommet1()->get_sommet();
532  V[1] = common_edge->get_cosommet2()->get_sommet();
533 
534  if (__vertices.find(V[0]) != __vertices.end()&&__vertices.find(V[1]) != __vertices.end())
535  {
536  __lst_edge.insert(common_edge);
537 #ifdef _IdentifyEdge_DEBUG
538  printf("Candidate edge %d has been choosen because: V1=%d V2=%d\n", common_edge->get_id(), V[0]->get_id(), V[1]->get_id());
539 #endif
540  }
541  }
542 
543  if (__lst_edge.size() > 1)
544  MG_MAILLAGE_OUTILS::_FilterGeometricTolerance( __nodes, __lst_edge);
545 }
546 
547 void
548 MG_MAILLAGE_OUTILS::IdentifyEdge3(std::set <MG_SOMMET *> __vertices, std::set<MG_ARETE *> & __lst_edge, std::vector<MG_NOEUD*> & __nodes, MG_ARETE ** __edge)
549 {
550  std::set<MG_ARETE*> lst_candidate_edge;
551 
552  for ( std::set<MG_ARETE*>::const_iterator
553  it_edge = __lst_edge.begin();
554  it_edge != __lst_edge.end();
555  it_edge ++ )
556  {
557  MG_ARETE * candidate_edge = *it_edge;
558 
559  MG_SOMMET * V[2];
560  V[0] = candidate_edge->get_cosommet1()->get_sommet();
561  V[1] = candidate_edge->get_cosommet2()->get_sommet();
562 
563  if (__vertices.find(V[0]) != __vertices.end()&&__vertices.find(V[1]) != __vertices.end())
564  {
565  lst_candidate_edge.insert(candidate_edge);
566  }
567  }
568 
569  if (lst_candidate_edge.size() > 1 && __nodes.size() > 2)
570  MG_MAILLAGE_OUTILS::_FilterGeometricTolerance(__nodes,lst_candidate_edge);
571 
572  *__edge = *(lst_candidate_edge.begin());
573 }
574 
575 void
576 MG_MAILLAGE_OUTILS::IdentifyEdge5(const std::set <MG_SOMMET *> __vertices,
577  const std::set<MG_ARETE *> & __lst_edge,
578  const std::vector<MG_NOEUD*> & __nodes,
579  const std::vector<MG_SEGMENT*> & __segs,
580  MG_ARETE ** __edge)
581 {
582  std::set<MG_ARETE*> lst_candidate_edge;
583 
584  for ( std::set<MG_ARETE*>::const_iterator
585  it_edge = __lst_edge.begin();
586  it_edge != __lst_edge.end();
587  it_edge ++ )
588  {
589  MG_ARETE * candidate_edge = *it_edge;
590 
591  MG_SOMMET * V[2];
592  V[0] = candidate_edge->get_cosommet1()->get_sommet();
593  V[1] = candidate_edge->get_cosommet2()->get_sommet();
594 
595  if (__vertices.find(V[0]) != __vertices.end()&&__vertices.find(V[1]) != __vertices.end())
596  {
597  lst_candidate_edge.insert(candidate_edge);
598  }
599  }
600 
601  if (lst_candidate_edge.size() > 1 && __nodes.size() > 2)
602  MG_MAILLAGE_OUTILS::_FilterGeometricTolerance5(__nodes, __segs, lst_candidate_edge);
603  if (lst_candidate_edge.size()==0)
604  *__edge = 0;
605  else
606  *__edge = *(lst_candidate_edge.begin());
607 }
608 void
609 MG_MAILLAGE_OUTILS::_FilterSegmentsAndEdgeAdjacentToSameFaces( std::vector<MG_SEGMENT*> & __segments, std::set<MG_ARETE *> & __lst_edge)
610 {
611  std::set < std::set < MG_FACE * > > neighbouringFaces;
612  std::map < MG_ARETE *, int > mapEdgeMatchCount;
613 
614  for (std::set<MG_ARETE *>::iterator it2 = __lst_edge.begin();
615  it2 != __lst_edge.end(); it2++)
616  {
617  MG_ARETE * edge = *it2;
618  mapEdgeMatchCount [ edge ] = 0;
619  }
620 
621  for (std::vector<MG_SEGMENT*>::iterator it = __segments.begin();
622  it != __segments.end();
623  it++)
624  {
625  MG_SEGMENT * seg = *it;
626  std::set <MG_FACE *> f;
627  int nb_triangle = seg->get_lien_triangle()->get_nb();
628  for ( int j=0; j<nb_triangle; j++)
629  {
630  MG_TRIANGLE * t = seg->get_lien_triangle()->get(j);
631  MG_ELEMENT_TOPOLOGIQUE * topo = t->get_lien_topologie();
632  if (topo && topo->get_dimension() == 2)
633  {
634  MG_FACE * thisface = (MG_FACE *)topo;
635  f.insert (thisface);
636  }
637  }
638  if (f.size() == 2)
639  neighbouringFaces.insert(f);
640  }
641 
642  for (std::set < std::set < MG_FACE * > >::iterator it1 = neighbouringFaces.begin();
643  it1 != neighbouringFaces.end(); it1++)
644  {
645  std::set < MG_FACE * > adjacentFaces = *it1;
646  std::set<MG_ARETE*> commonEdges;
647  MG_MAILLAGE_OUTILS::FindCommonEdgesOfFaces(adjacentFaces, commonEdges);
648 
649  for (std::set<MG_ARETE *>::iterator it2 = __lst_edge.begin();
650  it2 != __lst_edge.end(); it2++)
651  {
652  MG_ARETE * edge = *it2;
653 
654  if ( commonEdges.find (edge) != commonEdges.end() )
655  mapEdgeMatchCount [ edge ] ++;
656  }
657  }
658 
659  for (std::map < MG_ARETE *, int >::iterator it2 = mapEdgeMatchCount.begin();
660  it2 != mapEdgeMatchCount.end(); it2++)
661  {
662  MG_ARETE * edge = it2->first;
663  int score = it2->second;
664 
665  if (score == 0)
666  {
667  __lst_edge.erase (edge);
668  }
669  }
670 }
671 
672 void
673 MG_MAILLAGE_OUTILS::IdentifyEdge4(std::set <MG_SOMMET *> __vertices, std::set<MG_ARETE *> & __lst_edge, std::vector<MG_NOEUD*> & __nodes, std::vector<MG_SEGMENT*> & __segments, MG_ARETE ** __edge)
674 {
675  std::set<MG_ARETE*> lst_candidate_edge;
676 
677  for ( std::set<MG_ARETE*>::const_iterator
678  it_edge = __lst_edge.begin();
679  it_edge != __lst_edge.end();
680  it_edge ++ )
681  {
682  MG_ARETE * candidate_edge = *it_edge;
683 
684  MG_SOMMET * V[2];
685  V[0] = candidate_edge->get_cosommet1()->get_sommet();
686  V[1] = candidate_edge->get_cosommet2()->get_sommet();
687 
688  if (__vertices.find(V[0]) != __vertices.end()&&__vertices.find(V[1]) != __vertices.end())
689  {
690  lst_candidate_edge.insert(candidate_edge);
691  }
692  }
693 
694  //if (lst_candidate_edge.size() > 1 && __nodes.size() > 2)
695  MG_MAILLAGE_OUTILS::_FilterSegmentsAndEdgeAdjacentToSameFaces(__segments, lst_candidate_edge);
696  if (lst_candidate_edge.size() == 0)
697  {
698  printf("Error IdentifyEdge3: _FilterSegmentsAndEdgeAdjacentToSameFaces discarded all candidate edges !\n");
699  return;
700  }
701 
702  if (lst_candidate_edge.size() > 1 && lst_candidate_edge.size())
703  MG_MAILLAGE_OUTILS::_FilterGeometricTolerance(__nodes, lst_candidate_edge);
704 
705 
706  *__edge = *(lst_candidate_edge.begin());
707 }
708 
709 double MG_MAILLAGE_OUTILS::TestDistanceEdgeNode(MG_ARETE* candidate_edge, MG_NOEUD* test_node)
710 {
711  int i;
712  double xyz_node[3];
713 
714  xyz_node[0] = test_node->get_x();
715  xyz_node[1] = test_node->get_y();
716  xyz_node[2] = test_node->get_z();
717 
718  return TestDistanceEdge(candidate_edge, xyz_node);
719 }
720 
721 double MG_MAILLAGE_OUTILS::TestDistanceEdge(MG_ARETE* candidate_edge, double* xyz_node)
722 {
723  int i;
724  double xyz_projection [3];
725 
726  double distance;
727  double edge_param;
728 
729  candidate_edge->inverser(edge_param, xyz_node);
730  candidate_edge->evaluer(edge_param, xyz_projection);
731 
732  double d[3];
733  for (i=0; i<3; i++)
734  d[i] = xyz_projection[i] - xyz_node[i];
735 
736  distance = sqrt(d[0]*d[0]+d[1]*d[1]+d[2]*d[2]);
737  return distance;
738 }
739 
740 void
741 MG_MAILLAGE_OUTILS::_FilterGeometricTolerance(const std::vector<MG_NOEUD*> & __nodes, std::set<MG_ARETE*> & __lst_edge)
742 {
743  int i;
744 
745  double xyz[3];
746 
747  if (__nodes.size() < 3)
748  {
749  printf("Warning : can't perform geometric verification on a node because there is %d nodes only !\n",(int)__nodes.size());
750 
751 
752  for (i=0; i<2; i++)
753  {
754  xyz[0] = .5*__nodes[0]->get_x()+.5*__nodes[1]->get_x();;
755  xyz[1] = .5*__nodes[0]->get_y()+.5*__nodes[1]->get_y();;
756  xyz[2] = .5*__nodes[0]->get_z()+.5*__nodes[1]->get_z();;
757  }
758  }
759  else
760  {
761  xyz[0] = __nodes[1]->get_x();
762  xyz[1] = __nodes[1]->get_y();
763  xyz[2] = __nodes[1]->get_z();
764  }
765 
766  std::set<MG_ARETE*> new_lst_edge;
767  double epsilon = 1E-6;
768  MG_ARETE * closestEdge = NULL;
769  double minDist = 1E100;
770 
771  for (std::set<MG_ARETE*>::iterator it_edge = __lst_edge.begin();
772  it_edge != __lst_edge.end();
773  it_edge++)
774  {
775  MG_ARETE * candidate_edge = *it_edge;
776  double distance = MG_MAILLAGE_OUTILS::TestDistanceEdge(candidate_edge, xyz)/candidate_edge->get_longueur(candidate_edge->get_tmin(),candidate_edge->get_tmax());
777 
778  if (minDist > distance)
779  {
780  minDist = distance;
781  closestEdge = candidate_edge;
782  }
783 
784  if (distance > epsilon)
785  continue;
786  else
787  {
788  new_lst_edge.insert (candidate_edge);
789  }
790  }
791 
792  if (new_lst_edge.size() == 0)
793  new_lst_edge.insert(closestEdge);
794 
795  __lst_edge = new_lst_edge;
796 }
797 
798 double Point_FindClosestSegment(double __xyz[3], const std::vector<MG_SEGMENT*> & __segs, MG_SEGMENT*& __closestSeg)
799 {
800  double minDist=1E308;
801  double closestPointInAllSegs[3];
802 
803  for (std::vector<MG_SEGMENT*>::const_iterator itSeg=__segs.begin();
804  itSeg != __segs.end();
805  itSeg++)
806  {
807  MG_SEGMENT * seg=*itSeg;
808 
809  double closestPointInSegment[3];
810  OT_ALGORITHME_GEOMETRIQUE::Closest_Point_to_Segment_3d (seg->get_noeud1()->get_coord(), seg->get_noeud2()->get_coord(), __xyz, closestPointInSegment);
811 
812  double dist=OT_ALGORITHME_GEOMETRIQUE::VEC3_DISTANCE_VEC3( closestPointInSegment, __xyz );
813 
814  if ( dist < minDist )
815  {
816  minDist = dist;
817  __closestSeg=seg;
818  }
819  }
820 
821  return minDist;
822 }
823 
824 void
825 MG_MAILLAGE_OUTILS::_FilterGeometricTolerance5(const std::vector<MG_NOEUD*> & __nodes, const std::vector<MG_SEGMENT*> & __segs, std::set<MG_ARETE*> & __lst_edge)
826 {
827  int i;
828 
829  std::set<MG_ARETE*> new_lst_edge;
830  MG_ARETE * closestEdge = NULL;
831  double minDist = 1E100;
832 
833  for (std::set<MG_ARETE*>::iterator it_edge = __lst_edge.begin();
834  it_edge != __lst_edge.end();
835  it_edge++)
836  {
837  MG_ARETE * candidate_edge = *it_edge;
838 
839  double t1=candidate_edge->get_tmin();
840  double t2=candidate_edge->get_tmax();
841 
842  int N=1;
843  double distance=0;
844  double dt = 0;
845  double t;
846  for (dt=.1*(t2-t1); fabs(dt) < .9*fabs(t2-t1); dt+=.1*(t2-t1))
847  {
848  MG_SEGMENT * closestSegToXYZ;
849  t=t1+dt;
850  double xyz[3];
851  candidate_edge->evaluer(t, xyz);
852  distance += Point_FindClosestSegment(xyz, __segs, closestSegToXYZ);
853  N++;
854  }
855  distance /= N;
856 
857  if (distance < minDist)
858  {
859  minDist = distance;
860  closestEdge = candidate_edge;
861  }
862  }
863 
864  if (new_lst_edge.size() == 0)
865  new_lst_edge.insert(closestEdge);
866 
867  __lst_edge = new_lst_edge;
868 }
869 
870 void
871 MG_MAILLAGE_OUTILS::FindCommonEdgesOfFaces(std::set< MG_FACE * > & __faces, std::set<MG_ARETE*> & __commonEdges)
872 {
873  std::map < MG_FACE * , std::set <MG_ARETE *> > map_faceEdges;
874  for ( std::set< MG_FACE * >::const_iterator
875  it_face = __faces.begin();
876  it_face != __faces.end();
877  it_face++ )
878  {
879  MG_FACE * face = *it_face;
880  std::set < MG_ARETE * > lst_edges;
881 
882  unsigned nb_loop = face->get_nb_mg_boucle();
883  for (unsigned it_loop = 0; it_loop < nb_loop; it_loop++)
884  {
885  MG_BOUCLE * loop = face->get_mg_boucle(it_loop);
886  unsigned nb_edge = loop->get_nb_mg_coarete();
887 
888  for (unsigned it_edge = 0; it_edge < nb_edge; it_edge++)
889  {
890  MG_ARETE * edge = loop->get_mg_coarete(it_edge)->get_arete();
891  lst_edges.insert(edge);
892  }
893  }
894  map_faceEdges [ face ] = lst_edges;
895  }
896 
897  std::set<MG_ARETE*> cEdges = (map_faceEdges.begin())->second;
898  std::map < MG_FACE * , std::set <MG_ARETE *> >::iterator start_faceEdges = map_faceEdges.begin();
899  std::advance(start_faceEdges, 1);
900  for ( std::set<MG_ARETE*>::const_iterator
901  it_edge = cEdges.begin();
902  it_edge != cEdges.end();
903  it_edge ++ )
904  {
905  MG_ARETE * common_edge = *it_edge;
906 
907 
908  for (std::map < MG_FACE * , std::set <MG_ARETE *> >::iterator
909  it_faceEdges = start_faceEdges;
910  it_faceEdges != map_faceEdges.end() && common_edge;
911  it_faceEdges ++)
912  {
913 
914  std::set <MG_ARETE *> & setEdges = it_faceEdges->second;
915  if ( setEdges.find(common_edge) == setEdges.end())
916  common_edge = NULL;
917  }
918 
919  if (common_edge)
920  __commonEdges.insert( common_edge );
921  }
922 }
923 void
924 MG_MAILLAGE_OUTILS::change_lien_maillage(MG_ELEMENT_TOPOLOGIQUE * __old_topo, MG_ELEMENT_TOPOLOGIQUE * __new_topo, MG_MAILLAGE * __mesh)
925 {
926  TPL_SET<MG_ELEMENT_MAILLAGE*> lien_maillage = * __old_topo->get_lien_maillage();
927  TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
928  MG_ELEMENT_MAILLAGE* element;
929  int nb = lien_maillage.get_nb();
930  int i=0,j,k;
931  for (element = lien_maillage.get_premier(it); i++ < nb && element ; element = lien_maillage.get_suivant(it) )
932  {
933  if ( ! __mesh || __mesh->contient ( (MG_IDENTIFICATEUR *)element ) )
934  {
935  element->change_lien_topologie(__new_topo);
936 
937  if ( element->get_dimension() == 1 )
938  {
939  MG_SEGMENT * seg = (MG_SEGMENT *) element;
940  if ( seg->get_noeud1()->get_lien_topologie() == __old_topo )
941  seg->get_noeud1()->change_lien_topologie(__new_topo);
942  if ( seg->get_noeud2()->get_lien_topologie() == __old_topo )
943  seg->get_noeud2()->change_lien_topologie(__new_topo);
944  }
945 
946  if ( element->get_dimension() == 2 )
947  {
948  MG_TRIANGLE * triangle = (MG_TRIANGLE *) element;
949  MG_SEGMENT * segment[3];
950  segment[0] = triangle->get_segment1();
951  segment[1] = triangle->get_segment2();
952  segment[2] = triangle->get_segment3();
953 
954  for (j=0; j<3; j++)
955  {
956  if ( segment[j]->get_lien_topologie() == __old_topo )
957  segment[j]->change_lien_topologie(__new_topo);
958  }
959 
960  MG_NOEUD * noeud[3];
961  noeud[0] = triangle->get_noeud1();
962  noeud[1] = triangle->get_noeud2();
963  noeud[2] = triangle->get_noeud3();
964 
965  for (j=0; j<3; j++)
966  {
967  if ( noeud[j]->get_lien_topologie() == __old_topo )
968  noeud[j]->change_lien_topologie(__new_topo);
969  }
970  }
971  }
972  }
973 }
974 
975 void MG_MAILLAGE_OUTILS::SplitEdgeInMesh(MG_MAILLAGE * __mesh, MG_ARETE * __origEdge, MG_SOMMET * __splitVertex, MG_ARETE * __arete_gauche, MG_ARETE * __arete_droite, MG_SEGMENT **__origSegment, MG_NOEUD ** __splitNode, MG_SEGMENT * __splitSegments[2])
976 {
977  int i,j,k;
978  double distance, minDist;
979  MG_ARETE * __splitEdges[2];
980  __splitEdges[0] = __arete_gauche;
981  __splitEdges[1] = __arete_droite;
982 
983  // Verify that the edge has not the split vertex in its mesh
984  TPL_SET<MG_ELEMENT_MAILLAGE*>* lien_maillage;
985  TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
986  MG_ELEMENT_MAILLAGE* element;
987  lien_maillage = __splitVertex->get_lien_maillage();
988  for (element = lien_maillage->get_premier(it); element ; element = lien_maillage->get_suivant(it) )
989  {
990  if (__mesh->contient(element))
991  {
992  MG_NOEUD * node = (MG_NOEUD*) element;
993  if (EdgeMeshHasNode(__mesh,__origEdge, node) )
994  {
995  printf("Can't insert vertex %ld in edge %ld\n", __splitVertex->get_id(), __origEdge->get_id());
996  printf("because edge has already a node on vertex !\n");
997  return;
998  }
999  }
1000  }
1001 
1002  // find wether a node of the mesh is coicident to the splitVertex
1003  double splitVertexCoord[3];
1004  __splitVertex->get_point()->evaluer(splitVertexCoord);
1005 
1006  double origEdgeLength = __origEdge->get_longueur(__origEdge->get_tmin(), __origEdge->get_tmax());
1007 
1008  minDist = 1E100;
1009  MG_NOEUD * coincidentNode = NULL;
1010  LISTE_MG_NOEUD::iterator itNode;
1011  MG_NOEUD * node;
1012  for (node = __mesh->get_premier_noeud(itNode);
1013  node ; node = __mesh->get_suivant_noeud(itNode) )
1014  {
1015  if ( node->get_lien_topologie() != __origEdge )
1016  continue;
1017 
1018  double xyz[3];
1019  xyz[0] = node->get_x();
1020  xyz[1] = node->get_y();
1021  xyz[2] = node->get_z();
1022 
1023  distance = OT_ALGORITHME_GEOMETRIQUE::VEC3_DISTANCE_VEC3(xyz,splitVertexCoord);
1024 
1025  if (distance / origEdgeLength < 1E-6)
1026  {
1027  if (distance < minDist)
1028  {
1029  minDist = distance;
1030  coincidentNode = node;
1031  }
1032  }
1033  }
1034 
1035 
1036  lien_maillage = __origEdge->get_lien_maillage();
1037 
1038  int nbSegBeforeSplit;
1039  int nbOfNodesDim0 = 0;
1040  EdgeMeshStats(__mesh, __origEdge,nbSegBeforeSplit,nbOfNodesDim0);
1041  if (coincidentNode)
1042  {
1043  coincidentNode->change_lien_topologie(__splitVertex);
1044 
1045  // No split node was inserted on the edge's mesh !
1046  *__splitNode = NULL;
1047  // No new segment were inserted on the edge's mesh
1048  // No segment was deleted on the edge's mesh
1049  __splitSegments[0] = __splitSegments[1] = *__origSegment = NULL;
1050  }
1051  else
1052  {
1053  *__splitNode = new MG_NOEUD(__splitVertex, splitVertexCoord[0],splitVertexCoord[1],splitVertexCoord[2],MAGIC::ORIGINE::MODIFICATION);
1054  __mesh->ajouter_mg_noeud(*__splitNode);
1055 
1056  // get the closest segment to *__splitNode
1057  minDist = 1E100;
1058  for (element = lien_maillage->get_premier(it); element ; element = lien_maillage->get_suivant(it) )
1059  {
1060  if ( __mesh->contient ( (MG_IDENTIFICATEUR *)element ) )
1061  {
1062  MG_SEGMENT * seg = (MG_SEGMENT*) element;
1063 
1064  MG_NOEUD * nos[2];
1065  nos[0] = seg->get_noeud1();
1066  nos[1] = seg->get_noeud2();
1067 
1068  double xyzSeg[2][3];
1069  for (i=0; i<2; i++)
1070  {
1071  xyzSeg[i][0] = nos[i]->get_x();
1072  xyzSeg[i][1] = nos[i]->get_y();
1073  xyzSeg[i][2] = nos[i]->get_z();
1074  }
1075 
1076  distance = OT_ALGORITHME_GEOMETRIQUE::Dist3D_Point_Segment(xyzSeg[0], xyzSeg[1], splitVertexCoord);
1077  if (distance < minDist)
1078  {
1079  minDist = distance;
1080  *__origSegment = seg;
1081  }
1082  }
1083  }
1084 
1085  // split node, split segments, and original segment are return values
1086  MG_MAILLAGE_OUTILS::inserer_noeud_segment(__mesh, *__splitNode, *__origSegment, __splitSegments, false);
1087  // split segments are relocated on the original edge
1088  // (they'll both be relocated on their respective split edges afterwards)
1089  __splitSegments[0]->change_lien_topologie(__origEdge);
1090  __splitSegments[1]->change_lien_topologie(__origEdge);
1091  // split node is relocated on the split vertex
1092  (*__splitNode)->change_lien_topologie(__splitVertex);
1093 
1094  int nbSegAfterSplit;
1095  EdgeMeshStats(__mesh, __origEdge,nbSegAfterSplit,nbOfNodesDim0);
1096  if ( nbSegAfterSplit-1 != nbSegBeforeSplit )
1097  {
1098  printf("The edge %ld contains %d segments before split and %d after split \n", __origEdge->get_id(),nbSegBeforeSplit, nbSegAfterSplit);
1099  }
1100  else
1101  {
1102  printf("The edge %ld contains %d segments after split \n", __origEdge->get_id(), nbSegAfterSplit);
1103  }
1104 
1105  }
1106 
1107  // Sort segment and nodes of the edge
1108  std::vector <MG_NOEUD*> sequence_of_nodes;
1109  std::vector <MG_SEGMENT*> sequence_of_segments;
1110  std::set<MG_SEGMENT*> set_of_segments_of_edge;
1111  for (element = lien_maillage->get_premier(it); element; element = lien_maillage->get_suivant(it) )
1112  {
1113  MG_SEGMENT * seg = (MG_SEGMENT*)element;
1114  if (__mesh->contient(seg) )
1115  set_of_segments_of_edge.insert( seg );
1116  }
1117  printf("Edge %ld containing %d segments is split in mesh\n", __origEdge->get_id(), (int)set_of_segments_of_edge.size());
1118 
1119 
1120  std::set <MG_ARETE*> lst_edge;
1121  lst_edge.insert(__splitEdges[0]);
1122  lst_edge.insert(__splitEdges[1]);
1123 
1124 
1125  int nSegs;
1126  EdgeMeshStats(__mesh, __origEdge, nSegs, nbOfNodesDim0);
1127  if (nbOfNodesDim0 != 3)
1128  printf("Problem : there is less than 3 nodes having a vertex attached!\n");
1129 
1130  while ( lst_edge.size() && set_of_segments_of_edge.size() )
1131  {
1132  sequence_of_segments.clear();
1133  sequence_of_nodes.clear();
1134  MG_MAILLAGE_OUTILS::classe_elements_dimension1(set_of_segments_of_edge, sequence_of_segments, sequence_of_nodes );
1135 
1136  if (sequence_of_nodes.size() == 0)
1137  {
1138  printf("nodes = 0\n");
1139  continue;
1140  }
1141 
1142  MG_ARETE * topoEdge=0;
1143  std::set <MG_SOMMET *> vertices;
1144  vertices.insert((MG_SOMMET*)sequence_of_nodes[0]->get_lien_topologie());
1145  vertices.insert((MG_SOMMET*)sequence_of_nodes[sequence_of_nodes.size()-1]->get_lien_topologie());
1146 
1147  MG_ARETE * firstEdge = * lst_edge.begin();
1148  if (lst_edge.size() == 1)
1149  topoEdge = firstEdge;
1150  else
1151  {
1152  MG_MAILLAGE_OUTILS::IdentifyEdge5(vertices, lst_edge, sequence_of_nodes, sequence_of_segments, &topoEdge);
1153 
1154  if (topoEdge == NULL)
1155  {
1156  MG_MAILLAGE_OUTILS::IdentifyEdge5(vertices, lst_edge, sequence_of_nodes, sequence_of_segments, &topoEdge);
1157  }
1158  }
1159 
1160  lst_edge.erase(topoEdge);
1161 
1162  std::vector <MG_SEGMENT*>::iterator itSegs;
1163  for (itSegs = sequence_of_segments.begin();itSegs != sequence_of_segments.end();itSegs++)
1164  {
1165  MG_SEGMENT * seg = (*itSegs);
1166  seg->change_lien_topologie(topoEdge);
1167 
1168  if ( seg->get_noeud1()->get_lien_topologie() == __origEdge )
1169  seg->get_noeud1()->change_lien_topologie2(topoEdge);
1170  if ( seg->get_noeud2()->get_lien_topologie() == __origEdge )
1171  seg->get_noeud2()->change_lien_topologie2(topoEdge);
1172  }
1173 
1174  if (topoEdge != NULL)
1175  printf("debug: %d segments classified on edge %lu\n", (int)sequence_of_segments.size(), topoEdge->get_id() );
1176  }
1177 
1178  for (int i=0;i<2;i++)
1179  {
1180  EdgeMeshStats(__mesh, __splitEdges[i], nSegs, nbOfNodesDim0);
1181  if (nbOfNodesDim0 != 2)
1182  printf("Problem edge %ld : there is less than 2 nodes having a vertex attached!\n", __splitEdges[i]->get_id());
1183  }
1184 
1185  while (set_of_segments_of_edge.size() != 0)
1186  {
1187  printf("Warning : %d segments of split edges have not been classified !\n", (int)set_of_segments_of_edge.size() );
1188 
1189  {
1190  sequence_of_segments.clear();
1191  sequence_of_nodes.clear();
1192  MG_MAILLAGE_OUTILS::classe_elements_dimension1(set_of_segments_of_edge, sequence_of_segments, sequence_of_nodes );
1193  std::set <MG_ARETE*> candidateEdges;
1194  candidateEdges.insert(__splitEdges[0]);
1195  candidateEdges.insert(__splitEdges[1]);
1196  MG_ARETE * topoEdge=0;
1197  _FilterGeometricTolerance5(sequence_of_nodes, sequence_of_segments, candidateEdges);
1198  if (candidateEdges.size())
1199  {
1200  topoEdge = *(candidateEdges.begin());
1201  std::vector<MG_SEGMENT*>::iterator itSegs;
1202  for (itSegs = sequence_of_segments.begin();itSegs != sequence_of_segments.end();itSegs++)
1203  {
1204  MG_SEGMENT * seg = (*itSegs);
1205  seg->change_lien_topologie(topoEdge);
1206  }
1207  }
1208  }
1209  }
1210 }
1211 
1212 void MG_MAILLAGE_OUTILS::Conformity_CloseSurfaceMesh(MG_MAILLAGE * __tess, double __tolerance)
1213 {
1214  std::set <MG_SEGMENT * > free_segs;
1215  std::set <MG_NOEUD * > free_segs_nodes;
1216  std::set <MG_SEGMENT * >::iterator it_free_segs;
1217  std::set <MG_NOEUD * >::iterator it_free_segs_nodes;
1218  LISTE_MG_SEGMENT::iterator itSeg;
1219  for (MG_SEGMENT * seg=__tess->get_premier_segment(itSeg);
1220  seg; seg=__tess->get_suivant_segment(itSeg))
1221  {
1222  if ( seg->get_lien_triangle()->get_nb() == 1 )
1223  {
1224  free_segs.insert(seg);
1225  free_segs_nodes.insert (seg->get_noeud1());
1226  free_segs_nodes.insert (seg->get_noeud2());
1227  }
1228  }
1229 
1230  unsigned N = free_segs.size();
1231  for (unsigned i=0; i<N; i++)
1232  {
1233  MG_SEGMENT * seg1 = *(free_segs.begin());
1234  double *seg1P1=seg1->get_noeud1()->get_coord();
1235  double *seg1P2=seg1->get_noeud2()->get_coord();
1236  MG_NOEUD * closest_node=0;
1237  double dist_closest_node=1E300;
1238 
1239  for (it_free_segs_nodes=free_segs_nodes.begin();it_free_segs_nodes!=free_segs_nodes.end();it_free_segs_nodes++)
1240  {
1241  MG_NOEUD * no = *it_free_segs_nodes;
1242  if (no == seg1->get_noeud1() || no == seg1->get_noeud2()) continue;
1243  double distance = OT_ALGORITHME_GEOMETRIQUE::Dist3D_Point_Segment(seg1P1,seg1P2,no->get_coord());
1244  if (distance < dist_closest_node)
1245  {
1246  dist_closest_node = distance;
1247  closest_node = no;
1248  }
1249  }
1250 
1251  MG_SEGMENT * new_segs[2]={0,0};
1252  if (closest_node != 0 && dist_closest_node < __tolerance)
1253  {
1254  inserer_noeud_segment(__tess, closest_node, seg1, new_segs, true);
1255  free_segs.erase(seg1);
1256  free_segs_nodes.erase(seg1->get_noeud1());
1257  free_segs_nodes.erase(seg1->get_noeud2());
1258  for (int i=0; i<2; i++)
1259  {
1260  if (new_segs[i]->get_lien_triangle()->get_nb() == 1 )
1261  {
1262  free_segs.insert(new_segs[i]);
1263  free_segs_nodes.insert (new_segs[i]->get_noeud1());
1264  free_segs_nodes.insert (new_segs[i]->get_noeud2());
1265  }
1266  }
1267  }
1268  }
1269 
1270 }
1271 
1272 MG_MAILLAGE_OUTILS::MG_MAILLAGE_OUTILS():mai(NULL)
1273 {
1274 
1275 }
1276 
1277 MG_MAILLAGE_OUTILS::MG_MAILLAGE_OUTILS(MG_MAILLAGE* maitmp):mai(maitmp)
1278 {
1279 
1280 }
1281 MG_MAILLAGE_OUTILS::MG_MAILLAGE_OUTILS(MG_MAILLAGE_OUTILS& mdd):mai(mdd.mai)
1282 {
1283 
1284 }
1285 
1286 MG_MAILLAGE_OUTILS::~MG_MAILLAGE_OUTILS()
1287 {
1288 
1289 }
1290 
1291 
1292 
1293 
1294 
1295 
1296 void MG_MAILLAGE_OUTILS::calcul_courbure(MG_GESTIONNAIRE& gest,char* solnom,int nummai,int numgeo,char* outputgestnom)
1297 {
1298 std::map<std::string,double> liste_kmin;
1299  std::map<std::string,double> liste_kmax;
1300  TPL_MAP_ENTITE<MG_NOEUD *> lst1;
1301  TPL_MAP_ENTITE<MG_NOEUD *> ::ITERATEUR itlst1;
1302  TPL_MAP_ENTITE<MG_NOEUD *> lst2;
1303  TPL_MAP_ENTITE<MG_NOEUD *> ::ITERATEUR itlst2;
1304  TPL_MAP_ENTITE<MG_NOEUD *> lst3;
1305  TPL_MAP_ENTITE<MG_NOEUD *> ::ITERATEUR itlst3;
1306  MG_MAILLAGE* mai;
1307  if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
1308  MG_GEOMETRIE * geo1;
1309  if (numgeo==0) geo1=gest.get_mg_geometrie(numgeo); else geo1=gest.get_mg_geometrieid(numgeo);
1310  int nb1=mai->get_nb_mg_noeud();
1311  int nb3=mai->get_nb_mg_triangle();
1312  int nb2=mai->get_nb_mg_segment();
1313  int nb4=mai->get_nb_mg_tetra();
1314  int nbface=geo1->get_nb_mg_face();
1315  printf("%d,%d,%d,%d,%d\n",nb1,nb2,nb3,nb4,nbface);
1316  for (int i=0;i<nbface;i++)
1317  {
1318  MG_FACE* face=geo1->get_mg_face(i);
1319  double o=face->get_mg_coface(0)->get_orientation();
1320  int x= face->get_lien_maillage()->get_nb();
1321  for( int j=0;j<x;j++)
1322  {
1323  MG_TRIANGLE * tr=(MG_TRIANGLE *) face->get_lien_maillage()->get(j);
1324  MG_NOEUD * no1=tr->get_noeud1();
1325  MG_NOEUD * no2=tr->get_noeud2();
1326  MG_NOEUD * no3=tr->get_noeud3();
1327  lst1.ajouter(no1);
1328  lst2.ajouter(no2);
1329  lst3.ajouter(no3);
1330  double xyz1[3],dxyz1[3];
1331  double xyz2[3],dxyz2[3];
1332  double xyz3[3],dxyz3[3];
1333 
1334  xyz1[0]=no1->get_x();
1335  xyz1[1]=no1->get_y();
1336  xyz1[2]=no1->get_z();
1337  xyz2[0]=no2->get_x();
1338  xyz2[1]=no2->get_y();
1339  xyz2[2]=no2->get_z();
1340  xyz3[0]=no3->get_x();
1341  xyz3[1]=no3->get_y();
1342  xyz3[2]=no3->get_z();
1343 
1344  double uv1[2];
1345  double uv2[2];
1346  double uv3[2];
1347  double E1,F1,G1,L1,M1,N1;
1348  double E2,F2,G2,L2,M2,N2;
1349  double E3,F3,G3,L3,M3,N3;
1350  double normal1;
1351 
1352  face->inverser(uv1,xyz1);
1353  face->get_EFG(uv1,E1,F1,G1);
1354  face->get_LMN(uv1,L1,M1,N1);
1355  double L11=L1*o*(-1);
1356  double M11=M1*o*(-1);
1357  double N11=N1*o*(-1);
1358  double a1=E1*G1-F1*F1;
1359  double b1=E1*N11+G1*L11-2*F1*M11;
1360  double c1=L11*N11-M11*M11;
1361  double K1=c1/a1;
1362  double H1=b1/2./a1;
1363  double kma1=(H1+sqrt((H1*H1)-K1));
1364  double kmi1=(H1-sqrt((H1*H1)-K1));
1365  //printf("kmax1 %lf kmin1 %lf \n",kma1,kmi1);
1366 
1367  face->inverser(uv2,xyz2);
1368  face->get_EFG(uv2,E2,F2,G2);
1369  face->get_LMN(uv2,L2,M2,N2);
1370  double L22=L2*o*(-1);
1371  double M22=M2*o*(-1);
1372  double N22=N2*o*(-1);
1373  double a2=E2*G2-F2*F2;
1374  double b2=E2*N22+G2*L22-2*F2*M22;
1375  double c2=L22*N22-M22*M22;
1376  double K2=c2/a2;
1377  double H2=b2/2./a2;
1378  double kma2=(H2+sqrt((H2*H2)-K2));
1379  double kmi2=(H2-sqrt((H2*H2)-K2));
1380  //printf("kmax2 %lf kmin2 %lf \n",kma2,kmi2);
1381 
1382  face->inverser(uv3,xyz3);
1383  face->get_EFG(uv3,E3,F3,G3);
1384  face->get_LMN(uv3,L3,M3,N3);
1385  double L33=L3*o*(-1);
1386  double M33=M3*o*(-1);
1387  double N33=N3*o*(-1);
1388  double a3=E3*G3-F3*F3;
1389  double b3=E3*N33+G3*L33-2*F3*M33;
1390  double c3=L33*N33-M33*M33;
1391  double K3=c3/a3;
1392  double H3=b3/2./a3;
1393  double kma3=(H3+sqrt((H3*H3)-K3));
1394  double kmi3=(H3-sqrt((H3*H3)-K3));
1395  //printf("kmax3 %lf kmin3 %lf \n",kma3,kmi3);
1396 
1397 
1398  unsigned long idface=tr->get_lien_topologie()->get_id();
1399  unsigned long idnoeud1=no1->get_id();
1400  unsigned long idnoeud2=no2->get_id();
1401  unsigned long idnoeud3=no3->get_id();
1402  char mess[500];
1403  sprintf(mess,"%lu_%lu",idnoeud1,idface);
1404  // liste_H[mess]=H;
1405  // liste_K[mess]=K;
1406  liste_kmax[mess]=kma1;
1407  liste_kmin[mess]=kmi1;
1408  sprintf(mess,"%lu_%lu",idnoeud2,idface);
1409  // liste_H[mess]=H;
1410  // liste_K[mess]=K;
1411  liste_kmax[mess]=kma2;
1412  liste_kmin[mess]=kmi2;
1413  sprintf(mess,"%lu_%lu",idnoeud3,idface);
1414  // liste_H[mess]=H;
1415  // liste_K[mess]=K;
1416  liste_kmax[mess]=kma3;
1417  liste_kmin[mess]=kmi3;
1418  }
1419 
1420  }
1421 
1422  MG_SOLUTION* sol=new MG_SOLUTION(mai,2,(char*) solnom,1,(char*)"Geomertic_courbure_solution",MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD,MAGIC::TYPE_SOLUTION::SCALAIRE);
1423  gest.ajouter_mg_solution(sol);
1424  sol->change_legende(0,"Kmin");
1425  sol->change_legende(1,"Kmax");
1426  LISTE_MG_TRIANGLE::iterator ittri;
1427  int compte=0;
1428 
1429  for (MG_TRIANGLE* tri=mai->get_premier_triangle(ittri);tri!=NULL;tri=mai->get_suivant_triangle(ittri))
1430  {
1431  MG_NOEUD *no1=tri->get_noeud1();
1432  MG_NOEUD *no2=tri->get_noeud2();
1433  MG_NOEUD *no3=tri->get_noeud3();
1434  char mess[500];
1435  sprintf(mess,"%lu_%lu",no1->get_id(),tri->get_lien_topologie()->get_id());
1436  double valeur0=liste_kmin[mess];
1437  double valeur1=liste_kmax[mess];
1438  sol->ecrire(valeur0,compte,0,0);
1439  sol->ecrire(valeur1,compte,1,0);
1440  sprintf(mess,"%lu_%lu",no2->get_id(),tri->get_lien_topologie()->get_id());
1441  valeur0=liste_kmin[mess];
1442  valeur1=liste_kmax[mess];
1443  sol->ecrire(valeur0,compte,0,1);
1444  sol->ecrire(valeur1,compte,1,1);
1445  sprintf(mess,"%lu_%lu",no3->get_id(),tri->get_lien_topologie()->get_id());
1446  valeur0=liste_kmin[mess];
1447  valeur1=liste_kmax[mess];
1448  sol->ecrire(valeur0,compte,0,2);
1449  sol->ecrire(valeur1,compte,1,2);
1450  compte++;
1451  }
1452  gest.enregistrer((char*) outputgestnom);
1453  OT_CPU cpu;
1454  cpu.ajouter_etape("version 1 du for");
1455  cpu.ajouter_etape("version 3 du for");
1456  std::vector<std::string> tab;
1457  cpu.get_tabfinal(tab);
1458  for (int i=0;i<tab.size();i++)
1459  printf("%s\n",(char*)tab[i].c_str());
1460 }
1461 
1462 
1463 
1464 void MG_MAILLAGE_OUTILS::calcul_courbure_discrete(MG_GESTIONNAIRE& gest, char* solnom, int nummai,char* outputgestnom,int opensurafece)
1465 {
1466  MG_MAILLAGE* mai;
1467  if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
1468  int geonb=gest.get_nb_mg_geometrie();
1469  //if (geonb>0) MG_GEOMETRIE * geo1=gest.get_mg_geometrie(0); // wht if we dont have geometry???????????????????
1470 
1471  OT_CPU cpu;
1472  cpu.ajouter_etape("version 1 du for");
1473 
1474  std::map<std::string,double> liste_kmin;
1475  std::map<std::string,double> liste_kmax;
1476  std::map<std::string,double> liste_gau;
1477  std::map<std::string,double> liste_courburemax1;
1478  std::map<std::string,double> liste_courburemax2;
1479  std::map<std::string,double> liste_courburemax3;
1480  std::map<std::string,double> liste_courburemax4;
1481  std::map<std::string,double> liste_courburemax5;
1482  LISTE_MG_NOEUD::iterator it;
1483  int l=0.;
1484 
1485  // calcul courbure ********************************
1486 
1487  for (MG_NOEUD* noeud=mai->get_premier_noeud(it);noeud!=NULL;noeud=mai->get_suivant_noeud(it))
1488  {
1489  l++;
1490  //printf("%d\n",l);
1491  double kmin1=0.;
1492  double kmax1=0.;
1493  double kmin2=0.;
1494  double kmax2=0.;
1495  MG_MAILLAGE_OUTILS *cou;
1496  cou->calcul_courbure_face_arete_sommet(noeud,kmin1,kmax1,kmin2,kmax2,liste_kmin,liste_kmax,liste_gau,liste_courburemax1,liste_courburemax2,liste_courburemax3,liste_courburemax4,liste_courburemax5,opensurafece);
1497  }
1498 
1499  // affichage sur GMSH ******************************
1500 
1501  MG_SOLUTION* sol=new MG_SOLUTION(mai,3,(char*)solnom,1,(char*)"discrete_curboure_solution",MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD,MAGIC::TYPE_SOLUTION::SCALAIRE);
1502  gest.ajouter_mg_solution(sol);
1503  sol->change_legende(0,"Kmin");
1504  sol->change_legende(1,"Kmax");
1505  sol->change_legende(2,"K_gau");
1506  LISTE_MG_TRIANGLE::iterator ittri;
1507  int compte=0;
1508  for (MG_TRIANGLE* tri=mai->get_premier_triangle(ittri);tri!=NULL;tri=mai->get_suivant_triangle(ittri))
1509  {
1510  MG_NOEUD *no1=tri->get_noeud1();
1511  MG_NOEUD *no2=tri->get_noeud2();
1512  MG_NOEUD *no3=tri->get_noeud3();
1513  char mess[500];
1514  sprintf(mess,"%lu_%lu",no1->get_id(),tri->get_lien_topologie()->get_id());
1515  double valeur0=liste_kmin[mess];
1516  double valeur1=liste_kmax[mess];
1517  double valeur2=liste_gau[mess];
1518  sol->ecrire(valeur0,compte,0,0);
1519  sol->ecrire(valeur1,compte,1,0);
1520  sol->ecrire(valeur2,compte,2,0);
1521  sprintf(mess,"%lu_%lu",no2->get_id(),tri->get_lien_topologie()->get_id());
1522  valeur0=liste_kmin[mess];
1523  valeur1=liste_kmax[mess];
1524  valeur2=liste_gau[mess];
1525  sol->ecrire(valeur0,compte,0,1);
1526  sol->ecrire(valeur1,compte,1,1);
1527  sol->ecrire(valeur2,compte,2,1);
1528  sprintf(mess,"%lu_%lu",no3->get_id(),tri->get_lien_topologie()->get_id());
1529  valeur0=liste_kmin[mess];
1530  valeur1=liste_kmax[mess];
1531  valeur2=liste_gau[mess];
1532  sol->ecrire(valeur0,compte,0,2);
1533  sol->ecrire(valeur1,compte,1,2);
1534  sol->ecrire(valeur2,compte,2,2);
1535  compte++;
1536  }
1537 
1538 
1539  // enregistrement de données dans un fichier execl ***********
1540 
1541  std::ofstream fichier("fichierhistogram1.csv",std::ios_base::app );
1542  if( fichier.is_open() )
1543  {
1544  int u=0;
1545  for (MG_NOEUD* noeu=mai->get_premier_noeud(it);noeu!=NULL;noeu=mai->get_suivant_noeud(it))
1546  {
1547  u++;
1548  char mess1[500];
1549  sprintf(mess1,"%lu",noeu->get_id());
1550  double valeur1=liste_courburemax1[mess1];
1551  double valeur2=liste_courburemax2[mess1];
1552  double valeur3=liste_courburemax3[mess1];
1553  double valeur4=liste_courburemax4[mess1];
1554  double valeur5=liste_courburemax5[mess1];
1555  //double valeur6=liste_courburemax6[mess1];
1556  //double valeur7=liste_courburemax7[mess1];
1557  //double valeur8=liste_courburemax8[mess1];
1558  //double valeur9=liste_courburemax9[mess1];
1559  fichier << u <<'\t'<< std::setprecision(10) <<valeur1 <<'\t'<<std::setprecision(10) <<valeur2<<'\t'<<std::setprecision(10) <<valeur3<<'\t'<<std::setprecision(10) <<valeur4<<'\t'<<std::setprecision(10) <<valeur5<<std::endl;
1560  fichier << std::fixed;
1561  }
1562  }
1563  gest.enregistrer((char*) outputgestnom);
1564  // temps de reponse*************************************************
1565 
1566  cpu.ajouter_etape("version 3 du for");
1567  std::vector<std::string> tab;
1568  cpu.get_tabfinal(tab);
1569  for (int i=0;i<tab.size();i++)
1570  printf("%s\n",(char*)tab[i].c_str());
1571 
1572 }
1573 
1574 
1575 void MG_MAILLAGE_OUTILS::calcul_courbure_face_arete_sommet(MG_NOEUD* noeud, double& kmin1, double& kmax1, double& kmin2, double& kmax2, std::map< std::string, double >& liste_kmin, std::map< std::string, double >& liste_kmax,std::map<std::string,double> &liste_gau, std::map< std::string, double >& liste_courburemax1, std::map< std::string, double >& liste_courburemax2, std::map< std::string, double >& liste_courburemax3, std::map< std::string, double >& liste_courburemax4, std::map< std::string, double >& liste_courburemax5,int opensurafece)
1576 
1577 {
1578 
1579 
1580  //-------------------noeuds sur les faces du modele CAO--------------------------
1581  if (noeud->get_lien_topologie()->get_dimension()==2 || opensurafece>0) //sasan
1582  {
1583  double kmin=0.;
1584  double kmax=0.;
1585  MG_MAILLAGE_OUTILS * cou;
1586  cou->calcul_courbure_face(noeud,kmin,kmax,liste_kmin,liste_kmax,liste_gau,liste_courburemax1,liste_courburemax2,liste_courburemax3,liste_courburemax4,liste_courburemax5);
1587  }
1588  //-------------------noeuds sur les arets du modele CAO--------------------------
1589 
1590  if (noeud->get_lien_topologie()->get_dimension()==1 && opensurafece==0 ) //sasan
1591  {
1592  double kmin1;
1593  double kmax1;
1594  double kmin2;
1595  double kmax2;
1596  MG_MAILLAGE_OUTILS * cou;
1597  cou->calcul_courbure_arete(noeud,kmin1,kmax1,kmin2,kmax2,liste_kmin,liste_kmax);
1598  }
1599 
1600  //-------------------noeuds sur les sommets du modele CAO--------------------------
1601 /*
1602  if (noeud->get_lien_topologie()->get_dimension()==0)
1603  {
1604  double kmin1=0.;
1605  double kmax1=0.;
1606  double kmin2=0.;
1607  double kmax2=0.;
1608  MG_MAILLAGE_OUTILS * cou;
1609  cou->calcul_courbure_sommet(mai,noeud,kmin1,kmax1,kmin2,kmax2,liste_kmin,liste_kmax);
1610  }
1611  */
1612 
1613 }
1614 
1615 
1616 void MG_MAILLAGE_OUTILS::calcul_courbure_arete(MG_NOEUD* noeud, double& kmin1, double& kmax1, double& kmin2, double& kmax2, std::map< std::string, double >& liste_kmin, std::map< std::string, double >& liste_kmax)
1617 {
1618  double cmin1=0.;
1619  double cmin2=0.;
1620  double cmax1=0.;
1621  double cmax2=0.;
1622  MG_GEOMETRIE_OUTILS virt;
1623  MG_ARETE* aret=(MG_ARETE*)noeud->get_lien_topologie();
1624  double vir=virt.arete_virtuelle(aret);
1625 
1626  // MG_MAILLAGE_OUTILS cour(mai);
1627  // double hj=cour.get_courbure_geo_virtuelle(aret);
1628  if(vir==0)
1629 
1630  {
1631  printf("aret non virtuel\n");
1632  double kmin1=0.;
1633  double kmax1=0.;
1634  double kmin2=0.;
1635  double kmax2=0.;
1636 
1637  MG_MAILLAGE_OUTILS * cou;
1638  cou->calcul_courbure_arete_nonvirtuelle(noeud,kmin1,kmax1,kmin2,kmax2,liste_kmin,liste_kmax);
1639  printf("kmax1 %lf kmin1 %lf \n",kmax1,kmin1);
1640  printf("kmax2 %lf kmin2 %lf \n",kmax2,kmin2);
1641  }
1642  else if(vir==2)
1643  {
1644  printf("aret virtuel \n");
1645  double cmax1=0.;
1646  double cmax2=0.;
1647  double cmin1=0.;
1648  double cmin2=0.;
1649  // if(hj==1)
1650  // {
1651  // printf("arret virtuel\n");
1652  double kmin=0.;
1653  double kmax=0.;
1654  MG_MAILLAGE_OUTILS * cou;
1655  cou->calcul_courbure_arete_virtuelle(noeud,kmin,kmax,liste_kmin,liste_kmax);
1656  printf("kmax %lf kmin %lf \n",kmax,kmin);
1657  // }
1658 
1659  }
1660 }
1661 
1662 void MG_MAILLAGE_OUTILS::calcul_courbure_sommet(MG_NOEUD* noeud, double& kmin1, double& kmax1, double& kmin2, double& kmax2, std::map< std::string, double >& liste_kmin, std::map< std::string, double >& liste_kmax)
1663 {
1664  MG_SOMMET * sommet=(MG_SOMMET*)noeud->get_lien_topologie();
1665  int nbcosom=sommet->get_nb_mg_cosommet();
1666  //printf("nb : %d \n",nbcosom);
1667 
1668  TPL_MAP_ENTITE<MG_FACE *> lst100;
1669  TPL_MAP_ENTITE<MG_FACE *> ::ITERATEUR itlst100;
1670  TPL_MAP_ENTITE<MG_FACE *> lst200;
1671  TPL_MAP_ENTITE<MG_FACE *> ::ITERATEUR itlst200;
1672  TPL_MAP_ENTITE<MG_FACE *> lst601;
1673  TPL_MAP_ENTITE<MG_FACE *> ::ITERATEUR itlst601;
1674  TPL_MAP_ENTITE<MG_FACE *> lst602;
1675  TPL_MAP_ENTITE<MG_FACE *> ::ITERATEUR itlst602;
1676  TPL_MAP_ENTITE<MG_TRIANGLE *> lst500;
1677  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst500;
1678  TPL_MAP_ENTITE<MG_SEGMENT *> lst600;
1679  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst600;
1680  TPL_MAP_ENTITE<MG_TRIANGLE *> lst700;
1681  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst700;
1682  TPL_MAP_ENTITE<MG_TRIANGLE *> lst800;
1683  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst800;
1684  TPL_MAP_ENTITE<MG_SEGMENT *> lst701;
1685  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst701;
1686  TPL_MAP_ENTITE<MG_SEGMENT *> lst801;
1687  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst801;
1688 
1689  TPL_MAP_ENTITE<MG_ARETE *> lst102;
1690  TPL_MAP_ENTITE<MG_ARETE *> ::ITERATEUR itlst102;
1691  TPL_MAP_ENTITE<MG_ARETE *> lst105;
1692  TPL_MAP_ENTITE<MG_ARETE *> ::ITERATEUR itlst105;
1693 
1694  for(int ggo=0;ggo<nbcosom;ggo++)
1695  {
1696  MG_COSOMMET * cosom1=sommet->get_mg_cosommet(ggo);
1697  MG_ARETE * aret2=cosom1->get_arete();
1698 
1699 
1700  lst105.ajouter(aret2);
1701  }
1702 
1703  TPL_MAP_ENTITE<MG_ARETE *> lst106;
1704  TPL_MAP_ENTITE<MG_ARETE *> ::ITERATEUR itlst106;
1705  TPL_MAP_ENTITE<MG_ARETE *> lst107;
1706  TPL_MAP_ENTITE<MG_ARETE *> ::ITERATEUR itlst107;
1707  MG_ARETE * a;
1708  for(a=lst105.get_premier(itlst105);a;a=lst105.get_suivant(itlst105))
1709  {
1710  MG_GEOMETRIE_OUTILS virt2;
1711  double vir2=virt2.arete_virtuelle(a);
1712  if(vir2==0)
1713  {
1714  lst106.ajouter(a);
1715  }
1716 
1717  else if(vir2==1)
1718  {
1719  lst107.ajouter(a);
1720  }
1721  }
1722  int aaa=lst107.get_nb();
1723  // printf("nbre de aret %d \n",aaa);
1724 
1725  MG_ARETE *ar;
1726  if(aaa==1)
1727  {
1728 
1729  for(ar=lst107.get_premier(itlst107);ar;ar=lst107.get_suivant(itlst107))
1730  {
1731  double cmin1=0.;
1732  double cmax1=0.;
1733  double cmin2=0.;
1734  double cmax2=0.;
1735  // COURBURE_CLASS *cou;
1736  // cou->verifier_face_arete_geo(mai,ar,cmin1,cmax1,cmin2,cmax2);
1737 
1738  MG_GEOMETRIE_OUTILS cour;
1739 
1740  double hj=cour.arete_virtuelle(ar);
1741 
1742  // printf("cmax1 %lf \n",cmax1);
1743  // printf("cmax2 %lf \n",cmax2);
1744 
1745  if(hj==2)
1746  {
1747 
1748  for(int gg=0;gg<nbcosom;gg++)
1749  {
1750  MG_COSOMMET * cosom=sommet->get_mg_cosommet(gg);
1751  MG_ARETE * aret=cosom->get_arete();
1752  lst102.ajouter(aret);
1753 
1754  int nbcoaret=aret->get_nb_mg_coarete();
1755  MG_GEOMETRIE_OUTILS virt;
1756  double vir=virt.arete_virtuelle(aret);
1757 
1758 
1759 
1760  for(int ggg=0;ggg<nbcoaret;ggg++)
1761  {
1762  MG_FACE *face=aret->get_mg_coarete(ggg)->get_boucle()->get_mg_face();
1763  if(vir==0)
1764  {
1765  lst100.ajouter(face);
1766  }
1767  else if(vir==1)
1768  {
1769  lst200.ajouter(face);
1770  }
1771  }
1772  }
1773  TPL_MAP_ENTITE<MG_FACE *> lst101;
1774  TPL_MAP_ENTITE<MG_FACE *> ::ITERATEUR itlst101;
1775  TPL_MAP_ENTITE<MG_FACE *> lst201;
1776  TPL_MAP_ENTITE<MG_FACE *> ::ITERATEUR itlst201;
1777  MG_FACE *fac1;
1778  MG_FACE *fac2;
1779  MG_FACE *fac3;
1780  MG_FACE *fac7;
1781  for(fac1=lst100.get_premier(itlst100);fac1;fac1=lst100.get_suivant(itlst100))
1782  {
1783  //printf("face 1 %lu \n",fac1->get_id());
1784  for(fac2=lst200.get_premier(itlst200);fac2;fac2=lst200.get_suivant(itlst200))
1785  {
1786  //printf("face 2 %lu \n",fac2->get_id());
1787  if(fac1->get_id()==fac2->get_id())
1788  {
1789  lst100.supprimer(fac1);
1790  }
1791 
1792  }
1793  }
1794  int aii=noeud->get_lien_segment()->get_nb();
1795  int aai=noeud->get_lien_triangle()->get_nb();
1796  for(int o=0;o<aai;o++)
1797  {
1798  MG_TRIANGLE * triangle2=(MG_TRIANGLE *) noeud->get_lien_triangle()->get(o);
1799  lst500.ajouter(triangle2);
1800  //printf("triangle de la face %lu \n",triangle2->get_lien_topologie()->get_id());
1801  }
1802  for(int op=0;op<aii;op++)
1803  {
1804  MG_SEGMENT * segment2=(MG_SEGMENT *) noeud->get_lien_segment()->get(op);
1805  lst600.ajouter(segment2);
1806  // printf("segment de la face %lu \n",segment2->get_lien_topologie()->get_id());
1807  }
1808  TPL_MAP_ENTITE<MG_SEGMENT *> lst300;
1809  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst300;
1810  TPL_MAP_ENTITE<MG_SEGMENT *> lst400;
1811  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst400;
1812  MG_FACE *fac4;
1813  MG_SEGMENT * se1;
1814  MG_SEGMENT * se5;
1815 
1816  for(se1=lst600.get_premier(itlst600);se1;se1=lst600.get_suivant(itlst600))
1817 
1818  {
1819  for(fac4=lst100.get_premier(itlst100);fac4;fac4=lst100.get_suivant(itlst100))
1820  {
1821  if(se1->get_lien_topologie()->get_id()==fac4->get_id())
1822  {
1823  lst300.ajouter(se1);
1824  }
1825  else
1826  {
1827  lst400.ajouter(se1);
1828  }
1829  }
1830  }
1831 
1832  TPL_MAP_ENTITE<MG_ARETE *> lst202;
1833  TPL_MAP_ENTITE<MG_ARETE *> ::ITERATEUR itlst202;
1834  TPL_MAP_ENTITE<MG_ARETE *> lst302;
1835  TPL_MAP_ENTITE<MG_ARETE *> ::ITERATEUR itlst302;
1836  MG_FACE * fa;
1837  MG_ARETE * ar;
1838 
1839  for(ar=lst102.get_premier(itlst102);ar;ar=lst102.get_suivant(itlst102))
1840  {
1841  MG_GEOMETRIE_OUTILS virt1;
1842  double vir1=virt1.arete_virtuelle(ar);
1843  if(vir1==1)
1844  {
1845  lst202.ajouter(ar);
1846 
1847  }
1848  else if(vir1==0)
1849  {
1850  lst302.ajouter(ar);
1851  }
1852  }
1853  TPL_MAP_ENTITE<MG_SEGMENT *> lst303;
1854  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst303;
1855  TPL_MAP_ENTITE<MG_SEGMENT *> lst403;
1856  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst403;
1857  MG_ARETE * ar1;
1858  MG_ARETE * ar2;
1859  for(se5=lst400.get_premier(itlst400);se5;se5=lst400.get_suivant(itlst400))
1860  {
1861  for(ar1=lst202.get_premier(itlst202);ar1;ar1=lst202.get_suivant(itlst202))
1862  {
1863 
1864  if(se5->get_lien_topologie()->get_id()==ar1->get_id())
1865  {
1866  lst303.ajouter(se5);
1867  //printf("segment face cylindre 1 %lu \n",se5->get_id());
1868  }
1869  }
1870 
1871  }
1872  MG_FACE * fa1;
1873  MG_SEGMENT * s1;
1874  for(s1=lst400.get_premier(itlst400);s1;s1=lst400.get_suivant(itlst400))
1875  {
1876  for(fa1=lst200.get_premier(itlst200);fa1;fa1=lst200.get_suivant(itlst200))
1877  {
1878 
1879  if(s1->get_lien_topologie()->get_id()==fa1->get_id())
1880  {
1881  lst403.ajouter(s1);
1882  //printf("segment face cylindre2 %lu \n",s1->get_id());
1883  }
1884  }
1885 
1886  }
1887 
1888  MG_SEGMENT * se6;
1889  MG_SEGMENT * se7;
1890  TPL_MAP_ENTITE<MG_SEGMENT *> lst503;
1891  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst503;
1892  for(se6=lst303.get_premier(itlst303);se6;se6=lst303.get_suivant(itlst303))
1893  {
1894  lst503.ajouter(se6);
1895 
1896  for(se7=lst403.get_premier(itlst403);se7;se7=lst403.get_suivant(itlst403))
1897  {
1898 
1899  lst503.ajouter(se7);
1900 
1901  }
1902  }
1903 
1904 
1905 
1906 
1907  TPL_MAP_ENTITE<MG_TRIANGLE *> lst301;
1908  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst301;
1909  TPL_MAP_ENTITE<MG_TRIANGLE *> lst401;
1910  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst401;
1911  MG_FACE * fac5;
1912  MG_TRIANGLE * tri5;
1913  for(tri5=lst500.get_premier(itlst500);tri5;tri5=lst500.get_suivant(itlst500))
1914 
1915  {
1916  for(fac5=lst100.get_premier(itlst100);fac5;fac5=lst100.get_suivant(itlst100))
1917  {
1918  if(tri5->get_lien_topologie()->get_id()==fac5->get_id())
1919  {
1920  lst301.ajouter(tri5);
1921  }
1922  else
1923  {
1924  lst401.ajouter(tri5);
1925  }
1926  }
1927  }
1928  double angletri1=0.;
1929  double angletri2=0.;
1930  double K1=0.;
1931  double K2=0.;
1932  double H1=0.;
1933  double H2=0.;
1934  double H11=0.;
1935  double H22=0.;
1936  double h21=0.;
1937  double h22=0.;
1938  double o=0.;
1939  double o2=0.;
1940  double surface11=0.;
1941  double surface12=0.;
1942  double surf11=0.;
1943  double surf12=0.;
1944  MG_TRIANGLE *tr1;
1945  MG_TRIANGLE *tr2;
1946  MG_SEGMENT *se2;
1947  MG_SEGMENT *se3;
1948  for(tr1=lst301.get_premier(itlst301);tr1;tr1=lst301.get_suivant(itlst301))
1949  {
1950  MG_MAILLAGE_OUTILS cour1(mai);
1951  surface11=cour1.calcul_surface_lsttriangle(noeud,tr1);
1952  surf11+=surface11;
1953  o=cour1.calcul_angle_lsttriangle(noeud,tr1);
1954  angletri1+=o;
1955  }
1956  K1= ((M_PI) - angletri1)/((1./3.)*surf11);
1957  // printf("gauss1 %lf \n",K1);
1958  for(tr2=lst401.get_premier(itlst401);tr2;tr2=lst401.get_suivant(itlst401))
1959  {
1960  MG_MAILLAGE_OUTILS cour2(mai);
1961  surface12=cour2.calcul_surface_lsttriangle(noeud,tr2);
1962  surf12+=surface12;
1963  o2=cour2.calcul_angle_lsttriangle(noeud,tr2);
1964  angletri2+=o2;
1965  }
1966  K2= ((M_PI) - angletri2)/((1./3.)*surf12);
1967  // printf("gauss 2 %lf \n",K2);
1968  for(se2=lst300.get_premier(itlst300);se2;se2=lst300.get_suivant(itlst300))
1969  {
1970  MG_MAILLAGE_OUTILS cour3(mai);
1971  h21=cour3.calcul_angle_lstsegment(noeud,se2);
1972  H11+=h21;
1973  H1= (3. / (4.*surf11))*H11;
1974  }
1975  // printf("MOYENNE1 %lf \n",H1);
1976 
1977  for(se3=lst503.get_premier(itlst503);se3;se3=lst503.get_suivant(itlst503))
1978  {
1979  MG_MAILLAGE_OUTILS cour4(mai);
1980  h22=cour4.calcul_angle_lstsegment(noeud,se3);
1981  H22+=h22;
1982  H2= (3. / (4.*surf12))*H22;
1983  }
1984  // printf("MOYENNE2 %lf \n",H2);
1985 
1986  const std::complex<double> result = std::sqrt(std::complex<double>(H1*H1 - K1));
1987  // std::cout << result.real() << std::endl;
1988  //std::cout << result.imag() << std::endl;
1989  kmin1=(H1-result.real());
1990  kmax1=(H1+result.real());
1991 
1992  const std::complex<double> result1 = std::sqrt(std::complex<double>(H2*H2 - K2));
1993  // std::cout << result.real() << std::endl;
1994  //std::cout << result.imag() << std::endl;
1995  kmin2=(H2-result1.real());
1996  kmax2=(H2+result1.real());
1997 
1998 
1999 
2000  int nbtrxx=noeud->get_lien_triangle()->get_nb();
2001  for(int yy=0;yy<nbtrxx;yy++)
2002  {
2003 
2004  MG_TRIANGLE * trxx=(MG_TRIANGLE*) noeud->get_lien_triangle()->get(yy);
2005  unsigned long idface=trxx->get_lien_topologie()->get_id();
2006  unsigned long idnoeud=noeud->get_id();
2007  char mess[500];
2008  sprintf(mess,"%lu_%lu",idnoeud,idface);
2009  //liste_H1[mess]=H1;
2010  //liste_K1[mess]=K1;
2011  MG_FACE * fa10;
2012  MG_FACE * fa11;
2013  for(fa10=lst100.get_premier(itlst100);fa10;fa10=lst100.get_suivant(itlst100))
2014  {
2015  for(fa11=lst200.get_premier(itlst200);fa11;fa11=lst200.get_suivant(itlst200))
2016  {
2017 
2018  if(trxx->get_lien_topologie()==fa10)
2019  {
2020  liste_kmax[mess]=kmax1;
2021  liste_kmin[mess]=kmin1;
2022  }
2023  else if(trxx->get_lien_topologie()==fa11)
2024  {
2025  liste_kmax[mess]=kmax2;
2026  liste_kmin[mess]=kmin2;
2027  }
2028  }
2029  }
2030  }
2031  }
2032  else
2033  {
2034  for(int gg=0;gg<nbcosom;gg++)
2035  {
2036  MG_COSOMMET * cosom=sommet->get_mg_cosommet(gg);
2037  MG_ARETE * aret=cosom->get_arete();
2038  lst102.ajouter(aret);
2039 
2040  int nbcoaret=aret->get_nb_mg_coarete();
2041  //printf("nb arret %d\n",nbcoaret);
2042  MG_GEOMETRIE_OUTILS virt;
2043  double vir=virt.arete_virtuelle(aret);
2044  MG_FACE *face_n=aret->get_mg_coarete(0)->get_boucle()->get_mg_face();
2045  // printf("face_n %lu \n ",face_n->get_id());
2046  MG_FACE *face_m=aret->get_mg_coarete(1)->get_boucle()->get_mg_face();
2047  // printf("face_m %lu \n ",face_m->get_id());
2048  int aiii=noeud->get_lien_segment()->get_nb();
2049  int aaii=noeud->get_lien_triangle()->get_nb();
2050  for(int oip=0;oip<aaii;oip++)
2051  {
2052  MG_TRIANGLE * triangle3=(MG_TRIANGLE *) noeud->get_lien_triangle()->get(oip);
2053  if(triangle3->get_lien_topologie()==face_n)
2054  {
2055  lst700.ajouter(triangle3);
2056  //printf("triangle de la face 1 %lu \n",triangle3->get_id());
2057  }
2058  else if(triangle3->get_lien_topologie()==face_m)
2059  {
2060  lst800.ajouter(triangle3);
2061  // printf("triangle de la face 2 %lu \n",triangle3->get_id());
2062  }
2063  }
2064  for(int ooip=0;ooip<aiii;ooip++)
2065  {
2066  MG_SEGMENT * segment3=(MG_SEGMENT *) noeud->get_lien_segment()->get(ooip);
2067  // if (segment3->get_lien_topologie()->get_dimension()==2)
2068  //{
2069  // printf("segmen face %lu face %lu\n ",segment3->get_id(),segment3->get_lien_topologie()->get_id());
2070  if(segment3->get_lien_topologie()==face_n)
2071  {
2072  lst701.ajouter(segment3);
2073  //printf("segment 1 de face 1 %lu \n",segment3->get_id());
2074  }
2075  else if(segment3->get_lien_topologie()==face_m)
2076  {
2077  lst801.ajouter(segment3);
2078  //printf("segment 2 de face 2 %lu \n",segment3->get_id());
2079  }
2080  //}
2081  }
2082  double angletri1=0.;
2083  double angletri2=0.;
2084  double K1=0.;
2085  double K2=0.;
2086  double H1=0.;
2087  double H2=0.;
2088  double H11=0.;
2089  double H22=0.;
2090  double h21=0.;
2091  double h22=0.;
2092  double o=0.;
2093  double o2=0.;
2094  double surface11=0.;
2095  double surface12=0.;
2096  double surf11=0.;
2097  double surf12=0.;
2098  MG_TRIANGLE *tr1;
2099  MG_TRIANGLE *tr2;
2100  MG_SEGMENT *se2;
2101  MG_SEGMENT *se3;
2102  for(tr1=lst700.get_premier(itlst700);tr1;tr1=lst700.get_suivant(itlst700))
2103  {
2104  MG_MAILLAGE_OUTILS cour1(mai);
2105  surface11=cour1.calcul_surface_lsttriangle(noeud,tr1);
2106  surf11+=surface11;
2107  o=cour1.calcul_angle_lsttriangle(noeud,tr1);
2108  angletri1+=o;
2109  }
2110  K1= ((M_PI) - angletri1)/((1./3.)*surf11);
2111  printf("gauss1 %lf \n",K1);
2112  for(tr2=lst800.get_premier(itlst800);tr2;tr2=lst800.get_suivant(itlst800))
2113  {
2114  MG_MAILLAGE_OUTILS cour2(mai);
2115  surface12=cour2.calcul_surface_lsttriangle(noeud,tr2);
2116  surf12+=surface12;
2117  o2=cour2.calcul_angle_lsttriangle(noeud,tr2);
2118  angletri2+=o2;
2119  }
2120  K2= ((M_PI) - angletri2)/((1./3.)*surf12);
2121  // printf("gauss 2 %lf \n",K2);
2122 
2123  int hj1=lst701.get_nb();
2124  int hj2=lst801.get_nb();
2125  if(hj1==0)
2126  {
2127  H1= 0.;
2128  // printf("COURBURE H1 %lf \n",H1);
2129  }
2130  else if(hj1>=1)
2131  {
2132  for(se2=lst701.get_premier(itlst701);se2;se2=lst701.get_suivant(itlst701))
2133  {
2134  MG_MAILLAGE_OUTILS cour3(mai);
2135  h21=cour3.calcul_angle_lstsegment(noeud,se2);
2136  H11+=h21;
2137  H1= (3. / (4.*surf11))*H11;
2138  }
2139  // printf("MOYENNE1 %lf \n",H1);
2140  }
2141 
2142  if(hj2==0)
2143  {
2144  H2= 0.;
2145  // printf("COURBURE H2 %lf \n",H2);
2146  }
2147  else if(hj2>=1)
2148  {
2149  for(se3=lst801.get_premier(itlst801);se3;se3=lst801.get_suivant(itlst801))
2150  {
2151  MG_MAILLAGE_OUTILS cour4(mai);
2152  h22=cour4.calcul_angle_lstsegment(noeud,se3);
2153  H22+=h22;
2154  H2= (3. / (4.*surf12))*H22;
2155  }
2156  // printf("MOYENNE2 %lf \n",H2);
2157  }
2158 
2159  const std::complex<double> result = std::sqrt(std::complex<double>(H1*H1 - K1));
2160  //std::cout << result.real() << std::endl;
2161  //std::cout << result.imag() << std::endl;
2162  kmin1=(H1-result.real());
2163  kmax1=(H1+result.real());
2164 
2165  const std::complex<double> result1 = std::sqrt(std::complex<double>(H2*H2 - K2));
2166  // std::cout << result.real() << std::endl;
2167  //std::cout << result.imag() << std::endl;
2168  kmin2=(H2-result1.real());
2169  kmax2=(H2+result1.real());
2170 
2171  int nbtrxx=noeud->get_lien_triangle()->get_nb();
2172  for(int yy=0;yy<nbtrxx;yy++)
2173  {
2174  MG_TRIANGLE * trxx=(MG_TRIANGLE*) noeud->get_lien_triangle()->get(yy);
2175  unsigned long idface=trxx->get_lien_topologie()->get_id();
2176  unsigned long idnoeud=noeud->get_id();
2177  char mess[500];
2178  sprintf(mess,"%lu_%lu",idnoeud,idface);
2179  if(trxx->get_lien_topologie()==face_n)
2180  {
2181  liste_kmax[mess]=kmax1;
2182  liste_kmin[mess]=kmin1;
2183  }
2184  else if(trxx->get_lien_topologie()==face_m)
2185  {
2186  liste_kmax[mess]=kmax2;
2187  liste_kmin[mess]=kmin2;
2188  }
2189  }
2190  }
2191  }
2192 
2193  }
2194  }
2195 
2196 
2197  else if(aaa==0)//------------(aucune aret virtuelle)--------------------
2198  {
2199  // printf("hallo\n\n");
2200  for(int gg=0;gg<nbcosom;gg++)
2201  {
2202  MG_COSOMMET * cosom=sommet->get_mg_cosommet(gg);
2203  MG_ARETE * aret=cosom->get_arete();
2204  lst102.ajouter(aret);
2205 
2206  int nbcoaret=aret->get_nb_mg_coarete();
2207  //printf("nb arret %d\n",nbcoaret);
2208  MG_GEOMETRIE_OUTILS virt;
2209  double vir=virt.arete_virtuelle(aret);
2210  MG_FACE *face_n=aret->get_mg_coarete(0)->get_boucle()->get_mg_face();
2211  // printf("face_n %lu \n ",face_n->get_id());
2212  MG_FACE *face_m=aret->get_mg_coarete(1)->get_boucle()->get_mg_face();
2213  // printf("face_m %lu \n ",face_m->get_id());
2214  int aiii=noeud->get_lien_segment()->get_nb();
2215  int aaii=noeud->get_lien_triangle()->get_nb();
2216  for(int oip=0;oip<aaii;oip++)
2217  {
2218  MG_TRIANGLE * triangle3=(MG_TRIANGLE *) noeud->get_lien_triangle()->get(oip);
2219  if(triangle3->get_lien_topologie()==face_n)
2220  {
2221  lst700.ajouter(triangle3);
2222  //printf("triangle de la face 1 %lu \n",triangle3->get_id());
2223  }
2224  else if(triangle3->get_lien_topologie()==face_m)
2225  {
2226  lst800.ajouter(triangle3);
2227  // printf("triangle de la face 2 %lu \n",triangle3->get_id());
2228  }
2229  }
2230  for(int ooip=0;ooip<aiii;ooip++)
2231  {
2232  MG_SEGMENT * segment3=(MG_SEGMENT *) noeud->get_lien_segment()->get(ooip);
2233  // if (segment3->get_lien_topologie()->get_dimension()==2)
2234  //{
2235  // printf("segmen face %lu face %lu\n ",segment3->get_id(),segment3->get_lien_topologie()->get_id());
2236  if(segment3->get_lien_topologie()==face_n)
2237  {
2238  lst701.ajouter(segment3);
2239  //printf("segment 1 de face 1 %lu \n",segment3->get_id());
2240  }
2241  else if(segment3->get_lien_topologie()==face_m)
2242  {
2243  lst801.ajouter(segment3);
2244  //printf("segment 2 de face 2 %lu \n",segment3->get_id());
2245  }
2246  //}
2247  }
2248  double angletri1=0.;
2249  double angletri2=0.;
2250  double K1=0.;
2251  double K2=0.;
2252  double H1=0.;
2253  double H2=0.;
2254  double H11=0.;
2255  double H22=0.;
2256  double h21=0.;
2257  double h22=0.;
2258  double o=0.;
2259  double o2=0.;
2260  double surface11=0.;
2261  double surface12=0.;
2262  double surf11=0.;
2263  double surf12=0.;
2264  MG_TRIANGLE *tr1;
2265  MG_TRIANGLE *tr2;
2266  MG_SEGMENT *se2;
2267  MG_SEGMENT *se3;
2268  for(tr1=lst700.get_premier(itlst700);tr1;tr1=lst700.get_suivant(itlst700))
2269  {
2270  MG_MAILLAGE_OUTILS cour1(mai);
2271  surface11=cour1.calcul_surface_lsttriangle(noeud,tr1);
2272  surf11+=surface11;
2273  o=cour1.calcul_angle_lsttriangle(noeud,tr1);
2274  angletri1+=o;
2275  }
2276  K1= ((M_PI) - angletri1)/((1./3.)*surf11);
2277  printf("gauss1 %lf \n",K1);
2278  for(tr2=lst800.get_premier(itlst800);tr2;tr2=lst800.get_suivant(itlst800))
2279  {
2280  MG_MAILLAGE_OUTILS cour2(mai);
2281  surface12=cour2.calcul_surface_lsttriangle(noeud,tr2);
2282  surf12+=surface12;
2283  o2=cour2.calcul_angle_lsttriangle(noeud,tr2);
2284  angletri2+=o2;
2285  }
2286  K2= ((M_PI) - angletri2)/((1./3.)*surf12);
2287  // printf("gauss 2 %lf \n",K2);
2288 
2289  int hj1=lst701.get_nb();
2290  int hj2=lst801.get_nb();
2291  if(hj1==0)
2292  {
2293  H1= 0.;
2294  // printf("COURBURE H1 %lf \n",H1);
2295  }
2296  else if(hj1>=1)
2297  {
2298  for(se2=lst701.get_premier(itlst701);se2;se2=lst701.get_suivant(itlst701))
2299  {
2300  MG_MAILLAGE_OUTILS cour3(mai);
2301  h21=cour3.calcul_angle_lstsegment(noeud,se2);
2302  H11+=h21;
2303  H1= (3. / (4.*surf11))*H11;
2304  }
2305  // printf("MOYENNE1 %lf \n",H1);
2306  }
2307 
2308  if(hj2==0)
2309  {
2310  H2= 0.;
2311  // printf("COURBURE H2 %lf \n",H2);
2312  }
2313  else if(hj2>=1)
2314  {
2315  for(se3=lst801.get_premier(itlst801);se3;se3=lst801.get_suivant(itlst801))
2316  {
2317  MG_MAILLAGE_OUTILS cour4(mai);
2318  h22=cour4.calcul_angle_lstsegment(noeud,se3);
2319  H22+=h22;
2320  H2= (3. / (4.*surf12))*H22;
2321  }
2322  // printf("MOYENNE2 %lf \n",H2);
2323  }
2324 
2325  const std::complex<double> result = std::sqrt(std::complex<double>(H1*H1 - K1));
2326  //std::cout << result.real() << std::endl;
2327  //std::cout << result.imag() << std::endl;
2328  kmin1=(H1-result.real());
2329  kmax1=(H1+result.real());
2330 
2331  const std::complex<double> result1 = std::sqrt(std::complex<double>(H2*H2 - K2));
2332  // std::cout << result.real() << std::endl;
2333  //std::cout << result.imag() << std::endl;
2334  kmin2=(H2-result1.real());
2335  kmax2=(H2+result1.real());
2336 
2337  int nbtrxx=noeud->get_lien_triangle()->get_nb();
2338  for(int yy=0;yy<nbtrxx;yy++)
2339  {
2340  MG_TRIANGLE * trxx=(MG_TRIANGLE*) noeud->get_lien_triangle()->get(yy);
2341  unsigned long idface=trxx->get_lien_topologie()->get_id();
2342  unsigned long idnoeud=noeud->get_id();
2343  char mess[500];
2344  sprintf(mess,"%lu_%lu",idnoeud,idface);
2345  if(trxx->get_lien_topologie()==face_n)
2346  {
2347  liste_kmax[mess]=kmax1;
2348  liste_kmin[mess]=kmin1;
2349  }
2350  else if(trxx->get_lien_topologie()==face_m)
2351  {
2352  liste_kmax[mess]=kmax2;
2353  liste_kmin[mess]=kmin2;
2354  }
2355  }
2356  }
2357  }
2358 
2359  }
2360 
2361 void MG_MAILLAGE_OUTILS::calcul_courbure_arete_nonvirtuelle(MG_NOEUD* noeud, double& kmin1, double& kmax1, double& kmin2, double& kmax2, std::map< std::string, double >& liste_kmin, std::map< std::string, double >& liste_kmax)
2362 {
2363 
2364  MG_ARETE* aret=(MG_ARETE*)noeud->get_lien_topologie();
2365  int nbcoarete=aret->get_nb_mg_coarete();
2367  {
2368  // double kmin=0.;
2369  // double kmax=0.;
2370  // MG_MAILLAGE_OUTILS * cou;
2371  // cou->calcul_courbure_face(noeud,kmin,kmax,liste_kmin,liste_kmax,liste_gau,liste_courburemax1,liste_courburemax2,liste_courburemax3,liste_courburemax4,liste_courburemax5);
2372  }
2373 
2374  //if(nbcoarete==2)//sasan
2375  {
2376  MG_FACE* face1=aret->get_mg_coarete(0)->get_boucle()->get_mg_face();
2377  MG_FACE* face2=aret->get_mg_coarete(1)->get_boucle()->get_mg_face();
2378 
2379  int nbtri=noeud->get_lien_triangle()->get_nb();
2380  TPL_MAP_ENTITE<MG_TRIANGLE *> lst1;
2381  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst1;
2382  TPL_MAP_ENTITE<MG_TRIANGLE *> lst2;
2383  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst2;
2384  for(int kk=0;kk<nbtri;kk++)
2385  {
2386  MG_TRIANGLE* tri1=(MG_TRIANGLE *)noeud->get_lien_triangle()->get(kk);
2387 
2388  if(tri1->get_lien_topologie()==face1)
2389  {
2390  lst1.ajouter(tri1);
2391  }
2392  else if(tri1->get_lien_topologie()==face2)
2393  {
2394  lst2.ajouter(tri1);
2395  }
2396  }
2397 
2398  int nbseg=noeud->get_lien_segment()->get_nb();
2399 
2400  TPL_MAP_ENTITE<MG_SEGMENT *> lst3;
2401  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst3;
2402  TPL_MAP_ENTITE<MG_SEGMENT *> lst4;
2403  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst4;
2404 
2405 
2406  for(int jj=0;jj<nbseg;jj++)
2407  {
2408  MG_SEGMENT* sg1=(MG_SEGMENT *)noeud->get_lien_segment()->get(jj);
2409 
2410  if(sg1->get_lien_topologie()==face1)
2411  {
2412  lst3.ajouter(sg1);
2413  }
2414  else if(sg1->get_lien_topologie()==face2)
2415  {
2416  lst4.ajouter(sg1);
2417  }
2418 
2419  }
2420  double angletri1=0.;
2421  double angletri2=0.;
2422  double K1=0.;
2423  double K2=0.;
2424  double H1=0.;
2425  double H2=0.;
2426  double H11=0.;
2427  double H22=0.;
2428  double h21=0.;
2429  double h22=0.;
2430  double o=0.;
2431  double o2=0.;
2432  double surface11=0.;
2433  double surface12=0.;
2434  double surf11=0.;
2435  double surf12=0.;
2436  MG_TRIANGLE *tr1;
2437  MG_TRIANGLE *tr2;
2438  MG_SEGMENT *se1;
2439  MG_SEGMENT *se2;
2440  for(tr1=lst1.get_premier(itlst1);tr1;tr1=lst1.get_suivant(itlst1))
2441  {
2442  MG_MAILLAGE_OUTILS cour1(mai);
2443  surface11=cour1.calcul_surface_lsttriangle(noeud,tr1);
2444  surf11+=surface11;
2445  o=cour1.calcul_angle_lsttriangle(noeud,tr1);
2446  angletri1+=o;
2447  }
2448  K1= ((M_PI) - angletri1)/((1./3.)*surf11);
2449  //printf("gauss1 %lf \n",K1);
2450  for(tr2=lst2.get_premier(itlst2);tr2;tr2=lst2.get_suivant(itlst2))
2451  {
2452  MG_MAILLAGE_OUTILS cour2(mai);
2453  surface12=cour2.calcul_surface_lsttriangle(noeud,tr2);
2454  surf12+=surface12;
2455  o2=cour2.calcul_angle_lsttriangle(noeud,tr2);
2456  angletri2+=o2;
2457  }
2458  K2= ((M_PI) - angletri2)/((1./3.)*surf12);
2459  //printf("gauss 2 %lf \n",K2);
2460  for(se1=lst3.get_premier(itlst3);se1;se1=lst3.get_suivant(itlst3))
2461  {
2462  MG_MAILLAGE_OUTILS cour3(mai);
2463  h21=cour3.calcul_angle_lstsegment(noeud,se1);
2464  H11+=h21;
2465  H1= (3. / (4.*surf11))*H11;
2466  }
2467  //printf("MOYENNE1 %.20lf \n",H1);
2468 
2469  for(se2=lst4.get_premier(itlst4);se2;se2=lst4.get_suivant(itlst4))
2470  {
2471  MG_MAILLAGE_OUTILS cour4(mai);
2472  h22=cour4.calcul_angle_lstsegment(noeud,se2);
2473  H22+=h22;
2474  H2= (3. / (4.*surf12))*H22;
2475  }
2476  //printf("MOYENNE2 %.20lf \n",H2);
2477 
2478  if(H1>=0 && H1<0.00009)
2479  {
2480  kmin1=0;
2481  kmax1=0;
2482  }
2483  else
2484  {
2485 
2486  const std::complex<double> result = std::sqrt(std::complex<double>(H1*H1 - K1));
2487  kmin1=(H1-result.real());
2488  kmax1=(H1+result.real());
2489  }
2490 
2491  if(H2>=0 && H2<0.00009)
2492  {
2493  kmin2=0.;
2494  kmax2=0.;
2495  }
2496  else{
2497  const std::complex<double> result1 = std::sqrt(std::complex<double>(H2*H2 - K2));
2498  kmin2=(H2-result1.real());
2499  kmax2=(H2+result1.real());
2500  }
2501 
2502 
2503  int nbtrxx=noeud->get_lien_triangle()->get_nb();
2504  for(int yy=0;yy<nbtrxx;yy++)
2505  {
2506  MG_TRIANGLE * trxx=(MG_TRIANGLE*) noeud->get_lien_triangle()->get(yy);
2507  unsigned long idface=trxx->get_lien_topologie()->get_id();
2508  unsigned long idnoeud=noeud->get_id();
2509  char mess[500];
2510  sprintf(mess,"%lu_%lu",idnoeud,idface);
2511  if(trxx->get_lien_topologie()==face1)
2512  {
2513  liste_kmax[mess]=kmax1;
2514  liste_kmin[mess]=kmin1;
2515  }
2516  else if(trxx->get_lien_topologie()==face2)
2517  {
2518  liste_kmax[mess]=kmax2;
2519  liste_kmin[mess]=kmin2;
2520  }
2521  }
2522  }
2523 
2524 }
2525 
2526 void MG_MAILLAGE_OUTILS::calcul_courbure_arete_virtuelle(MG_NOEUD* noeud, double& kmin, double& kmax, std::map< std::string, double >& liste_kmin, std::map< std::string, double >& liste_kmax)
2527 {
2528 
2529  int nbtri2=noeud->get_lien_triangle()->get_nb();
2530  TPL_MAP_ENTITE<MG_TRIANGLE *> lst100;
2531  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst100;
2532  for(int uu=0;uu<nbtri2;uu++)
2533  {
2534  MG_TRIANGLE* tri100=(MG_TRIANGLE *)noeud->get_lien_triangle()->get(uu);
2535  lst100.ajouter(tri100);
2536  }
2537  int nbseg2=noeud->get_lien_segment()->get_nb();
2538  TPL_MAP_ENTITE<MG_SEGMENT *> lst300;
2539  TPL_MAP_ENTITE<MG_SEGMENT *> ::ITERATEUR itlst300;
2540  for(int zz=0;zz<nbseg2;zz++)
2541  {
2542  MG_SEGMENT* sg100=(MG_SEGMENT *)noeud->get_lien_segment()->get(zz);
2543 
2544  lst300.ajouter(sg100);
2545  }
2546 
2547  double angletri1=0.;
2548  double angle11=0.;
2549  double K1=0.;
2550  double H1=0.;
2551  double H11=0.;
2552  double h21=0.;
2553  double o=0.;
2554  double surface11=0.;
2555  double surf11=0;
2556  MG_TRIANGLE *tr100;
2557  MG_SEGMENT *se100;
2558  for(tr100=lst100.get_premier(itlst100);tr100;tr100=lst100.get_suivant(itlst100))
2559  {
2560  // printf("trinagle face 1 %lu \n",tr1->get_id());
2561  if (tr100->get_lien_topologie()->get_dimension()==2) // detecter le triangle de face et connecter au noeud
2562  {
2563  MG_MAILLAGE_OUTILS cour1(mai);
2564  surface11=cour1.calcul_surface_lsttriangle(noeud,tr100);
2565  surf11+=surface11;
2566  o=cour1.calcul_angle_lsttriangle(noeud,tr100);
2567  angletri1+=o;
2568  }
2569  }
2570  K1= ((2.*M_PI) - angletri1)/((1./3.)*surf11);
2571  for(se100=lst300.get_premier(itlst300);se100;se100=lst300.get_suivant(itlst300))
2572  {
2573  MG_MAILLAGE_OUTILS cour3(mai);
2574  h21=cour3.calcul_angle_lstsegment(noeud,se100);
2575  H11+=h21;
2576  H1= (3. / (4.*surf11))*H11;
2577  }
2578  const std::complex<double> result = std::sqrt(std::complex<double>(H1*H1 - K1));
2579  kmin=(H1-result.real());
2580  kmax=(H1+result.real());
2581  int nbtrxx=noeud->get_lien_triangle()->get_nb();
2582  for(int yy=0;yy<nbtrxx;yy++)
2583  {
2584  MG_TRIANGLE * trxx=(MG_TRIANGLE*) noeud->get_lien_triangle()->get(yy);
2585  unsigned long idface=trxx->get_lien_topologie()->get_id();
2586  unsigned long idnoeud=noeud->get_id();
2587  char mess[500];
2588  sprintf(mess,"%lu_%lu",idnoeud,idface);
2589  liste_kmax[mess]=kmax;
2590  liste_kmin[mess]=kmin;
2591  }
2592  }
2593 
2594 void MG_MAILLAGE_OUTILS::calcul_courbure_face(MG_NOEUD* noeud, double & kmin, double& kmax, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax,std::map<std::string,double> &liste_gau,std::map<std::string,double> &liste_courburemax1,std::map<std::string,double> &liste_courburemax2,std::map<std::string,double> &liste_courburemax3,std::map<std::string,double> &liste_courburemax4,std::map<std::string,double> &liste_courburemax5 )
2595 {
2596 
2597  // double kmin=0.;
2598  // double kmax=0.;
2599  double H=0.;
2600  MG_MAILLAGE_OUTILS cour(mai);
2601  double K=cour.calcul_gaussienne_face(noeud);
2602  // printf("GAUSS %lf\n",K);
2603  double surface=cour.calcul_surface_triangle_face(noeud);
2604  double H1=cour.calcul_moyenne_face(noeud);
2605  H= (3. / (4.*surface))*H1;
2606  // printf("moyenne %lf\n",H);
2607  const std::complex<double> result = std::sqrt(std::complex<double>(H*H - K));
2608  kmin=(H-result.real());
2609  kmax=(H+result.real());
2610  // printf("courbure minimale face %.4lf\n",kmin);
2611  // printf("courbure maximale face %.4lf\n",kmax);
2612  unsigned long idface=noeud->get_lien_topologie()->get_id();
2613  unsigned long idnoeud=noeud->get_id();
2614  char mess[500];
2615  sprintf(mess,"%lu_%lu",idnoeud,idface);
2616  liste_kmax[mess]=kmax;
2617  liste_kmin[mess]=kmin;
2618  liste_gau[mess]=K;
2619  unsigned long idnoeud1=noeud->get_id();
2620  char mess1[500];
2621  sprintf(mess1, "%lu",idnoeud1);
2622  // liste_MOY[file]=H;
2623  //liste_GAUSS[file]=K;
2624  //liste_courburemax1[file]=kmax;
2625  //liste_courburemin1[file]=kmin;
2626 
2627  if(kmax==0 && kmax<=0.00009)
2628  {
2629  liste_courburemax1[mess1]=kmax;
2630  }
2631  else if(kmax<=0.04 && kmax>0.00009)
2632  {
2633  liste_courburemax2[mess1]=kmax;
2634  }
2635  else if(kmax<=0.07 && kmax>=0.04)
2636  {
2637  liste_courburemax3[mess1]=kmax;
2638  }
2639  else if(kmax<=0.1 && kmax>=0.07)
2640  {
2641  liste_courburemax4[mess1]=kmax;
2642  }
2643  else if(kmax<=0.2 && kmax>=0.1)
2644  {
2645  liste_courburemax5[mess1]=kmax;
2646  }
2647 
2648 }
2649 
2650 
2651 double MG_MAILLAGE_OUTILS::calcul_angle_lstsegment(MG_NOEUD* noeud, MG_SEGMENT* se1)
2652 {
2653  double angle11=0.;
2654  double H1=0.;
2655  double H11=0.;
2656  double H21=0.;
2657  MG_NOEUD * no21=se1->get_noeud1();
2658  MG_NOEUD * no22=se1->get_noeud2();
2659 
2660  double longueur1= se1->get_longueur();
2661 
2662  int nbtrian=se1->get_lien_triangle()->get_nb();
2663  int nbtrian1=no21->get_lien_triangle()->get_nb();
2664  int nbtrian2=no22->get_lien_triangle()->get_nb();
2665 
2666  TPL_MAP_ENTITE<MG_TRIANGLE *> lst61;
2667  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst61;
2668  TPL_MAP_ENTITE<MG_TRIANGLE*> lst71;
2669  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst71;
2670  TPL_MAP_ENTITE<MG_TRIANGLE *> lst62;
2671  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst62;
2672  TPL_MAP_ENTITE<MG_TRIANGLE*> lst72;
2673  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst72;
2674  TPL_MAP_ENTITE<MG_TRIANGLE*> lst81;
2675  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst81;
2676  TPL_MAP_ENTITE<MG_TRIANGLE*> lst82;
2677  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst82;
2678  TPL_MAP_ENTITE<MG_TRIANGLE*> lst9;
2679  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst9;
2680 
2681  for(int p=0;p<nbtrian1;p++)
2682  {
2683 
2684  MG_TRIANGLE* tr41=(MG_TRIANGLE *)no21->get_lien_triangle()->get(p);
2685  //sur=tr5->get_longueur();
2686  MG_NOEUD * no41=tr41->get_noeud1();
2687  MG_NOEUD * no42=tr41->get_noeud2();
2688  MG_NOEUD * no43=tr41->get_noeud3();
2689 
2690 
2691  MG_FACE* face51=(MG_FACE*)tr41->get_lien_topologie(); //valider le sens d'orientation de coface
2692  int sens=face51->get_mg_coface(0)->get_orientation();
2693 
2694  {
2695  lst61.ajouter(tr41);
2696  }
2697  }
2698 
2699 
2700  for(int pp=0;pp<nbtrian2;pp++)
2701  {
2702 
2703  MG_TRIANGLE* tr42=(MG_TRIANGLE *)no22->get_lien_triangle()->get(pp);
2704  //sur=tr5->get_longueur();
2705  MG_NOEUD * no44=tr42->get_noeud1();
2706  MG_NOEUD * no45=tr42->get_noeud2();
2707  MG_NOEUD * no46=tr42->get_noeud3();
2708 
2709 
2710  MG_FACE* face52=(MG_FACE*)tr42->get_lien_topologie(); //valider le sens d'orientation de coface
2711  int sens=face52->get_mg_coface(0)->get_orientation();
2712 
2713  {
2714  //printf("trinagle 2 %d id %lu\n",pp,tr5->get_id());
2715  lst62.ajouter(tr42);
2716  }
2717 
2718 
2719  }
2720 
2721  int c=0;
2722  int g=0;
2723  MG_TRIANGLE * tri11;
2724  MG_TRIANGLE * tri12;
2725  for(tri11=lst61.get_premier(itlst61);tri11;tri11=lst61.get_suivant(itlst61))
2726  {
2727  for(tri12=lst62.get_premier(itlst62);tri12;tri12=lst62.get_suivant(itlst62))
2728  {
2729  if (tri11->get_id()==tri12->get_id())
2730  {
2731  lst81.ajouter(tri11);
2732 
2733  }
2734  }
2735  }
2736 
2737  MG_MAILLAGE_OUTILS ang(mai);
2738  MG_TRIANGLE *tri13;
2739  MG_TRIANGLE *tri14;
2740  tri13=lst81.get_premier(itlst81);
2741  //printf("triangle 1 %lu noeud1 %lu noeud2 %lu noeud3 %lu\n",tri3->get_id(),tri3->get_noeud1()->get_id(),tri3->get_noeud2()->get_id(),tri3->get_noeud3()->get_id());
2742  tri14=lst81.get_suivant(itlst81);
2743  //printf("triangle 2 %lu noeud1 %lu noeud2 %lu noeud3 %lu\n",tri4->get_id(),tri4->get_noeud1()->get_id(),tri4->get_noeud2()->get_id(),tri4->get_noeud3()->get_id());
2744 
2745  angle11=ang.get_angle(tri13,tri14);
2746  // printf("angle adjacent %lf \n",angle11);
2747  H11=(longueur1*(M_PI-angle11));
2748  // printf("angle inverse1 %lf \n",H11);
2749  //H21+=H11;
2750 
2751  return H11;
2752 
2753 }
2754 
2755 double MG_MAILLAGE_OUTILS::calcul_surface_lsttriangle(MG_NOEUD* noeud, MG_TRIANGLE * tr1)
2756 {
2757  double surface11=0.;
2758  double sur11=0;
2759  double sur1=0;
2760  MG_FACE* face41=(MG_FACE*)tr1->get_lien_topologie();
2761  int sens1=face41->get_mg_coface(0)->get_orientation();
2762  {
2763  MG_NOEUD* no11=tr1->get_noeud1();
2764  MG_NOEUD* no12=tr1->get_noeud2();
2765  MG_NOEUD* no13=tr1->get_noeud3();
2766 
2767  if(noeud==no11)
2768  {
2769  double *xyz11=noeud->get_coord();
2770  double *xyz12=no12->get_coord();
2771  double *xyz13=no13->get_coord();
2772  OT_VECTEUR_3D vec11(xyz11,xyz13);
2773  OT_VECTEUR_3D vec12(xyz11,xyz12);
2774  OT_VECTEUR_3D n_tri1=vec11&vec12;
2775  n_tri1=sens1*n_tri1;
2776  sur11=n_tri1.get_longueur()/2.;
2777  return sur11;
2778  }
2779  else if(noeud==no12)
2780  {
2781  double *xyz11=noeud->get_coord();
2782  double *xyz12=no11->get_coord();
2783  double *xyz13=no13->get_coord();
2784  OT_VECTEUR_3D vec11(xyz11,xyz13);
2785  OT_VECTEUR_3D vec12(xyz11,xyz12);
2786  OT_VECTEUR_3D n_tri1=vec11&vec12;
2787  n_tri1=sens1*n_tri1;
2788  sur11=n_tri1.get_longueur()/2.;
2789  return sur11;
2790  }
2791  else if(noeud==no13)
2792  {
2793  double *xyz11=noeud->get_coord();
2794  double *xyz12=no12->get_coord();
2795  double *xyz13=no11->get_coord();
2796  OT_VECTEUR_3D vec11(xyz11,xyz13);
2797  OT_VECTEUR_3D vec12(xyz11,xyz12);
2798  OT_VECTEUR_3D n_tri1=vec11&vec12;
2799  n_tri1=sens1*n_tri1;
2800  sur11=n_tri1.get_longueur()/2.;
2801  return sur11;
2802  }
2803 
2804  }
2805  return -1; // la fonction doit retourner une valeur par défaut
2806 
2807 }
2808 double MG_MAILLAGE_OUTILS::calcul_angle_lsttriangle(MG_NOEUD* noeud, MG_TRIANGLE * tr1)
2809 {
2810  double angletri1=0.;
2811  double surface11=0.;
2812  double sur11=0;
2813  double surface12=0.;
2814  double sur12=0;
2815  double sur1=0;
2816  double o=0.;
2817  MG_FACE* face41=(MG_FACE*)tr1->get_lien_topologie(); //valider le sens d'orientation de coface
2818  int sens1=face41->get_mg_coface(0)->get_orientation();
2819  {
2820  MG_NOEUD* no11=tr1->get_noeud1();
2821  MG_NOEUD* no12=tr1->get_noeud2();
2822  MG_NOEUD* no13=tr1->get_noeud3();
2823 
2824  if(noeud==no11)
2825  {
2826  double *xyz11=noeud->get_coord();
2827  double *xyz12=no12->get_coord();
2828  double *xyz13=no13->get_coord();
2829  OT_VECTEUR_3D vec11(xyz11,xyz13);
2830  OT_VECTEUR_3D vec12(xyz11,xyz12);
2831  OT_VECTEUR_3D n_tri1=vec11&vec12;
2832  n_tri1=sens1*n_tri1;
2833  sur11=n_tri1.get_longueur()/2.;
2834  surface11=surface11+sur11;
2835  double a=vec11.get_longueur();
2836  double b=vec12.get_longueur();
2837  double c=(vec11.get_x()*vec12.get_x()+vec11.get_y()*vec12.get_y()+vec11.get_z()*vec12.get_z());
2838  o=acos(c/(a*b));
2839 
2840  }
2841  else if(noeud==no12)
2842  {
2843  double *xyz11=noeud->get_coord();
2844  double *xyz12=no11->get_coord();
2845  double *xyz13=no13->get_coord();
2846  OT_VECTEUR_3D vec11(xyz11,xyz13);
2847  OT_VECTEUR_3D vec12(xyz11,xyz12);
2848  OT_VECTEUR_3D n_tri1=vec11&vec12;
2849  n_tri1=sens1*n_tri1;
2850  sur11=n_tri1.get_longueur()/2.;
2851  surface11=surface11+sur11;
2852  double a=vec11.get_longueur();
2853  double b=vec12.get_longueur();
2854  double c=(vec11.get_x()*vec12.get_x()+vec11.get_y()*vec12.get_y()+vec11.get_z()*vec12.get_z());
2855  o=acos(c/(a*b));
2856 
2857  }
2858  else if(noeud==no13)
2859  {
2860  double *xyz11=noeud->get_coord();
2861  double *xyz12=no12->get_coord();
2862  double *xyz13=no11->get_coord();
2863  OT_VECTEUR_3D vec11(xyz11,xyz13);
2864  OT_VECTEUR_3D vec12(xyz11,xyz12);
2865  OT_VECTEUR_3D n_tri1=vec11&vec12;
2866  n_tri1=sens1*n_tri1;
2867  sur11=n_tri1.get_longueur()/2.;
2868  surface11=surface11+sur11;
2869  double a=vec11.get_longueur();
2870  double b=vec12.get_longueur();
2871  double c=(vec11.get_x()*vec12.get_x()+vec11.get_y()*vec12.get_y()+vec11.get_z()*vec12.get_z());
2872  o=acos(c/(a*b));
2873 
2874  }
2875  }
2876  return o;
2877 }
2878 
2879 double MG_MAILLAGE_OUTILS::calcul_surface_triangle_face(MG_NOEUD *noeud)
2880 {
2881  int nbtri=noeud->get_lien_triangle()->get_nb();// detection de triangles connectés sur chaque noeud
2882  double angle=0.;
2883  double surface=0.;
2884  double sur=0;
2885  for (int i=0;i<nbtri;i++)
2886  {
2887  MG_TRIANGLE* tri=(MG_TRIANGLE*)noeud->get_lien_triangle()->get(i);
2888  if (tri->get_lien_topologie()->get_dimension()==2) // detecter le triangle de face et connecter au noeud
2889  {
2890 
2891  MG_FACE* face=(MG_FACE*)tri->get_lien_topologie(); //valider le sens d'orientation de coface
2892  int sens=face->get_mg_coface(0)->get_orientation(); //
2893  {
2894  MG_NOEUD* no1=tri->get_noeud1();
2895  MG_NOEUD* no2=tri->get_noeud2();
2896  MG_NOEUD* no3=tri->get_noeud3();
2897  if(noeud==no1)
2898  {
2899  double *xyz1=noeud->get_coord();
2900  double *xyz2=no2->get_coord();
2901  double *xyz3=no3->get_coord();
2902  OT_VECTEUR_3D vec1(xyz1,xyz3);
2903  OT_VECTEUR_3D vec2(xyz1,xyz2);
2904  OT_VECTEUR_3D n_tri=vec1&vec2;
2905  n_tri=sens*n_tri;
2906  sur=n_tri.get_longueur()/2.;
2907  surface=surface+sur;
2908  }
2909  else if (noeud==no2)
2910  {
2911  double *xyz1=noeud->get_coord();
2912  double *xyz2=no1->get_coord();
2913  double *xyz3=no3->get_coord();
2914  OT_VECTEUR_3D vec1(xyz1,xyz3);
2915  OT_VECTEUR_3D vec2(xyz1,xyz2);
2916  OT_VECTEUR_3D n_tri=vec1&vec2;
2917  n_tri=sens*n_tri;
2918  sur=n_tri.get_longueur()/2.;
2919  surface=surface+sur;
2920  }
2921  else if (noeud==no3)
2922  {
2923  double *xyz1=noeud->get_coord();
2924  double *xyz2=no2->get_coord();
2925  double *xyz3=no1->get_coord();
2926 
2927  OT_VECTEUR_3D vec1(xyz1,xyz3);
2928  OT_VECTEUR_3D vec2(xyz1,xyz2);
2929  OT_VECTEUR_3D n_tri=vec1&vec2;
2930  n_tri=sens*n_tri;
2931  sur=n_tri.get_longueur()/2.;
2932  surface=surface+sur;
2933  }
2934 
2935 
2936  }
2937 
2938  }
2939 
2940  }
2941  return surface;
2942 
2943 }
2944 double MG_MAILLAGE_OUTILS::calcul_gaussienne_face(MG_NOEUD *noeud)
2945 {
2946  int nbtri=noeud->get_lien_triangle()->get_nb();// detection de triangles connectés sur chaque noeud
2947  double angle=0.;
2948  double surface=0.;
2949  double sur=0;
2950  double K=0.;
2951 
2952  for (int i=0;i<nbtri;i++)
2953  {
2954  MG_TRIANGLE* tri=(MG_TRIANGLE*)noeud->get_lien_triangle()->get(i);
2955  if (tri->get_lien_topologie()->get_dimension()==2) // detecter le triangle de face et connecter au noeud
2956  {
2957 
2958  MG_FACE* face=(MG_FACE*)tri->get_lien_topologie(); //valider le sens d'orientation de coface
2959  int sens=face->get_mg_coface(0)->get_orientation(); //
2960  {
2961  MG_NOEUD* no1=tri->get_noeud1();
2962  MG_NOEUD* no2=tri->get_noeud2();
2963  MG_NOEUD* no3=tri->get_noeud3();
2964  if(noeud==no1)
2965  {
2966  double *xyz1=noeud->get_coord();
2967  double *xyz2=no2->get_coord();
2968  double *xyz3=no3->get_coord();
2969  OT_VECTEUR_3D vec1(xyz1,xyz3);
2970  OT_VECTEUR_3D vec2(xyz1,xyz2);
2971  OT_VECTEUR_3D n_tri=vec1&vec2;
2972  n_tri=sens*n_tri;
2973  sur=n_tri.get_longueur()/2.;
2974  surface=surface+sur;
2975  //printf("surface %lf\n",sur);
2976  double a=vec1.get_longueur();
2977  double b=vec2.get_longueur();
2978  double c=(vec1.get_x()*vec2.get_x()+vec1.get_y()*vec2.get_y()+vec1.get_z()*vec2.get_z());
2979  double o=acos(c/(a*b));
2980  angle=angle+o;
2981  }
2982  else if (noeud==no2)
2983  {
2984  double *xyz1=noeud->get_coord();
2985  double *xyz2=no1->get_coord();
2986  double *xyz3=no3->get_coord();
2987  OT_VECTEUR_3D vec1(xyz1,xyz3);
2988  OT_VECTEUR_3D vec2(xyz1,xyz2);
2989  OT_VECTEUR_3D n_tri=vec1&vec2;
2990  n_tri=sens*n_tri;
2991  sur=n_tri.get_longueur()/2.;
2992  surface=surface+sur;
2993  //printf("surface %lf\n",sur);
2994  double a=vec1.get_longueur();
2995  double b=vec2.get_longueur();
2996  double c=(vec1.get_x()*vec2.get_x()+vec1.get_y()*vec2.get_y()+vec1.get_z()*vec2.get_z());
2997  double o=acos(c/(a*b));
2998  angle=angle+o;
2999  }
3000  else if (noeud==no3)
3001  {
3002  double *xyz1=noeud->get_coord();
3003  double *xyz2=no2->get_coord();
3004  double *xyz3=no1->get_coord();
3005 
3006  OT_VECTEUR_3D vec1(xyz1,xyz3);
3007  OT_VECTEUR_3D vec2(xyz1,xyz2);
3008  OT_VECTEUR_3D n_tri=vec1&vec2;
3009  n_tri=sens*n_tri;
3010  // Normale au triangle
3011  //calcul du surface dec ahque triangle
3012  sur=n_tri.get_longueur()/2.;
3013  //calcaul de somme du surface de triangles connectés à chaque noeud
3014  surface=surface+sur;
3015  // printf("surface %lf\n",sur);
3016  //calcul de angle de chaque triangle
3017  double a=vec1.get_longueur();
3018  double b=vec2.get_longueur();
3019  double c=(vec1.get_x()*vec2.get_x()+vec1.get_y()*vec2.get_y()+vec1.get_z()*vec2.get_z());
3020  double o=acos(c/(a*b));
3021  angle=angle+o;
3022  }
3023 
3024 
3025  }
3026 
3027  }
3028 
3029  }
3030  K= ((2.* M_PI) - angle)/((1./3.)*surface);
3031  return K;
3032 
3033 }
3034 
3035 double MG_MAILLAGE_OUTILS::calcul_moyenne_face(MG_NOEUD *noeud)
3036 {
3037  int nbseg=noeud->get_lien_segment()->get_nb(); // detection de segments connectés sur chaque noeud
3038  int x=0;
3039  int p=0;
3040  int t=0;
3041  int b=0;
3042  double angle=0.;
3043  double angle1=0.;
3044  double angle2=0.;
3045  double kmin=0.;
3046  double kmax=0.;
3047  double K=0.;
3048  double H=0.;
3049  double H1=0.;
3050  double H2=0.;
3051  double r=0.;
3052  double surface=0.;
3053  double sur=0;
3054  double longueur=0.;
3055  for (int i=0;i<nbseg;i++)
3056  {
3057  MG_SEGMENT* seg=(MG_SEGMENT*)noeud->get_lien_segment()->get(i);
3058  {
3059  if (seg->get_lien_topologie()->get_dimension()==2) // detecter le segment de face et connecter au noeud
3060  {
3061  MG_NOEUD *no1=seg->get_noeud1();
3062  MG_NOEUD *no2=seg->get_noeud2();
3063  longueur= seg->get_longueur();
3064 
3065  int nbtriangle1=no1->get_lien_triangle()->get_nb();
3066  int nbtriangle2=no2->get_lien_triangle()->get_nb();
3067  TPL_MAP_ENTITE<MG_TRIANGLE *> lst1;
3068  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst1;
3069  TPL_MAP_ENTITE<MG_TRIANGLE*> lst2;
3070  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst2;
3071  TPL_MAP_ENTITE<MG_TRIANGLE*> lst3;
3072  TPL_MAP_ENTITE<MG_TRIANGLE *> ::ITERATEUR itlst3;
3073 
3074  for(int j=0;j<nbtriangle1;j++)
3075  {
3076 
3077  MG_TRIANGLE* t1=(MG_TRIANGLE *)no1->get_lien_triangle()->get(j);
3078  if (t1->get_lien_topologie()->get_dimension()==2)
3079 
3080 
3081  {
3082  lst1.ajouter(t1);
3083  }
3084 
3085  }
3086  for(int k=0;k<nbtriangle2;k++)
3087  {
3088 
3089  MG_TRIANGLE* t2=(MG_TRIANGLE *)no2->get_lien_triangle()->get(k);
3090  if (t2->get_lien_topologie()->get_dimension()==2)
3091 
3092  {
3093  lst2.ajouter(t2);
3094  }
3095  }
3096  int c=0;
3097  int g=0;
3098  MG_TRIANGLE * tri1;
3099  MG_TRIANGLE * tri2;
3100  for(tri1=lst1.get_premier(itlst1);tri1;tri1=lst1.get_suivant(itlst1))
3101  {
3102  for(tri2=lst2.get_premier(itlst2);tri2;tri2=lst2.get_suivant(itlst2))
3103  {
3104  if (tri1->get_id()==tri2->get_id())
3105  {
3106  lst3.ajouter(tri1);
3107 
3108  }
3109  }
3110  }
3111  MG_MAILLAGE_OUTILS ang(mai);
3112  MG_TRIANGLE *tri3;
3113  MG_TRIANGLE *tri4;
3114  tri3=lst3.get_premier(itlst3);
3115  //printf("triangle 1 %lu noeud1 %lu noeud2 %lu noeud3 %lu\n",tri3->get_id(),tri3->get_noeud1()->get_id(),tri3->get_noeud2()->get_id(),tri3->get_noeud3()->get_id());
3116  tri4=lst3.get_suivant(itlst3);
3117  //printf("triangle 2 %lu noeud1 %lu noeud2 %lu noeud3 %lu\n",tri4->get_id(),tri4->get_noeud1()->get_id(),tri4->get_noeud2()->get_id(),tri4->get_noeud3()->get_id());
3118  angle1=ang.get_angle(tri3,tri4);
3119  H1=(longueur* (M_PI-angle1));
3120  H2+=H1;
3121  //angle2+=angle1;
3122  }
3123  }
3124  }
3125 
3126  return H2;
3127 }
3128 
3129 void MG_MAILLAGE_OUTILS::get_noeud_voisin(MG_NOEUD* no, TPL_MAP_ENTITE< MG_NOEUD* > &liste,int niveau)
3130 {
3131 if (niveau==1)
3132  {
3133  int nbvoisin=no->get_lien_segment()->get_nb();
3134  for (int i=0;i<nbvoisin;i++)
3135  {
3136  liste.ajouter(no->get_lien_segment()->get(i)->get_noeud1());
3137  liste.ajouter(no->get_lien_segment()->get(i)->get_noeud2());
3138  }
3139  }
3140 if (niveau==2)
3141  {
3142  int nbvoisin=no->get_lien_triangle()->get_nb();
3143  for (int i=0;i<nbvoisin;i++)
3144  {
3145  liste.ajouter(no->get_lien_triangle()->get(i)->get_noeud1());
3146  liste.ajouter(no->get_lien_triangle()->get(i)->get_noeud2());
3147  liste.ajouter(no->get_lien_triangle()->get(i)->get_noeud3());
3148  }
3149  nbvoisin=no->get_lien_quadrangle()->get_nb();
3150  for (int i=0;i<nbvoisin;i++)
3151  {
3152  liste.ajouter(no->get_lien_quadrangle()->get(i)->get_noeud1());
3153  liste.ajouter(no->get_lien_quadrangle()->get(i)->get_noeud2());
3154  liste.ajouter(no->get_lien_quadrangle()->get(i)->get_noeud3());
3155  liste.ajouter(no->get_lien_quadrangle()->get(i)->get_noeud4());
3156  }
3157  }
3158 if (niveau==3)
3159  {
3160  int nbvoisin=no->get_lien_tetra()->get_nb();
3161  for (int i=0;i<nbvoisin;i++)
3162  {
3163  liste.ajouter(no->get_lien_tetra()->get(i)->get_noeud1());
3164  liste.ajouter(no->get_lien_tetra()->get(i)->get_noeud2());
3165  liste.ajouter(no->get_lien_tetra()->get(i)->get_noeud3());
3166  liste.ajouter(no->get_lien_tetra()->get(i)->get_noeud4());
3167  }
3168  nbvoisin=no->get_lien_hexa()->get_nb();
3169  for (int i=0;i<nbvoisin;i++)
3170  {
3171  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud1());
3172  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud2());
3173  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud3());
3174  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud4());
3175  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud5());
3176  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud6());
3177  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud7());
3178  liste.ajouter(no->get_lien_hexa()->get(i)->get_noeud8());
3179  }
3180  }
3181 liste.supprimer(no);
3182 
3183 }
3184 
3185 
3186 double MG_MAILLAGE_OUTILS::get_volume(MG_MAILLAGE* mai)
3187 {
3188 double volume=0;
3189 LISTE_MG_TRIANGLE::iterator it;
3190 for (MG_TRIANGLE* tri=mai->get_premier_triangle(it);tri!=NULL;tri=mai->get_suivant_triangle(it))
3191  {
3192  MG_NOEUD* no1=tri->get_noeud1();
3193  MG_NOEUD* no2=tri->get_noeud2();
3194  MG_NOEUD* no3=tri->get_noeud3();
3195  double *xyz1=no1->get_coord();
3196  double *xyz2=no2->get_coord();
3197  double *xyz3=no3->get_coord();
3198  OT_VECTEUR_3D vec1(xyz1,xyz2);
3199  OT_VECTEUR_3D vec2(xyz1,xyz3);
3200  OT_VECTEUR_3D n=vec2&vec1;
3201  double detj=n.get_longueur();
3202  n.norme();
3203  for (int k=0;k<3;k++)
3204  {
3205  double xsi=1./6.;
3206  double eta=1./6.;
3207  double wi=1./6.;
3208  if (k==1) xsi=2./3.;
3209  if (k==2) eta=2./3.;
3210  double x=(1-xsi-eta)*xyz1[0]+xsi*xyz2[0]+eta*xyz3[0];
3211  OT_VECTEUR_3D psi1(x,0,0);
3212  volume=volume+detj*wi*(psi1*n);
3213  }
3214  }
3215 return volume;
3216 }
3217 
3218 int MG_MAILLAGE_OUTILS::est_delaunay_generalise(double* xyz, MG_TRIANGLE* tri)
3219 {
3220 double *xyz1=tri->get_noeud1()->get_coord();
3221 double *xyz2=tri->get_noeud2()->get_coord();
3222 double *xyz3=tri->get_noeud3()->get_coord();
3223 OT_VECTEUR_3D ab(xyz1,xyz2);
3224 OT_VECTEUR_3D ac(xyz1,xyz3);
3225 OT_VECTEUR_3D bc(xyz2,xyz3);
3226 double a=bc.get_longueur();
3227 double b=ac.get_longueur();
3228 double c=ab.get_longueur();
3229 ab.norme();
3230 ac.norme();
3231 bc.norme();
3232 double aa=acos(ab*ac);
3233 double bb=-acos(bc*ab);
3234 double cc=acos(ac*bc);
3235 double centre[3];
3236 centre[0]=(sin(2.*aa)*xyz1[0]+sin(2.*bb)*xyz2[0]+sin(2.*cc)*xyz3[0])/(sin(2.*aa)+sin(2.*bb)+sin(2.*cc));
3237 centre[1]=(sin(2.*aa)*xyz1[1]+sin(2.*bb)*xyz2[1]+sin(2.*cc)*xyz3[1])/(sin(2.*aa)+sin(2.*bb)+sin(2.*cc));
3238 centre[2]=(sin(2.*aa)*xyz1[2]+sin(2.*bb)*xyz2[2]+sin(2.*cc)*xyz3[2])/(sin(2.*aa)+sin(2.*bb)+sin(2.*cc));
3239 double r=(a+b+c)/2./(sin(aa)+sin(bb)+sin(cc));
3240 OT_VECTEUR_3D vec(xyz,centre);
3241 double crit=vec.get_longueur();
3242 double epsilon=1e-12*(a+b+c)/3.;
3243 if (crit>r+epsilon) return 2;
3244 if (crit>r-epsilon) return 1;
3245 return 0;
3246 
3247 }
3248 
3249 
TPL_MAP_ENTITE::supprimer
virtual void supprimer(X x)
Definition: tpl_map_entite.h:69
MG_SOMMET::get_mg_cosommet
virtual MG_COSOMMET * get_mg_cosommet(int num)
Definition: mg_sommet.cpp:88
MG_MAILLAGE_OUTILS::calcul_gaussienne_face
double calcul_gaussienne_face(MG_NOEUD *noeud)
Definition: mg_maillage_outils.cpp:2944
MG_GESTIONNAIRE::enregistrer
virtual void enregistrer(std::ostream &o, double version=MAGIC_VERSION_FICHIER_DOUBLE)
Definition: mg_gestionnaire.cpp:1070
MG_ARETE::get_cosommet2
virtual class MG_COSOMMET * get_cosommet2(void)
Definition: mg_arete.cpp:85
TPL_MAP_ENTITE::get_premier
virtual X get_premier(ITERATEUR &it)
Definition: tpl_map_entite.h:112
MG_HEXA::get_noeud4
virtual MG_NOEUD * get_noeud4(void)
Definition: mg_hexa.cpp:214
MG_MAILLAGE_OUTILS::calcul_courbure_arete_virtuelle
void calcul_courbure_arete_virtuelle(MG_NOEUD *noeud, double &kmin, double &kmax, std::map< std::string, double > &liste_kmin, std::map< std::string, double > &liste_kmax)
Definition: mg_maillage_outils.cpp:2526
MG_TRIANGLE::get_segment1
virtual MG_SEGMENT * get_segment1(void)
Definition: mg_triangle.cpp:142
MG_SEGMENT
Definition: mg_segment.h:38
MG_MAILLAGE_OUTILS::_FilterGeometricTolerance
static void _FilterGeometricTolerance(const std::vector< MG_NOEUD * > &__nodes, std::set< MG_ARETE * > &__lst_edge)
Definition: mg_maillage_outils.cpp:741
MG_MAILLAGE_OUTILS::calcul_courbure_discrete
void calcul_courbure_discrete(class MG_GESTIONNAIRE &gest, char *nom, int nummai, char *outputgestnom, int opensurafece)
Definition: mg_maillage_outils.cpp:1464
tpl_fonctions_generiques.h
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
MG_BOUCLE
Definition: mg_boucle.h:35
gestionversion.h
MG_BOUCLE::get_nb_mg_coarete
virtual int get_nb_mg_coarete(void)
Definition: mg_boucle.cpp:78
fem_element3.h
TPL_MAP_ENTITE< MG_NOEUD * >
MG_MAILLAGE_OUTILS::mai
MG_MAILLAGE * mai
Definition: mg_maillage_outils.h:169
MG_ARETE::evaluer
virtual void evaluer(double t, double *xyz)
Definition: mg_arete.cpp:143
mg_gestionnaire.h
MG_SEGMENT::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_segment.cpp:113
MG_NOEUD::get_lien_quadrangle
TPL_LISTE_ENTITE< class MG_QUADRANGLE * > * get_lien_quadrangle(void)
Definition: mg_noeud.cpp:164
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
OT_CPU
Definition: ot_cpu.h:31
MG_MAILLAGE_OUTILS::calcul_courbure_face_arete_sommet
void calcul_courbure_face_arete_sommet(MG_NOEUD *noeud, double &kmin1, double &kmax1, double &kmin2, double &kmax2, std::map< std::string, double > &liste_kmin, std::map< std::string, double > &liste_kmax, std::map< std::string, double > &liste_gau, std::map< std::string, double > &liste_courburemax1, std::map< std::string, double > &liste_courburemax2, std::map< std::string, double > &liste_courburemax3, std::map< std::string, double > &liste_courburemax4, std::map< std::string, double > &liste_courburemax5, int opensurafece)
Definition: mg_maillage_outils.cpp:1575
TPL_SET< MG_ELEMENT_MAILLAGE * >
MG_COSOMMET
Definition: mg_cosommet.h:31
robustPredicates::epsilon
static REAL epsilon
Definition: robustpredicates.cc:371
a
#define a(i, j)
MG_MAILLAGE_OUTILS::SplitEdgeInMesh
static void SplitEdgeInMesh(MG_MAILLAGE *__mesh, class MG_ARETE *__origEdge, class MG_SOMMET *__splitVertex, class MG_ARETE *__arete_gauche, MG_ARETE *__arete_droite, MG_SEGMENT **__origSegment, MG_NOEUD **__splitNode, MG_SEGMENT *__splitSegments[2])
Definition: mg_maillage_outils.cpp:975
OPERATEUR::projeteestdansletriangle
static int projeteestdansletriangle(double *xyz1, double *xyz2, double *xyz3, double x, double y, double z)
Definition: ot_mathematique.cpp:1748
MG_QUADRANGLE::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_quadrangle.cpp:150
fem_noeud.h
MG_ELEMENT_MAILLAGE
Definition: mg_element_maillage.h:38
MG_MAILLAGE::supprimer_mg_segmentid
int supprimer_mg_segmentid(unsigned long num)
Definition: mg_maillage.cpp:652
MG_TRIANGLE::get_segment2
virtual MG_SEGMENT * get_segment2(void)
Definition: mg_triangle.cpp:147
MG_MAILLAGE_OUTILS::_FilterSegmentsAndEdgeAdjacentToSameFaces
static void _FilterSegmentsAndEdgeAdjacentToSameFaces(std::vector< MG_SEGMENT * > &__segments, std::set< MG_ARETE * > &__lst_edge)
Definition: mg_maillage_outils.cpp:609
MG_SOLUTION
Definition: mg_solution.h:46
MG_GESTIONNAIRE::get_nb_mg_geometrie
unsigned int get_nb_mg_geometrie(void)
Definition: mg_gestionnaire.cpp:358
TPL_SET::get_premier
X get_premier(ITERATEUR &it)
Definition: tpl_set.h:99
ot_cpu.h
MG_MAILLAGE_OUTILS::calcul_surface_triangle_face
double calcul_surface_triangle_face(MG_NOEUD *noeud)
Definition: mg_maillage_outils.cpp:2879
OT_CPU::ajouter_etape
double ajouter_etape(std::string nom)
Definition: ot_cpu.cpp:58
OT_ALGORITHME_GEOMETRIQUE::Dist3D_Point_Segment
static double Dist3D_Point_Segment(double a[3], double b[3], double c[3])
Definition: ot_algorithme_geometrique.cpp:299
OPERATEUR::compare_etat_triangle
static int compare_etat_triangle(int etat, int valeur)
Definition: ot_mathematique.cpp:1857
OPERATEUR::estdansletetra
static int estdansletetra(double *xyz1, double *xyz2, double *xyz3, double *xyz4, double x, double y, double z)
Definition: ot_mathematique.cpp:1709
MG_COARETE::get_boucle
virtual MG_BOUCLE * get_boucle(void)
Definition: mg_coarete.cpp:53
MG_ELEMENT_TOPOLOGIQUE::get_dimension
virtual int get_dimension(void)=0
MG_COFACE::get_orientation
virtual int get_orientation(void)
Definition: mg_coface.cpp:69
MG_ELEMENT_MAILLAGE::change_lien_topologie
void change_lien_topologie(MG_ELEMENT_TOPOLOGIQUE *topo)
Definition: mg_element_maillage.cpp:56
MAGIC::ORIGINE::MODIFICATION
@ MODIFICATION
Definition: mg_definition.h:79
MG_TRIANGLE
Definition: mg_triangle.h:38
MG_MAILLAGE_OUTILS::classe_elements_dimension1
static void classe_elements_dimension1(std::set< MG_SEGMENT * > &__unvisitedSegs, std::vector< MG_SEGMENT * > &__visitedSegs, std::vector< MG_NOEUD * > &__visitedNodes)
Definition: mg_maillage_outils.cpp:427
MG_MAILLAGE_OUTILS::get_angle
double get_angle(class MG_TRIANGLE *ele1, class MG_TRIANGLE *ele2)
Definition: mg_maillage_outils.cpp:93
MG_GESTIONNAIRE
Definition: mg_gestionnaire.h:57
OT_VECTEUR_3D::get_x
virtual double get_x(void) const
Definition: ot_mathematique.cpp:417
mg_noeud.h
MG_TRIANGLE::get_segment3
virtual MG_SEGMENT * get_segment3(void)
Definition: mg_triangle.cpp:152
MG_FACE::get_nb_mg_boucle
virtual int get_nb_mg_boucle(void)
Definition: mg_face.cpp:67
MG_MAILLAGE::get_premier_segment
MG_SEGMENT * get_premier_segment(LISTE_MG_SEGMENT::iterator &)
Definition: mg_maillage.cpp:630
OPERATEUR::projetedansletriangle
static void projetedansletriangle(double *xyz1, double *xyz2, double *xyz3, double x, double y, double z, double &xx, double &yy, double &zz)
Definition: ot_mathematique.cpp:1755
MG_TETRA
Definition: mg_tetra.h:37
MG_MAILLAGE_OUTILS::classe_elements_dimension1__trouver_prochains_elements
static void classe_elements_dimension1__trouver_prochains_elements(std::set< MG_SEGMENT * > &__unvisitedSegs, std::vector< MG_SEGMENT * > &__visitedSegs, std::vector< MG_NOEUD * > &__visitedNodes, MG_NOEUD *&__nextNode, MG_SEGMENT *&__nextSeg)
Definition: mg_maillage_outils.cpp:303
MG_MAILLAGE_OUTILS::IdentifyEdge1
static void IdentifyEdge1(std::set< MG_SOMMET * > __vertices, std::set< class MG_FACE * > &__adjacentFaces, std::set< MG_ARETE * > &__edge)
Definition: mg_maillage_outils.cpp:450
MG_SOMMET::get_nb_mg_cosommet
virtual int get_nb_mg_cosommet(void)
Definition: mg_sommet.cpp:64
MG_MAILLAGE_OUTILS::change_lien_maillage
static void change_lien_maillage(class MG_ELEMENT_TOPOLOGIQUE *__old_topo, MG_ELEMENT_TOPOLOGIQUE *__new_topo, MG_MAILLAGE *__mesh=0)
Definition: mg_maillage_outils.cpp:924
MG_MAILLAGE_OUTILS::_FilterGeometricTolerance5
static void _FilterGeometricTolerance5(const std::vector< MG_NOEUD * > &__nodes, const std::vector< MG_SEGMENT * > &__segs, std::set< MG_ARETE * > &__lst_edge)
Definition: mg_maillage_outils.cpp:825
occ_import.h
MG_MAILLAGE_OUTILS::classe_elements_dimension1__trouver_noeud_dimension0
static MG_NOEUD * classe_elements_dimension1__trouver_noeud_dimension0(const std::set< MG_SEGMENT * > &__unvisitedSegs)
Definition: mg_maillage_outils.cpp:382
MG_NOEUD::get_lien_hexa
TPL_LISTE_ENTITE< class MG_HEXA * > * get_lien_hexa(void)
Definition: mg_noeud.cpp:186
MG_HEXA::get_noeud5
virtual MG_NOEUD * get_noeud5(void)
Definition: mg_hexa.cpp:218
MG_MAILLAGE_OUTILS
Definition: mg_maillage_outils.h:47
MG_ARETE::get_tmin
virtual double get_tmin(void)
Definition: mg_arete.cpp:179
ot_decalage_parametre.h
MG_ELEMENT_TOPOLOGIQUE::get_lien_maillage
virtual TPL_SET< MG_ELEMENT_MAILLAGE * > * get_lien_maillage(void)
Definition: mg_element_topologique.cpp:62
MG_HEXA::get_noeud8
virtual MG_NOEUD * get_noeud8(void)
Definition: mg_hexa.cpp:230
MG_HEXA::get_noeud3
virtual MG_NOEUD * get_noeud3(void)
Definition: mg_hexa.cpp:209
MG_MAILLAGE_OUTILS::~MG_MAILLAGE_OUTILS
~MG_MAILLAGE_OUTILS()
Definition: mg_maillage_outils.cpp:1286
MG_ELEMENT_TOPOLOGIQUE
Definition: mg_element_topologique.h:51
MG_FACE::inverser
virtual void inverser(double *uv, double *xyz, double precision=1e-6)
Definition: mg_face.cpp:228
MG_MAILLAGE_OUTILS::calcul_surface_lsttriangle
double calcul_surface_lsttriangle(MG_NOEUD *noeud, MG_TRIANGLE *tr1)
Definition: mg_maillage_outils.cpp:2755
MG_MAILLAGE_OUTILS::TestDistanceEdge
static double TestDistanceEdge(MG_ARETE *candidate_edge, double *xyz_node)
Definition: mg_maillage_outils.cpp:721
MG_ARETE::inverser
virtual void inverser(double &t, double *xyz, double precision=1e-6)
Definition: mg_arete.cpp:173
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_MAILLAGE_OUTILS::calcul_courbure_face
void calcul_courbure_face(MG_NOEUD *noeud, double &kmin, double &kmax, std::map< std::string, double > &liste_kmin, std::map< std::string, double > &liste_kmax, std::map< std::string, double > &liste_gau, std::map< std::string, double > &liste_courburemax1, std::map< std::string, double > &liste_courburemax2, std::map< std::string, double > &liste_courburemax3, std::map< std::string, double > &liste_courburemax4, std::map< std::string, double > &liste_courburemax5)
Definition: mg_maillage_outils.cpp:2594
MG_SOLUTION::ecrire
void ecrire(double val, int i, int j, int coord=0, int num_no=0)
Definition: mg_solution.cpp:309
MG_MAILLAGE_OUTILS::TestDistanceEdgeNode
static double TestDistanceEdgeNode(MG_ARETE *candidate_edge, MG_NOEUD *test_node)
Definition: mg_maillage_outils.cpp:709
OPERATEUR::compare_etat_tetra
static int compare_etat_tetra(int etat, int valeur)
Definition: ot_mathematique.cpp:1828
MG_MAILLAGE_OUTILS::calcul_moyenne_face
double calcul_moyenne_face(MG_NOEUD *noeud)
Definition: mg_maillage_outils.cpp:3035
MG_ARETE::get_nb_mg_coarete
virtual int get_nb_mg_coarete(void)
Definition: mg_arete.cpp:106
EdgeMeshHasNode
bool EdgeMeshHasNode(MG_MAILLAGE *__mesh, MG_ARETE *__edge, MG_NOEUD *__node)
Definition: mg_maillage_outils.cpp:135
mg_maillage_outils.h
f
double f(double x, long nb, double *xfonc, double *fonc, double eng, double eni, double lambda, double nor, double *fonc2)
Definition: fct_generateur_calibrage.cpp:96
mg_segment.h
MG_MAILLAGE_OUTILS::IdentifyEdge5
static void IdentifyEdge5(const std::set< MG_SOMMET * > __vertices, const std::set< MG_ARETE * > &__lst_edge, const std::vector< MG_NOEUD * > &__nodes, const std::vector< MG_SEGMENT * > &__segs, MG_ARETE **__edge)
Definition: mg_maillage_outils.cpp:576
MG_MAILLAGE::get_premier_triangle
MG_TRIANGLE * get_premier_triangle(LISTE_MG_TRIANGLE::iterator &it)
Definition: mg_maillage.cpp:912
MG_HEXA::get_noeud2
virtual MG_NOEUD * get_noeud2(void)
Definition: mg_hexa.cpp:204
MG_MAILLAGE_OUTILS::FindCommonEdgesOfFaces
static void FindCommonEdgesOfFaces(std::set< MG_FACE * > &__faces, std::set< MG_ARETE * > &__commonEdges)
Definition: mg_maillage_outils.cpp:871
OT_CPU::get_tabfinal
void get_tabfinal(std::vector< std::string > &tab)
Definition: ot_cpu.cpp:107
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
MG_NOEUD::get_lien_segment
TPL_LISTE_ENTITE< class MG_SEGMENT * > * get_lien_segment(void)
Definition: mg_noeud.cpp:141
MG_MAILLAGE::supprimer_mg_triangleid
int supprimer_mg_triangleid(unsigned long num)
Definition: mg_maillage.cpp:820
MG_FACE::get_mg_coface
virtual MG_COFACE * get_mg_coface(int num)
Definition: mg_face.cpp:104
TPL_MAP_ENTITE::get_nb
virtual int get_nb(void)
Definition: tpl_map_entite.h:83
MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD
@ ENTITE_ELEMENT2_NOEUD
Definition: mg_definition.h:86
MG_MAILLAGE_OUTILS::estdansletetra
int estdansletetra(class MG_TETRA *tet, double x, double y, double z)
Definition: mg_maillage_outils.cpp:43
MG_NOEUD
Definition: mg_noeud.h:41
TPL_SET::get_nb
int get_nb(void)
Definition: tpl_set.h:78
OT_ALGORITHME_GEOMETRIQUE::Closest_Point_to_Segment_3d
static int Closest_Point_to_Segment_3d(double a[3], double b[3], double c[3], double d[3])
Definition: ot_algorithme_geometrique.cpp:177
MG_COSOMMET::get_arete
virtual MG_ARETE * get_arete(void)
Definition: mg_cosommet.cpp:88
MG_MAILLAGE::get_suivant_segment
MG_SEGMENT * get_suivant_segment(LISTE_MG_SEGMENT::iterator &)
Definition: mg_maillage.cpp:638
V
void V(MCAA *mcaa)
Definition: CAD4FE_MCAA.cpp:1794
MG_MAILLAGE_OUTILS::calcul_courbure_sommet
void calcul_courbure_sommet(MG_NOEUD *noeud, double &kmin1, double &kmax1, double &kmin2, double &kmax2, std::map< std::string, double > &liste_kmin, std::map< std::string, double > &liste_kmax)
Definition: mg_maillage_outils.cpp:1662
MG_MAILLAGE_OUTILS::get_volume
double get_volume(MG_MAILLAGE *mai)
Definition: mg_maillage_outils.cpp:3186
EdgeMeshStats
void EdgeMeshStats(MG_MAILLAGE *__mesh, MG_ARETE *__edge, int &nSeg, int &nNodesVertex)
Definition: mg_maillage_outils.cpp:109
MG_NOEUD::get_coord
virtual double * get_coord(void)
Definition: mg_noeud.cpp:92
MG_BOUCLE::get_mg_face
virtual MG_FACE * get_mg_face(void)
Definition: mg_boucle.cpp:102
MG_GESTIONNAIRE::get_mg_maillage
MG_MAILLAGE * get_mg_maillage(unsigned int num)
Definition: mg_gestionnaire.cpp:550
MG_HEXA::get_noeud6
virtual MG_NOEUD * get_noeud6(void)
Definition: mg_hexa.cpp:222
TPL_LISTE_ENTITE::get_nb
virtual int get_nb(void)
Definition: tpl_liste_entite.h:67
MG_SOMMET::get_point
virtual MG_POINT * get_point(void)
Definition: mg_sommet.cpp:52
node
#define node(i, j)
OT_VECTEUR_3D::norme
virtual void norme(void)
Definition: ot_mathematique.cpp:494
MG_ELEMENT_MAILLAGE::change_lien_topologie2
void change_lien_topologie2(MG_ELEMENT_TOPOLOGIQUE *topo)
Definition: mg_element_maillage.cpp:69
MG_MAILLAGE_OUTILS::calcul_angle_lsttriangle
double calcul_angle_lsttriangle(MG_NOEUD *noeud, MG_TRIANGLE *tr1)
Definition: mg_maillage_outils.cpp:2808
MG_MAILLAGE_OUTILS::IdentifyEdge2
static void IdentifyEdge2(std::set< MG_SOMMET * > __vertices, std::set< MG_FACE * > &__adjacentFaces, std::set< MG_ARETE * > &__lst_edge, std::vector< MG_NOEUD * > &__nodes)
Definition: mg_maillage_outils.cpp:498
MG_MAILLAGE::get_nb_mg_segment
unsigned int get_nb_mg_segment(void)
Definition: mg_maillage.cpp:646
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_NOEUD::get_lien_tetra
TPL_LISTE_ENTITE< class MG_TETRA * > * get_lien_tetra(void)
Definition: mg_noeud.cpp:175
MG_COSOMMET::get_sommet
virtual MG_SOMMET * get_sommet(void)
Definition: mg_cosommet.cpp:83
MG_MAILLAGE_OUTILS::est_delaunay_generalise
int est_delaunay_generalise(double *xyz, MG_TRIANGLE *tri)
Definition: mg_maillage_outils.cpp:3218
MG_MAILLAGE_OUTILS::calcul_courbure
void calcul_courbure(class MG_GESTIONNAIRE &gest, char *solnom, int nummai, int numgeo, char *outputgestnom)
Definition: mg_maillage_outils.cpp:1296
TPL_LISTE_ENTITE::get
virtual X get(int num)
Definition: tpl_liste_entite.h:72
MG_SOLUTION::change_legende
void change_legende(int num, std::string val)
Definition: mg_solution.cpp:328
OT_VECTEUR_3D::get_y
virtual double get_y(void) const
Definition: ot_mathematique.cpp:423
MG_GEOMETRIE::get_nb_mg_face
unsigned int get_nb_mg_face(void)
Definition: mg_geometrie.cpp:1264
MG_NOEUD::get_x
virtual double get_x(void)
Definition: mg_noeud.cpp:77
acos
double2 acos(double2 &val)
Definition: ot_doubleprecision.cpp:224
OT_REFERENCE::decrementer
void decrementer(void)
Definition: ot_reference.cpp:45
MG_MAILLAGE_OUTILS::inserer_noeud_segment
static void inserer_noeud_segment(class MG_MAILLAGE *__mesh, class MG_NOEUD *__node, class MG_SEGMENT *__splitSeg, MG_SEGMENT *__segs[2], bool __deleteOriginalSeg=true)
Definition: mg_maillage_outils.cpp:174
OT_VECTEUR_3D
Definition: ot_mathematique.h:94
TPL_MAP_ENTITE::ajouter
virtual void ajouter(X x)
Definition: tpl_map_entite.h:55
TPL_SET::get
X get(int num)
Definition: tpl_set.h:84
MG_MAILLAGE_OUTILS::projetedansletriangle
void projetedansletriangle(MG_TRIANGLE *tri, double x, double y, double z, double &xx, double &yy, double &zz)
Definition: mg_maillage_outils.cpp:72
MG_MAILLAGE_OUTILS::calcul_courbure_arete_nonvirtuelle
void calcul_courbure_arete_nonvirtuelle(MG_NOEUD *noeud, double &kmin1, double &kmax1, double &kmin2, double &kmax2, std::map< std::string, double > &liste_kmin, std::map< std::string, double > &liste_kmax)
Definition: mg_maillage_outils.cpp:2361
MG_MAILLAGE_OUTILS::compare_etat_tetra
int compare_etat_tetra(int etat, int valeur)
Definition: mg_maillage_outils.cpp:82
MG_TRIANGLE::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_triangle.cpp:126
mg_maillage.h
MG_FACE::get_LMN
virtual void get_LMN(double *uv, double &L, double &M, double &N)
Definition: mg_face.cpp:301
MG_BOUCLE::get_mg_coarete
virtual MG_COARETE * get_mg_coarete(int num)
Definition: mg_boucle.cpp:84
MG_MAILLAGE_OUTILS::nummai
int nummai
Definition: mg_maillage_outils.h:170
MG_TETRA::get_noeud4
virtual MG_NOEUD * get_noeud4(void)
Definition: mg_tetra.cpp:158
sqrt
double2 sqrt(double2 &val)
Definition: ot_doubleprecision.cpp:345
MG_MAILLAGE_OUTILS::projeteestdansletriangle
int projeteestdansletriangle(MG_TRIANGLE *tri, double x, double y, double z)
Definition: mg_maillage_outils.cpp:62
MG_GESTIONNAIRE::get_mg_maillageid
MG_MAILLAGE * get_mg_maillageid(unsigned long num)
Definition: mg_gestionnaire.cpp:538
MG_MAILLAGE_OUTILS::MG_MAILLAGE_OUTILS
MG_MAILLAGE_OUTILS()
Definition: mg_maillage_outils.cpp:1272
MG_MAILLAGE_OUTILS::IdentifyEdge3
static void IdentifyEdge3(std::set< MG_SOMMET * > __vertices, std::set< MG_ARETE * > &__lst_edge, std::vector< MG_NOEUD * > &__nodes, MG_ARETE **__edge)
Definition: mg_maillage_outils.cpp:548
MG_ELEMENT_MAILLAGE::get_lien_topologie
MG_ELEMENT_TOPOLOGIQUE * get_lien_topologie(void)
Definition: mg_element_maillage.cpp:51
MG_MAILLAGE_OUTILS::calcul_angle_lstsegment
double calcul_angle_lstsegment(MG_NOEUD *noeud, MG_SEGMENT *se1)
Definition: mg_maillage_outils.cpp:2651
MG_MAILLAGE_OUTILS::IdentifyEdge4
static void IdentifyEdge4(std::set< MG_SOMMET * > __vertices, std::set< MG_ARETE * > &__lst_edge, std::vector< MG_NOEUD * > &__nodes, std::vector< MG_SEGMENT * > &__segments, MG_ARETE **__edge)
Definition: mg_maillage_outils.cpp:673
ot_algorithme_geometrique.h
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
MG_MAILLAGE::get_nb_mg_noeud
unsigned int get_nb_mg_noeud(void)
Definition: mg_maillage.cpp:476
OT_VECTEUR_3D::get_z
virtual double get_z(void) const
Definition: ot_mathematique.cpp:429
MG_GEOMETRIE
Definition: mg_geometrie.h:84
OPERATEUR::estdansletriangle
static int estdansletriangle(double *xyz1, double *xyz2, double *xyz3, double x, double y, double z)
Definition: ot_mathematique.cpp:1802
OT_REFERENCE::incrementer
void incrementer(void)
Definition: ot_reference.cpp:40
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
MG_MAILLAGE
Definition: mg_maillage.h:62
TPL_LISTE_ENTITE< class MG_TRIANGLE * >
MG_QUADRANGLE::get_noeud4
virtual MG_NOEUD * get_noeud4(void)
Definition: mg_quadrangle.cpp:161
MG_QUADRANGLE::get_noeud3
virtual MG_NOEUD * get_noeud3(void)
Definition: mg_quadrangle.cpp:156
MG_SEGMENT::get_longueur
virtual double get_longueur(void)
Definition: mg_segment.cpp:125
Point_FindClosestSegment
double Point_FindClosestSegment(double __xyz[3], const std::vector< MG_SEGMENT * > &__segs, MG_SEGMENT *&__closestSeg)
Definition: mg_maillage_outils.cpp:798
MG_HEXA::get_noeud7
virtual MG_NOEUD * get_noeud7(void)
Definition: mg_hexa.cpp:226
MG_MAILLAGE::get_nb_mg_tetra
unsigned int get_nb_mg_tetra(void)
Definition: mg_maillage.cpp:1262
MG_HEXA::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_hexa.cpp:199
MG_MAILLAGE_OUTILS::Conformity_CloseSurfaceMesh
static void Conformity_CloseSurfaceMesh(MG_MAILLAGE *__tess, double __tolerance)
Definition: mg_maillage_outils.cpp:1212
MG_ARETE
Definition: mg_arete.h:36
MG_FACE
Definition: mg_face.h:34
MG_QUADRANGLE::get_noeud1
virtual MG_NOEUD * get_noeud1(void)
Definition: mg_quadrangle.cpp:145
MG_FACE::get_mg_boucle
virtual MG_BOUCLE * get_mg_boucle(int num)
Definition: mg_face.cpp:72
MAGIC::TYPE_SOLUTION::SCALAIRE
@ SCALAIRE
Definition: mg_definition.h:93
MG_ARETE::get_cosommet1
virtual class MG_COSOMMET * get_cosommet1(void)
Definition: mg_arete.cpp:81
TPL_MAP_ENTITE::get_suivant
virtual X get_suivant(ITERATEUR &it)
Definition: tpl_map_entite.h:120
MG_SOMMET
Definition: mg_sommet.h:35
MG_IDENTIFICATEUR
Definition: mg_identificateur.h:34
MG_ARETE::get_longueur
virtual double get_longueur(double t1, double t2, double precis=1e-6)
Definition: mg_arete.cpp:193
MG_GEOMETRIE_OUTILS
Definition: mg_geometrie_outils.h:37
MG_MAILLAGE::contient
bool contient(MG_IDENTIFICATEUR *id)
Definition: mg_maillage.cpp:2180
MG_COARETE::get_arete
virtual MG_ARETE * get_arete(void)
Definition: mg_coarete.cpp:58
MG_GESTIONNAIRE::get_mg_geometrie
MG_GEOMETRIE * get_mg_geometrie(unsigned int num)
Definition: mg_gestionnaire.cpp:331
MG_GEOMETRIE_OUTILS::arete_virtuelle
int arete_virtuelle(class MG_ARETE *are, MG_FACE **tabface=NULL)
Definition: mg_geometrie_outils.cpp:585
tpl_liste_entite.h
MG_FACE::get_EFG
virtual void get_EFG(double *uv, double &E, double &F, double &G)
Definition: mg_face.cpp:264
MG_MAILLAGE::get_suivant_noeud
MG_NOEUD * get_suivant_noeud(LISTE_MG_NOEUD::iterator &it)
Definition: mg_maillage.cpp:556
MG_ARETE::get_tmax
virtual double get_tmax(void)
Definition: mg_arete.cpp:184
OT_ALGORITHME_GEOMETRIQUE::VEC3_DISTANCE_VEC3
static double VEC3_DISTANCE_VEC3(double a[3], double b[3])
Definition: ot_algorithme_geometrique.h:127
MG_GESTIONNAIRE::get_mg_geometrieid
MG_GEOMETRIE * get_mg_geometrieid(unsigned long num)
Definition: mg_gestionnaire.cpp:319
MG_MAILLAGE_OUTILS::calcul_courbure_arete
void calcul_courbure_arete(MG_NOEUD *noeud, double &kmin1, double &kmax1, double &kmin2, double &kmax2, std::map< std::string, double > &liste_kmin, std::map< std::string, double > &liste_kmax)
Definition: mg_maillage_outils.cpp:1616
MG_MAILLAGE_OUTILS::compare_etat_triangle
int compare_etat_triangle(int etat, int valeur)
Definition: mg_maillage_outils.cpp:87
MG_POINT::evaluer
virtual void evaluer(double *xyz)=0
mg_solution.h
MG_GESTIONNAIRE::ajouter_mg_solution
int ajouter_mg_solution(MG_SOLUTION *mgsol)
Definition: mg_gestionnaire.cpp:764
MG_MAILLAGE_OUTILS::estdansletriangle
int estdansletriangle(MG_TRIANGLE *tri, double x, double y, double z)
Definition: mg_maillage_outils.cpp:53
TPL_SET::get_suivant
X get_suivant(ITERATEUR &it)
Definition: tpl_set.h:107
MG_ARETE::get_mg_coarete
virtual MG_COARETE * get_mg_coarete(int num)
Definition: mg_arete.cpp:228
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
sin
double2 sin(double2 &val)
Definition: ot_doubleprecision.cpp:250