Sujets et Corrections
de TD et TP

TD

TD 1: Création de scènes VRML

TD 2: Création de scènes OpenGL

TD 3: Les primitives
graphiques
en OpenGL

TD 4: Animations en OpenGL

TD 5: La réutilisation
des objets
en VRML

TD 6: Matériaux
et lumières
en OpenGL

TD 7: Le plaçage
de texture,
application au VRML
et à OpenGL

TD 8: Mathématiques
élémentaires

TP

TP 1-2: Prise
en mains des
environnements
de programmation
VRML et OpenGL

TP 3: Gestion
de la souris
et animation

TP 4: Gestion
du clavier
et animation

TP 5: Caméras
de visualisation
en VRML
et en OpenGL

TP 6: Lumières
et matériaux
en VRML

TP 7: Dessin et remplissage de cercles

TP 8: Le placage
de texture
en OpenGL

RETOUR

Dernière modification
16/11/09 07:03:34

Travaux dirigés

TD 1: Création de scènes VRML

Exercice n°1

Programmer en VRML les scènes suivantes sans utiliser le nœud Separator:

• Scène (1): Quatre cubes de coté de longueur 1.0 aux positions (2.0,0.0,2.0), (2.0,0.0,-2.0), (-2.0,0.0,2.0) et (-2.0,0.0,-2.0).

• Scène (2): Même scène que la scène (1), mais le cube en position (2.0,0.0,2.0) subit une rotation de 45° autour de l'axe y passant par son centre.

• Scène (3): Même scène que la scène (2), mais le cube en position (2.0,0.0,-2.0) subit un zoom de rapport (1.0,1.0,2.0) par rapport à son centre.

• Scène (4): Même scène que la scène (3), mais le cube en position (-2.0,0.0,-2.0) subit une rotation de 30° autour de l'axe y passant par son centre et un zoom de rapport (1.0,1.0,2.0) par rapport à son centre.

On s'autorise maintenant le nœud Separator

Programmer les scènes suivantes:

• Scène (5): Même scène que la scène (4), mais on utilise le Separator pour éviter des transformations géométriques ayant pour but d'en annuler une autre.

• Scène (6): Même scène que la scène (4), mais on utilise le Separator pour rendre les positions des objets indépendantes les une des autres.

Exercice n°2

Programmer la scène modélisant un bras robot composé d'un avant-bras, d'un bras, et d'une paire de pinces.
L'avant bras est articulé pour tourner autour de l'axe y d'un angle r1. Il s'agit d'un parallélépipède rectangle de dimension (3.0,1.0,1.0) (rouge). Le bras est articulé autour de l'axe y au bout de l'avant bras pour un angle r2. Il s'agit d'un parallélépipède rectangle de dimension (3.0,0.8,0.8) (vert). La pince est située au bout du bras. Elle peut tourner autour de l'axe du bras pour un angle r3. L'embase de la paire de pinces est un parallélépipède rectangle de dimension (0.6,1.2,1.8) (bleu). Chacune des mâchoires est un parallélépipède rectangle de dimension (1.0,1.2,0.4) (jaune) à même de se déplacer longitudinalement d'une valeur d pour réaliser une ouverture totale de 2xd.

TD 2: Implantation en OpenGL

Exercice 1

Réaliser l'implantation OpenGL des scènes de l'exercice 1 du TD 1.

Exercice 2

Réaliser l'implantation OpenGL de l'exercice 2 du TD 1.

Exercice 3

Soit la scène composée de six cubes de cotés 1 centrés sur les sommets d'un hexagone régulier de rayon 3 lui-même centré sur O et plongé dans le plan xOy. Les cubes doivent présenter une face directement orientée vers O.

Réaliser l'implantation OpenGL de cette scène.

Exercice 4

Soit la scène composée de huit cubes de cotés 1 centrés sur les sommets d'un cube de rayon 4 lui-même centré sur O, et de 12 pavés de dimension (0.5, 0.5, 4.0) joignant ces 8 sommets entre eux pour matérialiser les arêtes du cube de coté 4.
Implanter cette scène.

TD 3: Les primitives graphiques en OpenGL

Exercice 1

a) Ecrire une fonction de modélisation d'une boite cubique de dimension c centrée sur l'origine du repère. Cette fonction devra seulement assurer la création des facettes (cubes rouge et gris sur l'image proposée).

b) Modifier la fonction précédente pour y inclure la gestion des normales aux facettes (utilisées pour les calculs d'éclairages) (cubes bleu et vert sur l'image proposée).

Exercice 2

a) Ecrire une fonction de modélisation d'un cylindre de rayon r, de hauteur h, possédant n sections radiales, centré sur l'origine et d'axe y. Cette fonction devra seulement assurer la création des facettes (cylindres rouge et gris sur l'image proposée).

b) Modifier la fonction précédente pour y inclure la gestion des normales aux facettes (utilisées pour les calculs d'éclairages) (cylindres bleu et vert sur l'image proposée).

TD 4: Programmation d'animations

Exercice 1

a) Programmer l'animation d'une sphère de rayon 1 selon une trajectoire circulaire de rayon 3 centrée sur l'origine du repère et définie dans le plan xOy. Cette animation est réalisée à raison de 1° de rotation entre chaque image.

b) Modifier le programme précédent de telle manière que la sphère réalise un mouvement d'aller et de retour de telle manière que revenue à sa position de départ, elle reparte en marche arrière.

c) Modifier le programme précédent de telle manière que la touche Enter du clavier soit utilisable pour activer/désactiver l'animation. En cas de réactivation, l'animation repart là où elle avait été interrompue.

Exercice 2

Programmer un mouvement hélicoïdal. Les paramètres sont les suivants:

• L'objet en mouvement est une sphère de rayon 1.
• L'axe du mouvement hélicoïdal est l'axe -Oy.
• Le rayon du mouvement est 3.
• Le point de départ de la sphère est (0.0F,5.0F,-3.0F).
• La perte d'"altitude" (déplacement selon l'axe y) entre chaque tour est 2.
• Le nombre de tours est 5.
• La sphère effectue une rotation de 1° entre chaque image.
• Une fois arrivée à son point d'arrivée, la sphère regagne son point de départ selon une trajectoire linéaire uniforme effectuée en 1000 images.

Exercice 3

Programmer une animation où deux sphères de rayon 1, suspendues à deux cylindres de longueur 10 et de rayon 0.25 matérialisant des fils, s'entrechoquent l'une l'autre de manière cyclique.
Pour s'implifier la programmation, les mouvements de va et vient seront effectués à la vitesse radiale constante de 1° entre chaque image (pas de mouvement balistique). Les sphères remontent jusqu'à l'horizontale au bout de leurs cylindres respectifs.

TD 5: La réutilisation d'objets en VRML

Exercice 1

Programmer la scène suivante en utilisant le DEF et le USE de VRML. Les cylindres ont pour rayon 0.5 et pour longueur 3. Les cones ont pour rayon 1.0 et pour longueur 3.0. L'objet est centré sur l'origine et est dessiné dans le plan xOy.

Exercice 2

Reprendre l'exercice précédent pour l'implanter sous forme de 2 fichiers VRML avec utilisation du WWWInline.

Exerecice 3

Reprendre l'exercice précédent pour créer un lien vers le site http://www.univ-fcomte.fr sur chacun des cones.

TD 6: Les matériaux et lumières en OpenGL

Exercice 1

Soit une scène composée d'une scène unique quelconque modélisé au sein d'une fonction void scene(void);.

a) Ecrire la fonction display dessinant cette scène en l'affectant d'un matériau diffusant dans le gris moyen et réfléchissant spéculairement dans le gris moyen.

b) Cette scène est éclairée au moyen d'une lumière ponctuelle blanche située en position (0.0F,0.0F,10.0F).
Modifier la fonction display pour l'intégrer.

c) Modifier une nouvelle fois la fonction display pour que la lumière devienne verte en spéculaire et que la scène intégre une seconde lumière directionnelle bleue en spéculaire et blanche en diffusion éclairant selon la direction (-1.0, -1.0, -1.0).

d) La scène n'est pas animée, mais la lumière ponctuelle l'est. Elle réalise un mouvement de rotation autour de l'axe Ox.
Programmer cette animation.

Solution

TD 7: Le placage de texture en VRML et en OpenGL

Le placage de texture
Application en VRML
Application en OpenGL

Exercice 1 : VRML

Définir le champ image d'un noeud Texture2 permettant la création d'une texture de 2x2 pixels jaune, rouge pour la ligne du haut et bleu et vert pour la ligne du bas.

Exercice 2 : OpenGL

Définir une fonction créant un tableau à même d'être utilisé dans un appel à glTexImage2D pour spécifier une texture identique à celle de l'exercice 1.

Solution

TD 8: Mathématiques élémentaires pour l'infographie

1) Définir une structure de données permettant de stocker une position dans un espace à 3 dimensions.

2) Définir une structure de données permettant de stocker un vecteur (direction) dans un espace à 3 dimensions.

3) Ecrire une fonction de calcul du vecteur défini entre deux positions.

4) Ecrire une fonction calculant la norme d'un vecteur.

5) Ecrire une fonction de normalisation d'un vecteur.

6) Ecrire une fonction calculant le produit scalaire de deux vecteurs.

7) Ecrire une fonction calculant le produit vectoriel de deux vecteurs.

8) Définir une structure de données permettant de stocker une facette triangulaire d'un espace à 3 dimensions.

9) Ecrire une fonction calculant l'une des deux normales à une facette triangulaire.

10) Ecrire une fonction testant le parallélisme entre deux facettes triangulaires.

11) Définir une structure de données permettant de stocker une facette d'arité quelconque d'un espace à 3 dimensions.

12) Ecrire une fonction testant la planarité d'une facette d'arité quelconque.

13) Ecrire une fonction testant la convexité d'une facette plane d'arité quelconque.

Solution

TD 9: Remplissage de facettes triangulaires 2D et 3D

Exercice 1

On cherche à déterminer les pixels des bords d'une facette triangulaire définie dans un espace 2D. Ecrire une fonction permettant de remplir un tableau indicé sur y, pour tous les y où un segment 2D rectiligne est présent, avec l'abscice d'un des pixels présent en cet y.

Exercice 2

En utilisant la fonction précédente, écrire une fonction de remplissage d'une facette triangulaire définie dans un espace 2D.

Exercice 3

Dans l'optique de l'écriture d'une fonction de remplissage d'une facette triangulaire 3D, reprendre la question de l'exercice 1 pour calculer un tableau de profondeurs z en plus du tableau d'absices x pour chacun des pixels d'une trame y d'un segment 3D.

Exercice 4

Généraliser la fonction de l'exercice 2 au facettes triangulaires 3D.

Travaux pratiques

TP 1-2: Prise en mains des environnements de programmation VRML et OpenGL

Sous VRML:

• Un plugin Internet Explorer/Netscape Navigator (soit Cortona Player, soit Cosmo Player suivant les machines)
• Une application de visualisation (Scene Viewer)

Sous OpenGL:

• Visual C++ 6.0 sous Windows
• Cygwin g++ sous Windows
• g++ avec la librairie Mesa3D sous Linux

Travail demandé:

• Sous VRML: Implantation des fichiers VRML du TD n°1.

• Sous VRML: Implantation d'une scène avec un cube, une sphère, un cylindre et un cone pour vérifier l'axe de dessin de ces objets.

• Sous OpenGL:

  • Création d'un projet Visual C++ permettant la compilation OpenGL (bien spécifier les librairies OpenGL: OpenGL32.lib, glu32.lib et glut32.lib).

  • Téléchargement du source exemple destiné à être testé: TP-Roll.cpp.

  • Téléchargement du source exemple destiné à être testé: StarWarsIntro.cpp.

  • Dessin des objets de base GLUt pour repérer leurs caractéristiques de taille, d'orientation et de facettisation.

  • Implantation des exemples des TD n°2 et n°3 (en repartant des exemples précédents).

  • Exercice supplémentaire:

    Soit la scène composée de huit cubes de cotés 1 centrés sur les sommets d'un cube de rayon 4 lui-même centré sur O, et de 12 cylindres de rayon 0.2 et de hauteur 4 joignant ces 8 sommets entre eux pour matérialiser les arêtes du cube de coté 4. Implanter cette scène.

TP 3: Gestion de la souris et animation, premières notions sur les caméras

Exercice 1

Programmez une application OpenGL affichant une petite sphère dans une fenêtre et permettant à l'utilisateur de cliquer au moyen de la souris pour déplacer cette sphère à l'endroit où le clic a eu lieu.

Exercice 2

Programmez une application OpenGL affichant une petite sphère dans une fenêtre et permettant à l'utilisateur de glisser déplacer (drag and drop) cette sphère au moyen de la souris.

Exercice 3

Programmez une application OpenGL affichant une petite sphère dans une fenêtre et permettant à l'utilisateur de cliquer au moyen de la souris pour déclencher une animation amenant la sphère de sa position originelle à la position cliquée. Le déplacement est rectiligne à raison de deux pixels entre images successives. Quand la position destination est atteinte, l'animation s'arrête.

TP 4: Gestion du clavier et animation

Exercice 1

Reprendre l'exercice du bras robot et le programmer avec des contrôles clavier permettant de modifier les trois angles et l'ouverture.

Exercice 2

Programmez une animation où un nombre arbitraire de sphères parcourent une trajectoire en huit. Elles sont régulièrement réparties sur la trajectoire.

On pourra:

• augmenter/diminuer le nombre de sphères,
• augmenter/diminuer la vitesse de rotation,
• activer/désactiver l'animation.

Exercice 3

Programmez une animation où un nombre arbitraire de sphères parcourent une trajectoire en hippodrome. Elles sont régulièrement réparties sur la trajectoire.

On pourra:

• augmenter/diminuer le nombre de sphères,
• augmenter/diminuer la vitesse de rotation,
• activer/désactiver l'animation.

TP 5: Caméras en VRML et en OpenGL

Exercice 1 (VRML)

On considère le fichier VRML suivant: xxx.wrl.

a) Utiliser ce fichier dans un autre fichier VRML (WWWInline) pour le visualiser depuis le point de vue de coordonnées (0.0, 100.0, 100.0) au moyen d'une caméra de visualisation en perspective. Celle-ci regarde l'origine du repère. Il faut trouver l'angle d'ouverture permettant de voir le fichier en "gros plan".

b) (Question supplémentaire optionnelle) Changer la position du point de vue pour le placer en position (100.0, 100.0, 100.0) tout en continuant à viser l'origine.

Exercice 2 (OpenGL)

On considère le fichier source C suivant: Croix.cpp auquel est associé le fichier d'entête Croix.h. Il contient le code source d'une fonction C + OpenGL dessinant la croix du TD n°5.

Intégrer ce code source au sein d'un programme et définir dans ce programme une caméra de visualisation en projection en perspective visualisant cette scène en gros plan depuis le point de vue (100.0, 100.0, 100.0). La scène est centrée sur l'origine.

TP 6: Les lumières et matériaux en VRML

Exercice 1

a) Ecrire une scène composée d'une sphère de rayon 5 centrée sur l'origine du repère et affectée d'un matériel avec uniquement de la diffusion dans le rouge.
Tester avec et sans headlight.

b) Modifier la scène précédente pour que le matériel intègre une réflexion spéculaire dans le vert.

c) Modifier la scène précédente pour y intégrer un éclairage sous la forme d'une source lumineuse directionnelle blanche éclairant depuis la droite.

d) Modifier la scène précédente pour y inclure une seconde sphère de rayon 2 placée en position (10, 0, 0) possédant le même matériel que la première ainsi qu'une seconde source lumineuse ponctuelle blanche placée à l'origine.

e) Modifier la scène précédente pour y inclure une source lumineuse spot placée en position (0, 0, 10) orientée vers l'origine et éclairant partiellement la grosse sphère (éclipse à l'envers).

Solutions

Exercice 2

Soient deux sphères de rayon 1, placées en position (5, 0, 0) et (-5, 0, 0) et blanches en diffusion. Soient deux sources lumineuses ponctuelles placées à l'origine du repère émettant dans le vert et dans le bleu. Construire la scène de telle manière que la sphère de droite soit éclairée uniquement par la lumière verte, et la sphère de gauche uniquement par la lumière bleue.

Modifier le matériau des deux sphères pour les rendre transparentes.

Solution

TP 7: Dessin et remplissage de cercles

Exercice 1

Implanter l'algorithme du midpoint (Bresenham) pour le dessin de cercles.

Exercice 2

A partir de l'algorithme précédent, implanter un algorithme de remplissage de cercles.

Solution

TP 8: Le placage de texture en OpenGL

Le TP est réalisé sous Linux en utilisant Mesa OpenGL.

Exercice 1

Dessiner un dé à jouer modélisé par un cube dont les facettes sont texturées.

Exercice 2

Dessiner un dé à jouer sans utiliser le texturage.

Exercice 3

Tester l'utilisation du canal alpha pour gérer des textures transparentes.
Sur le dé de l'exercice 1, les points seront opaques tandis que le reste de la facette sera transparent.