Rapport Infographie

publicité
Institut Galilée
INFO 1 :
Yohan ROUSSET
Stéphane FOURNIER
INFOGRAPHIE
Rapport du Projet
de dessin
2D et 3D
Superviseur : R. MALGOUYRES
Année 2008-2009
2
Table des matières
I.
Introduction..................................................................................................................................... 4
II.
Dessin en deux dimensions ............................................................................................................. 5
A.
Description générale ................................................................................................................... 5
B.
Fonctionnalités ............................................................................................................................ 5
III. Dessin en trois dimensions .............................................................................................................. 7
A.
Description générale ................................................................................................................... 7
B.
Fonctionnalités ............................................................................................................................ 8
3
I.
Introduction
Dans le cadre de notre formation d’ingénieur première année, nous avons suivi un cours
d’infographie. Ce cours permet, par le biais de diverses implémentations que nous verrons plus tard
dans ce rapport, de construire des figures géométriques et de les afficher sur l’écran d’un pc. Ainsi,
nous allons dans un premier temps aborder le dessin en deux dimensions. Dans un second temps,
nous mettrons la lumière sur le dessin en trois dimensions.
4
II.
Dessin en deux dimensions
A.
Description générale
Le fichier dessin2D.java (joint dans l’archive du rapport), une fois compilé,
permet d’afficher à l’écran des formes géométriques à deux dimensions, telles que
des droites, des cercles, des polygones quelconques, etc. En outre, notre programme
permet de changer la couleur de ces formes (bleu, vert, rouge et noir) par simple
sélection dans un menu déroulant. Le choix des formes géométriques à créer se fait
également par un menu déroulant.
B.
Fonctionnalités
Figure 1
Sur la figure1, on peut observer, en haut à gauche, des droites dessinées via
l’algorithme naïf. En haut à droite, des droites dessinées avec l’algorithme de Foley.
Pour chacune d’elle, le fonctionnement est le suivant : on clique sur la fenêtre, cela
définit le point de départ de la droite. Puis, on clique sur la fenêtre pour définir un
deuxième point, ceci définit le point d’arrivée de la droite. L’algorithme trace alors
une droite reliant ces deux points.
5
Ensuite, on observe deux cercles. Ces deux cercles sont tracés avec un
algorithme reprenant le principe de Foley. Le cercle de gauche a été rempli, l’inverse
du cercle de droite qui reste vide. Pour remplir un cercle, un bouton est prévu à cet
effet, il remplit tous les cercles dessinés à l’écran au moment où on clique sur le
bouton.
Enfin, on trouve en dessous un polygone rempli. Pour se faire, il a fallut tout
d’abord sélectionner dans le menu déroulant « Polygone », puis on clique sur la
fenêtre pour créer des droites. Lorsque le polygone est terminé, on clique sur le
bouton « Fin du Polygone » pour terminer le polygone (la droite reliant le dernier
point au premier point est tracée). Puis, on clique sur « Remplissage du Polygone »
pour remplir ce dernier.
Figure 2
Figure 3
En figure deux et trois, on montre que la fonctionnalité de suppression d’un
point fonctionne. En effet, on note qu’entre les figures 2 et 3, les points d’en bas à
droite de la figure on été retiré. En outre, la fonctionnalité de translation d’un
polygone fonctionne puisque le polygone a été déplacé sur la gauche. Enfin, la
hachure d’un polygone fonctionne.
De la même manière qu’on ajoute un point ou supprime un point, on peut
déplacer un point déjà présent sur la figure, ainsi, on clique prés d’un point déjà
présent, et on le déplace à sa nouvelle position. L’utilisation de mouseDragged en
JAVA permet de voir les modifications en temps réel.
Enfin, les fonctionnalités de fenêtrage d’un polygone et d’un cercle
fonctionnent. Ainsi, on peut fenêtrer un polygone et un cercle en choisissant l’option
6
adéquat dans le menu déroulant. On clique alors deux fois sur la fenêtre pour définir
une zone (un rectangle) où sera conservée la forme géométrique. En dehors de cette
zone, la figure n’est pas affichée.
III.
Dessin en trois dimensions
A.
Description générale
Le fichier dessin3D.java (joint dans l’archive du rapport), une fois compilé,
permet d’afficher à l’écran des formes géométriques en trois dimensions. Il est
accompagné de plusieurs autres fichiers .Java représentant des classes d’objets. On a
alors Cone.java, Cube.java, Sphere.java et Cylindre.java. Ces classes, définissant les
formes géométriques dont elles ont le nom, héritent de Maillage.java. Dans cette
dernières sont définies les méthodes qui manipulent un maillage. On rappelle qu’un
maillage est un ensemble de mailles. Une maille est un polygone (une maille est
définie par une liste de sommets). Un algorithme, implémenté dans le fichier
dessin3D.java, permet de calculer, pour chaque maillage, quel sont ses mailles
visibles : le zbuffer. Ce dernier nécessite certains pré-requis. Ainsi, il faut savoir
déterminer l’intersection d’une droite avec un plan, et savoir calculer un plan à partir
d’une maille. Le zbuffer parcourra chaque maille. Pour chaque point de la maille
courante, il calculera le point d’intersection entre la droite (Observateur, Point sur le
plan de projection) vers le plan de la maille courante. Le plan de la maille est calculé
par une fonction située dans Maillage.java.
Ainsi, notre programme de dessin en trois dimensions permet de construire
un cône, un cylindre, une sphère ou un cube. En outre, on peut appliquer sur
chacune de ces formes une lumière réaliste. Composée de 3 lumières différentes
(ambiante, ponctuelle et ponctuelle a réflexion spéculaire), elle permet de mieux voir
certaines perspectives, et d’avoir un bon rendu de la forme géométrique que l’on
souhaite afficher. La lumière s’applique en appuyant simplement sur un bouton
prévu à cet effet sur l’interface. Pour chaque point visible sur le plan de projection,
on calcule les différentes lumières. Pour les lumières ponctuelles, on utilise
l’algorithme de l’interpolation des normales disponibles dans le fichier Maillage.java.
Il permet, à partir de trois normales (une par sommets), de déterminer une normale
pour un point quelconque de la maille courante.
Enfin, de la même manière que pour la lumière, il existe un bouton qui
permet d’afficher une texture ou non. Cette fonctionnalité permet alors d’afficher
une forme géométrique texturée. Une image texturée peut aussi être éclairée. De la
même manière que pour l’interpolation des normales, il y a un algorithme
d’interpolation des points de textures dans la classe Maillage.java. Cet algorithme
permet, à partir de trois points d’un maillage, et de leur équivalent sur une texture,
de trouver le pixel correspondant à un point quelconque de la maille.
Néanmoins, nous avons un problème lorsque nous souhaitons texturés un
cône. Nous n’avons pas trouvé de coordonnées de texture approprié.
7
Par défaut, la lumière et le plaquage de textures sont sur « OFF ».
B.
Fonctionnalités
Figure 4 : Cube sans texture, sans
lumière
Figure 5 : Cube sans texture, avec
lumière
En figure 4, un cube a été dessiné. Les
champs x0, y0 et z0 sont les coordonnées
du point P0 du cube. On donne ensuite
trois valeurs qui donnent les longueurs des
cotés du cube. Le cube a ensuite été
translaté avec la fonction de translation
vers le bas droit de la fenêtre. Pour
translater, on clique à un endroit de la
fenêtre, et on fait glisser la souris dans la
direction où l’on veut amener notre figure
géométrique, sans relâcher le clic.
Figure 6 : Cube avec texture et avec lumière
En figure 5, c’est le même cube que
précédemment, avec cette fois la lumière
d’appliquée. Enfin, en figure 6, c’est
toujours le même cube, mais avec cette
fois la texture en plus (la lumière est
conservée).
Plus généralement, on peut dessiner toutes sortes de parallélépipède
rectangle. En effet, cela peut se faire de façon simple en mettant des valeurs
différentes pour taille en x, taille en y et taille en z. Mais on a alors un problème pour
texturer des parallélépipèdes rectangles pour certaines valeurs de taille en x, taille en
y et taille en z ((300,50,150) ne fonctionne pas, mais (300,200,200) fonctionne).
Un autre problème que nous avons rencontré avec le cube, c’est la rotation
du cube maillés à trois sommets. En effet, comme il y a plus de points (un point est
répété trois fois dans la liste des sommets), la translation d’un cube le translate de 3
8
fois la distance qu’il aurait du être translater. Ainsi, le problème a été corrigé en
écrasant la méthode de translation de Maillage.java. Ainsi, une méthode de
translation propre au cube est présente dans Cube.java.
Figure 7 : Cylindre sans lumière ni texture
Figure 8 : Cylindre avec deux lumières sans
Figure 9 : Cylindre avec texture et lumière
Le cylindre est créé en donnant la position en x y et z de son centre, il faut lui
donner une hauteur, un rayon et une précision pour le maillage. Sur les figures 7,8 et
9, le cylindre est le même, seul les paramètres de texture et lumière différent. Le
cylindre a été créé, puis un a subit une rotation qui a permit de le mettre dans sa
position actuelle.
Nous avons rencontré quelques problèmes dans la création du cylindre. En
effet, au début, il était constitué de mailles à 4 sommets. Mais lorsque nous sommes
passés aux mailles à trois sommets, il y avait des problèmes dans le maillage. Une
relecture du code a démontré que cela provenait d’une simple erreur d’étourderie
lors de la création des sommets (indices d’insertion des sommets dans la liste des
sommets).
Figure 10 : Sphère avec deux lumières, sans
texture
9
Figure 11 : Sphère avec texture sans lumière
Figure 12 : Sphère avec texture et avec une
lumière
En figure 10,11 et 12, une sphère a été créée en utilisant un centre (x,y,z), un
rayon et une précision du maillage. Sur chacune des figures
f
ci-dessus,
dessus, c’est
c’
la même
sphère qui est affichée. Seuls les paramètres d’affichage de la texture et de lumière
changent.
En figure 10, on remarque la présence de deux taches lumineuses. En fait, on
a créé deux lumières, une au nord et une au sud du plan de projection. Le résultat
cohérent est donc cohérent.
En figure 11, c’est la même sphère,, sans lumière cette fois, mais avec le
plaquage d’une texture (disponible dans l’archive sous le nom de terre.jpg). On
observe que le plaquage est cohérent. Cela ressemble vraiment à un globe terrestre.
En figure 12, toujours la même sphère, avec une lumière cette fois au nord.
On a alors le rendu de la planète Terre avec son Soleil.
Figure 13 : Cône sans lumière ni texture
Figure 14 : Cône avec lumière sans
s
texture
Sur les figures 13 et 14, un cône a été dessiné. Sur les deux figures, c’est le
même, seul la lumière a été ajoutée au second. Un cône est créé à partir d’un centre,
un rayon, une hauteur et une précision.
pré
Jusqu’ici, toutes les formes géométriques ont des mailles à trois sommets. En
effet, on ne peut pas utiliser l’interpolation linéaire des normales et points pour la
texture sur des mailles à 4 sommets.
Néanmoins, pour le cône, le maillage actuel donne
onne des résultats étranges
lorsqu’on applique la lumière dessus. L’interpolation des normales ne se fait
10
probablement pas de la bonne manière (car il faut des mailles à trois sommets, ce qui
n’est pas le cas de la base du cône actuel). En outre, les textures ne sont pas faites, et
donc leur plaquage est impossible.
Cependant, lorsqu’on applique les lumières qui n’utilisent pas l’interpolation
des normales, le rendu de la lumière est parfaitement cohérent. Mais la nonutilisation de l’interpolation des normales affiche des ruptures lorsque l’on passe
d’une maille à l’autre.
11
Téléchargement