MIM Images
année 2003-2004
http://www710.univ-lyon1.fr/~jciehl/
TD3 - Visualisation et navigation
Dans ce TP, nous allons voir comment visualiser des primitives
plus complexes que les triangles ou quarangles du TP précédent.
Ce sera aussi l'occasion de se confronter aux problèmes liées
à l'affichage efficace d'une grande quantité de géométrie
ainsi qu'aux problèmes liés à la manipulation d'un objet.
En effet, lorsque l'on dispose d'une visualisation interactive, il est souhaitable
de pouvoir positionner, ou orienter, le modèle selon ses désirs.
Ce positionnement dispose de 8 degrés de liberté, et proposer
une interface intuitive pour les spéficier n'est pas si évident.
Dans la première partie, nous allons nous concentrer
sur l'affichage d'une classe de primitive simple : une fonction du type z=
F(x, y), c'est à dire une surface paramétrée. Nous avons
vu que openGL ne sait afficher que des primitives de bas niveau : points,
lignes, triangles, et quadrangles. Il est donc nécessaire de
"découper" notre surface en éléments affichables par
openGL. Une manière simple de réaliser ce découpage
est de découper la surface le long des lignes x=const ou y=const.
On peut également enviseager de découper simultanément
sur x et y.
Dans la deuxième partie, nous nous intérèsseront
à la visualisation interactive d'une surface de ce type et à
comment spécifier sa position et son orientation relativement à
la caméra.
Dans la troisième partie, nous utiliserons une
méthode simple afin de réduire le nombre de polygones affichés
par openGL.
Partie 1 : une surface z= F(x, y)
Pour faire afficher notre primitive par openGL nous allons
devoir la découper en éléments plus simples : un ensemble
de lignes-iso ou un ensemble de triangles.
Proposer une méthode de découpage et d'énumération
des éléments à afficher.
Reprenez le squelette openGL des TP précédents
et modifiez-le afin d'afficher une surface sous forme de lignes ou de triangles.
Quels sont les avantages et inconvénients de ces
méthodes ?
note : afin de mieux percevoir la structure de votre surface,
affichez-la en fil de fer. Nous verrons comment faire mieux d'ici quelques
séances.
Partie 2 : Visualisation interactive
Proposez une manière interactive de visualiser
votre surface. Il est souvent nécessaire de choisir entre naviguer
dans l'espace (déplacer le point de vue) et orienter le modèle
(en utilisant une rotation par axe). Les évènements clavier
et souris gérés par glut permettent de simplifier ce type d'interaction.
note : vous aurez très certainement besoin de définir
une action pour les évènements clavier (glutKeyboardFunc
et glutSpecialFunc) ou pour les évènements souris
(glutMouseFunc).
Partie 3 : Réduction du nombre d'éléments affichés
Il est inutile d'afficher la totalité des éléments
issu du découpage de la surface. Proposez une méthode simple
capable de déterminer quels éléments seront visibles
a priori, et lesquels seront invisibles, a priori.
Modifier votre programme de manière à n'afficher
que les éléments à priori visibles. Eventuellement,
ajoutez une action à votre programme permettant de choisir l'ensemble
d'éléments à visualiser.
Il est existe une classe complète d'algorithmes
qui permettent de limiter le nombre d'éléments affichés,
elles déterminent, en fonction des paramètres de la visualisation,
quels éléments seront entièrement, ou du moins partiellement,
visibles. Quels sont les avantages et les défauts d'une méthode
de ce type ?
Questions subsidiaires :
Utilisez une paramétrisation z= F(x, y, t) de votre
surface. Comment visualiser ce type de surface ? Proposez une application
pratique.
note : vous aurez sans doute besoin de définir une action
pour la mesure du temps, glutIdleFunc devrait vous y aider.
Dans le cas d'une surface paramétrée, il
est relativement simple de la découper et de calculer efficacement
les normales afin de déterminer quels éléments seront
visibles. Lorsque le modèle est difficilement paramètrable
ou constitué d'un ensemble moins organisé de triangles, il
est nécessaire de recalculer les normales aux éléments.
Modifiez votre algorithme d'élimination des éléments
cachés de manière à pouvoir le ré-utiliser dans
le cas d'un ensemble de triangles quelconques (sans utiliser le fait qu'ils
décrivent une surface paramétrée).