Maillage et Visualisation Université Pierre et Marie Curie

Les trois projets
—–
Maillage et Visualisation
Université Pierre et Marie Curie
P. Frey, F. Hecht
EPU 3 / session 2006/2007
Table des matières
1 Sujet 1 : Algorithme de Maillage de Delaunay 1
1.1 Méthodeoptimisation...................................... 2
1.2 Structurededonnées ...................................... 2
1.3 Àfairepourleprojet1 ..................................... 3
2 Sujet 2 : Interpolation de solution 3
2.1 Àfairepourleprojet2 ..................................... 3
3 Sujet 3 : Visualisation d’un maillage et d’une solution associée 4
3.1 Àfairepourleprojet3 ..................................... 4
Introduction
Pour tout projet , il faut faire un document d’une dizaine de pages (sans les sources des programmes, ni
les dessins). Il faut bien sur présenter les phases d’analyse algorithmique, de validation, et d’exploitation.
Le projet est a rendre avant le dimanche 21 janvier à 24h par courriel aux
adresses : [email protected] et [email protected]
1 Sujet 1 : Algorithme de Maillage de Delaunay
But : générer la triangulation de Delaunay d’un ensemble de Nppoints de [0,1]2tirer aléatoirement
Voilà l’algorithme insertion des points
1

Projet Maillage et Visualisation 2
Algorithme 1
1. Générer un maillage formé d’un triangle (ou rectangle), qui contiendra tous les
points du futur maillage.
2. Ajouter les points Npun à un suivant un ordre aléatoire.
Les points ajoutés sont toujours dans un ou deux triangles. Trouvez ces triangles
en utilisant l’algorithme de localisation 2 et puis découpez le triangle en 3 tri-
angle ou le quadrangle en 4 triangles.
3. Pour rendre le maillage de Delaunay, il suffit d’appliquer la méthode optimi-
sation du maillage autour du point xken rendant de Delaunay toutes les motifs
formés de 2 triangles contenant le point xk, et cela pour tous les points xkdu
maillage juste après son insertion.
FIG. 1 – Répresentation graphique de l’algorithme 1, où tous les points sont mis dans un rectangle.
1.1 Méthode optimisation
b
12
a
b
12
a
FIG. 2 – Échange de diagonale d’un quadrilatère convexe selon le critère de la boule vide.
Nous ferons un échange de diagonale [sa,sb]dans un quadrilatère convexe de sommets s1,sa,s2,sb(tour-
nant dans le sens trigonométrique) si le critère de la boule vide n’est pas vérifié, comme dans la figure
2.
Le critère de la boule vide dans un quadrilatère convexe s1,sa,s2,sben [s1,s2]est équivalent à l’inégalité
angulaire (propriété des angles inscrits dans un cercle) :
\s1sasb<\s1s2sb
ce qui équivaut au critère d’échange de diagonale optimisé
det(−−→ s2s1,−−→ s2sb) (−−→ sas1,−−→ sasb)>det(−−→ sas1,−−→ sasb) (−−→ s2s1,−−→ s2sb),(1)

Projet Maillage et Visualisation 3
où (., .)est le produit scalaire de IR2.
1.2 Structure de données
Nous allons prendre une structure orientée sommet. C’est-à-dire que chaque sommet aura la double liste
des sommets connectés tournant dans le sens direct. Les triangles ne seront connus que virtuellement.
Je vous conseille d’utiliser la STL pour écrire ce logiciel.
Nous avons besoin d’un algorithme de localisation pour trouver le triangle virtuel qui contient un point.
Il faut quelque peut changer l’algorithme de promenade du cours car nous n’avons pas de triangles mais
seulement des sommets connectés.
Algorithme 2
Partant d’un sommet s, trouver les 2 sommets concécutifs (s,a)et (s,b)du sommet s
(où a et b sont les 2 autres sommets des arêtes), tournant dans le sens trigonométrique,
telles que les aires signées des 2 triangles A =aire(a,p,s)et B =aire(b,s,p)soient
positives.
Soit C =aire(a,b,s)l’aire signé du triangle . Si C ≥0et C −A−B≥0alors le point
p dans le triangle s,a,b sinon choisir aléatoirement le nouveau point s entre les points
a et b et continuer.
1.3 À faire pour le projet 1
Programmez l’algorithme 1 . Faite une étude de la complexité des algorithmes, et une vérification nu-
mérique de la complexité. Une option de visualisation pas à pas pour comprendre de déroulement du pro-
gramme est impérative avec gnuplot.
Pour finir, il faut écrire un fichier maillage au format .msh, pour que freefem++ puisse le lire.
2 Sujet 2 : Interpolation de solution
Le but est d’écrire une programme qui interpole une solution élément fini P
1Lagrange définie sur un
maillage convexe, sur un autre maillage du même domaine convexe.
Pour faire cela, vous aurez à écrire l’algorithme de recherche d’un triangle Kdans un maillage convexe
Thcontenant un point (x,y)suivant :
Algorithme 3
Partant du triangle K,
Pour les 3 arêtes (ai,bi),i=0,1,2du triangle K, tournant dans le sens trigonomé-
trique, calculer l’aire des 3 triangles (ai,bi,p). Si les trois aires sont positives alors
p∈K (stop), sinon nous choisirons comme nouveau triangle K l’un des triangles
adjacents à l’une des arête associée à une aire négative (les ambiguïtés sont levées
aléatoirement).
2.1 À faire pour le projet 2
1. Construire une classe maillage formée d’un tableau de sommets et d’un tableau de triangles, qui lit le
fichier maillage.
2. Construire une méthode dans la classe maillage donnant le triangle K0adjacent d’un triangle Kopposé
à son sommet i∈ {0,1,2}. La complexité de cette fonction doit être constante après bien sur une
unique initialisation en O(nT)ou O(nTlog2(nT)).
Pour cela vous pourrez utiliser le chapitre chaîne et chaînage.
3. Programmez l’algorithme 3 en partant d’un triangle quelconque (ajoutez une nouvelle méthode de la
classe maillage).

Projet Maillage et Visualisation 4
4. Puis trouver pour chaque sommet de autre maillage le triangle le contenant. Afin de briser la com-
plexité algorithmique, il faut utiliser l’assertion suivante : les sommets d’un même triangle sont proche
car les triangles sont petits.
Voila le code freefem++ pour générer un maillage d’un disque avec 50 points sur le cercle.
int n=50 ;
border a(t=0,2*pi){ x=cos(t) ; y=sin(t) ;label=1 ;}
mesh Th= buildmesh(a(n)) ;
savemesh(Th,"c"+n+".msh")
3 Sujet 3 : Visualisation d’un maillage et d’une solution associée
Le but de ce projet de visualiser une fonction fdu carré ]−1,1[2à valeur dans IR avec une précision de
εdonnée.
Il faut donc construire un maillage telle que l’erreur sur chaque arête du maillage soit inférieure à ε.
L’algorithme de raffinement de maillage est très simple : il consiste à couper les arêtes avec une erreur
trop importante en deux parties égales, et à couper ces triangles adjacents en 2 triangles
Si l’on utilise cette technique bêtement, la qualité des triangles devient vite très médiocre. Pour éviter ce
problème, il suffit de découper les arêtes en allant de la plus grande à la plus petite longueur. Pour cela on
utilisera une queue prioritaire (conteneur piriority_queue de la STL ) avec comme relation d’ordre la
longueur de l’arête.
Donc l’algorithme est :
1. insérer les arêtes à découpe dans la queue prioritaire
2. tant que la queue n’est pas vide faire :
(a) Prendre le sommet de la queue et découper les triangles adjacents et ajouter à la queue les arêtes
qui ont une erreur trop grande parmi les 2 nouvelles arêtes créées.
L’erreur sur une arête sera définie par :
e(A,B)'max
α∈Aeα(A,B)
avec eα(A,B) = |α(f(A)+(1−α)f(B)−f(αA+ (1−α)B)|.
L’ensemble Apeut être par exemple {1
2},{1 3,2 3}ou {1 4,2 4,,4 4}, ... suivant les cas.
3.1 À faire pour le projet 3
Programmer l’algorithme precédent pour visualiser les fonctions
f1(x,y) = x2+y2
f2(x,y) = x2+y3+tanh(5sin(2(y+x))
avec la bibliothèque GLUT où le paramètre εpeut être changé interactivement, et bien sur il doit être
possible d’afficher ou non le maillage.
Vous pourrez utiliser le conteneur map de la STL avec une structure d’arêtes comme suit :
vector<Edge> E ; // votre tableau d’arêtes

Projet Maillage et Visualisation 5
map< pair<int,int>,int> VO ; // le numéro k du sommet opposé à l’arête orientée
// si l’arête orientée est i,j alors
// le triangle (i,j,k) tourne dans le sens direct
vector<R2> P ; // votre tableau des coordonné des sommets
Après avoir défini un classe Edge qui modélise une arête
class Edge : pair<int,int>
{publc:
double l ; // la longueur de l’arête
....
Edge (const vector<R2> & P, int i, int j)
:pair<int,int>(i<j ? i : j , i<j ? j : i )
{
...
}
...
} ;
Voilà par exemple de code qui génère une maillage initial avec deux triangles du carré ]−1,1[2.
NbT=2 ;
P.push_back(R2(-1,-1)) ; // sommet 0
P.push_back(R2(1,-1)) ;
P.push_back(R2(1,1)) ;
P.push_back(R2(-1,1)) ; // sommet 3
E.push_back(Edge(P,0,1)) ; // arête 0
E.push_back(Edge(P,1,2)) ;
E.push_back(Edge(P,2,3)) ;
E.push_back(Edge(P,3,0)) ;
E.push_back(Edge(P,0,2)) ; // arête 4
// Les sommet opposées aux arêtes
// il y a 6 ARETES car l’arête (0,2) est interne et vue dans le 2 sens
// attention ici les arêtes sont orientées
VO[make_pair(0,1)]=2 ;
VO[make_pair(1,2)]=0 ;
VO[make_pair(2,3)]=0 ;
VO[make_pair(3,0)]=2 ;
VO[make_pair(2,0)]=1 ; // arête interne, le triangle (2 0 1) tourne de le sens direct
VO[make_pair(0,2)]=3 ; // arête interne, le triangle 0 2 3) tourne de le sens direct