Sujets et Corrections |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
TD n°1 TD n°2 TP n°1 TD n°3 TD n°4 TP n°3 TD n°5 TP n°4 TD n°6 TP n°6 TD n°8 TP n°7 TD n°9 TP n°8 TD n°10 TP n°9
Dernière modification |
TD n°1 : Création de scènes en VRML 1.0 (1) Programmer en VRML la scène suivante sans utiliser le nud
Separator ailleurs que pour le Separator d'encadrement global du fichier:
(2) Reprogrammer en VRML la scène de la question (1) de telle manière que les cubes aient une de leurs faces orientée vers l'origine du repère.
(3) Reprogrammer en VRML la scène de la question (2) en utilisant le nud Separator pour rendre les objets indépendants les uns des autres et simplifier l'écriture du fichier scène. (4) Programmer une scène en VRML en plaçant 3 cubes de coté 2.0 aux 3 sommets d'un
triangle équilatéral défini avec les caractéristiques suivantes:
(5) Programmer la scène VRML modélisant un bras robot simplifié composé d'un
avant-bras et d'un bras. (6) Modifier le fichier VRML de l'exercice n°5 en remplaçant les parallélépipèdes par des cylindres de tailles équivalentes. TD n°2: Premières scènes OpenGL Exercice 1 Implanter en OpenGL les questions n°3 et n°4 du TD n°1. Question n°3 Question n°4 Exercice 2 Implanter en OpenGL les questions n°5 et n°6 du TD n°1. Question n°5 Question n°6 Exercice 3 Implanter en OpenGL une fonction de dessin d'une molécule de Benzène (C6H6).
Les atomes de carbone (atome centraux) ont un rayon égal à 0.5. Solutions TP n°1 : Premières implantations en VRML et en OpenGL Exercice n°1 (VRML) Les viewers VRML disponibles sont:
(a) Implanter les questions n°3 et n°4 du TD n°1. (b) Implanter les questions n°5 et n°6 du TD n°1. Exercice n°2 (OpenGL) Création d'un projet Visual C++ permettant la compilation OpenGL:
Seul GLUT n'est pas installé lors de l'installation de Visual C++. Il est
nécessaire de se procurer les fichiers .h, .lib et .dll lui
correspondant puis de les installer. Suivant la manière avec laquelle Visual C++ à été installé, il pourra être nécessaire (ou non) de spécifier les fichiers .lib d'OpenGL dans les options d'édition de lien. Si gcc sous Linux est utilisé, Mesa3D devrait avoir été installé au
cours de l'installation des outils de développement (gcc). S'il ne l'est pas, ou si l'on
constate l'absence de GLUT, ou si l'on souhaite utiliser une version plus récente que
celle disponible (en septembre 2009, la version la plus récente disponible de Mesa3D est
la version 7.5.1 qui est compatible OpenGL 2.1), il sera nécessaire de télécharger et d'installer (compilation puis
installation, une archive pour OpenGL, une archive pour GLUT et une archive pour des
exemples) la version souhaitée. (a) Télécharger le programme source exemple suivant : GetConfig.cpp. Ce programme a pour but
d'initialiser OpenGL pour en extraire et afficher les informations de version. Exécutable compilé avec Visual C++ et Exécutable compilé avec Visual C++ et Exécutable compilé avec Visual C++ et b) Recommencer la procédure de test avec le fichier source suivant: Animation2009-2010.cpp.
TP n°2 : Programmation OpenGL Spécifications de GLUt version 3 Exercice n°1 a) En adaptant le programme Animation2009-2010.cpp du TP n°1, implanter l'exercice du TD n°2 pour la modélisation et le dessin d'une molécule de benzène. La fonction suivante pourra être utilisée pour modéliser un cylindre de hauteur h, de rayon r, de facteurs de facettisation n et m, centré sur l'origine et orienté selon l'axe y. void cylindre(double h,double r,int n,int m) { glPushMatrix(); glRotatef(90.0F,1.0F,0.0F,0.0F); glTranslatef(0.0F,0.0F,-h/2); GLUquadricObj *qobj = gluNewQuadric(); gluQuadricDrawStyle(qobj,GLU_FILL); gluCylinder(qobj,r,r,h,n,m); gluDeleteQuadric(qobj); glPopMatrix(); } b) Modifier la modélisation de la molécule de benzène de la question précédente
pour que les liaisons carbone-carbone soient alternativement des liaisons simples et des
liaisons doubles (voir figure ci-dessous).
c) Définir et tester différentes alternatives (3 possibilités) permettant d'afficher la molécule en gros plan de manière à la visualiser avec précision. Exercice n°2 a) Programmer la modélisation et l'affichage d'un tétraèdre modélisé par cylindres et sphères comme représenté sur la figure ci-dessous.
Les caractéristiques du tétraèdre sont les suivantes: Solutions
TD n°3 : Modélisation par facettes en OpenGL Exercice n°1 a) Modéliser par facettes un cube de coté 1.0 centré sur l'origine du repère de modélisation. b) Modifier la modélisation de la question précédente pour ajouter la gestion des normales. Solution
Exercice n°1 : Modélisation par facettes en OpenGL Soit l'équation paramétrique de la bille de rayon r centrée sur le point de
coordonnées (cx,cy,cz):
Développer une fonction de modélisation d'une sphère de rayon r, centrée sur
l'origine du repère de modélisation. Solutions
TP n°3 : Caméras OpenGL Le fichier SceneOpenGL.cpp contient une fonction de dessin de scène. Celle-ci est prototypée dans le fichier SceneOpenGL.h. La scène modélisée occupe un volume approximativement sphèrique de rayon 12.0. Les objets jaune et rouge sont orientés en x. Les objets bleu et magenta sont orientés verticalement (en y). Les objets vert et cyan sont orientés en z. Le but de l'exercice est de visualiser cette scène en gros plan dans une fenêtre d'affichage OpenGL. Question n°1 Télécharger le fichier CameraOpenGL.cpp. Ce fichier utilise les deux fichiers précédents pour créer une application OpenGL + GLUt. La scène est "affichée", mais la fonction reshape étant incomplète, l'affichage est tout à fait incorrecte. Complèter la fonction reshape pour obtenir un affichage en gros plan en projection orthographique selon l'axe -z. La scène est dessinée centrée sur l'origine.
Question n°2 Changer la caméra de la question n°1 pour lui substituer une caméra de visualisation
en perspective placée en position (1000.0, 1000.0,1000.0) tout en conservant la scène en
gros plan. Question n°3 Dans les questions suivantes, tester les conséquences d'un mauvais choix de cmin et
cmax dans le paramètrage de la fonction gluPerspective. a) Déplacer la caméra de la question n°2 pour l'amener en position (100.0,
100.0,100.0).
Question n°4 Reprendre la question n°3b en ne s'autorisant plus l'utilisation de la fonction gluLookAt. Solutions TD n°5 : Caméra, lumières et matériaux en VRML Question n°1 a) Définir une caméra de visualisation en perspective placée en position (0.0,0.0,10.0) orientée vers l'origine du repère. b) Déplacer cette caméra vers la position (10.0,0.0,10.0) tout en la conservant orientée vers le point de coodonnées (0.0,0.0,0.0). c) Déplacer une dernière fois cette caméra vers la position (10.0,10.0,10.0) tout en conservant son orientation vers l'origine. Question n°2 La caméra de l'exercice n°1 visualise la scène composée de quatre objets définis
selon les caractéristiques suivantes: Question n°3 Tester successivement la scène de la question n°2 sous les éclairages suivants: a) Une lumière ponctuelle blanche est placée en position (0.0,0.0,0.0). b) Une lumière directionnelle cyan éclaire la scène depuis la droite. c) Un spot jaune est placé en position (-12.0,0.0,10.0) et est orienté vers le point de coordonnées (-2.0,0.0,0.0) avec une ouverture de 0.15 radians. d) Les trois lumières des questions a), b) et c) sont définies.
Solutions TP n°4 : Lumières et matériaux en OpenGL Réaliser l'implantation en OpenGL + GLUt des questions du TD n°5.
Contributions individuelles des trois lumières Solution TD n°6 : Calculs mathématiques pour l'illumination des objets Le TD est réalisé en langage Java. Question n°1 L'exercice consiste à évaluer la quantité d'énergie diffusée par une surface "colorée" éclairée par une lumière directionnelle colorée. a) Développer les classes Material.java, Normale.java et LumiereDirectionnelle.java minimales nécessaires (variables membres et constructeurs), ainsi que les classes utilitaires qu'elles requièrent, permettant d'instancier les objets à gérer pour résoudre la question n°1. b) Developper une méthode de calcul de l'énergie diffusée par une surface sous l'éclairage d'une lumière directionnelle. On utilisera la formule de Lambert. Question n°2 L'exercice consiste à évaluer la quantité d'énergie diffusée par une surface "colorée" éclairée par une lumière ponctuelle colorée. a) Développer les classes Position.java et LumierePonctuelle.java minimales nécessaires (variables membres et constructeurs), ainsi que les classes utilitaires qu'elles requièrent, permettant d'instancier les objets à gérer pour résoudre la question n°2. b) Developper une méthode de calcul de l'énergie diffusée par une surface sous l'éclairage d'une lumière ponctuelle. On utilisera la formule de Lambert. Solutions Pour gérer les animations demandées, on pourra utiliser glutIdleFunc (programmation d'une tâche de fond) ou glutTimerFunc (programmation d'une fonction timer). a) Le fichier ScenePourAnimation.cpp (décrit par le fichier d'entête ScenePourAnimation.h) contient une fonction void scene(int l) de modélisation d'une scène composée d'une surface plane carrée de diagonale (-10.0, 0.0, -10.0) - (10.0, 0.0, 10.0) sur laquelle sont posés aléatoirement 100 "poteaux" parallélipipédiques. L'éclairage de cette scène est activé/désactivé par le paramètre booléen l. Implanter le dessin de cette scène par une caméra de visualisation en perspective placée en position (0.0, 0.5, 0.0) orientée selon la direction (0.0, 0.0, 1.0). L'ouverture verticale de la caméra est de 60°. Les plans cmin est cmax sont aux distances 0.01 et 100.0. La taille de la fenêtre d'affichage est 450 sur 200 pixels. b) Modifier le programme précédent pour autoriser le déplacement de la caméra au moyen des touches up et down de manière à avancer et reculer dans la scène dans l'axe de la caméra. c) Modifier le programme précédent pour autoriser l'utilisation des touches right et left de manière à faire tourner la caméra vers la droite et vers la gauche tout en continuant à pourvoir utiliser les touches up et down pour l'avancer et la reculer. d) Modifier une nouvelle fois le programme précédent pour que l'utilisateur puisse utiliser la touche "Enter" pour activer la réalisation automatique d'un tour sur elle-même pour la caméra. Pendant le tour, celle-ci ne peut plus se déplacer. Après le tour elle s'immobilise avec la posture qu'elle avait avant de le débuter et peut de nouveau se déplacer. e) Revenir à la version c) et modifier la scène pour transformer les poteaux en cylindres de rayon 0.05 et de hauteur 2.0 et gérer les déplacements de la caméra de manière qu'il lui soit impossible de traverser les poteaux ainsi modifiés (impossible de se rapprocher à une distance inférieure à 0.01 d'un poteau). f) Modifier la scène pour que la lumière ponctuelle qui l'éclaire se déplace automatiquement pour décrire une trajectoire circulaire d'altitude (y) constante 1.0 centrée sur le point de coordonnées (0.0,1.0,0.0) et de rayon 5.0. g) Modifier la scène pour y inclure un objet supplémentaire en déplacement. Cet objet est une sphère blanche de rayon 0.1 qui se déplace pour matérialiser la lumière ponctuelle en mouvement. Gérer l'affichage de cette sphère de manière qu'elle apparaisse illuminée par une lumière lui étant extérieure. Solutions
TD n°7 : Coordonnées homogènes Le TD est réalisé en langage Java. Exercice n°1 a) Développer une classe CoordonneesHomogenes3D permettant de stocker des coordonnées homogènes dans un espace à 3 dimensions. b) Dériver la classe du (a) en une classe Position3D permettant de stocker des positions dans un espace 3D. c) Dériver la classe du (a) en une classe Direction3D permettant de stocker des directions dans un espace 3D. Exercice n°2 a) Développer une classe TransformationGeometrique3D permettant de stocker des transformations géométriques génériques en coordonnées homogènes dans un espace à 3 dimensions. b) Dériver la classe du (a) en une classe Translation permettant de stocker des translations dans un espace à 3 dimensions. c) Dériver la classe du (a) en une classe Rotation permettant de stocker des rotations (rotation d'angle arbitraire autour d'un axe arbitraire non nul passant par l'origine) dans un espace à 3 dimensions. d) Dériver la classe du (a) en une classe Scale permettant de stocker des zooms dans un espace à 3 dimensions. Exercice n°3 Modifier les classes précédentes pour y inclure les méthodes permettant de réaliser la transformation d'une position par une transformation géométrique, la transformation d'une direction par une transformation géométrique, la composition de transformations géométriques. Solutions TP n°6 : Transformations géométriques pour la visualisation Le fichier AffichageEcranOrthographique.cpp donne un exemple de programme OpenGL où la caméra virtuelle de visualisation est définie selon les caractéristiques suivantes:
La scène affichée est constituée de lignes horizontales ou verticales (Enter pour switcher) de 1 pixel d'épaisseur séparées de 2.0 en coordonnées de modélisation et donc de 2 pixels en coordonnées écran ce qui conduit à une alternance de lignes de pixels rouges et de lignes de pixels noirs.
On pourra s'inspirer de cet exemple pour la suite du TP. Exercice n°1 Les lignes de code suivantes définissent un objet en "fil de fer" par la donnée de la position (en coordonnées homogènes) de ses npos sommets et la donnée des nind couples d'indices, dans le tableau des sommets, définissant les arêtes. typedef float coordonneesHomogenes3D[4]; typedef float transformationGeometrique3D[4][4]; static int npos = 10; static int nind = 15; static coordonneesHomogenes3D pos[] = { { 2.0, 0.0, 3.0, 1.0 }, { 2.0, 3.0, 3.0, 1.0 }, { 0.0, 5.0, 3.0, 1.0 }, { -2.0, 3.0, 3.0, 1.0 }, { -2.0, 0.0, 3.0, 1.0 }, { 2.0, 0.0,-3.0, 1.0 }, { 2.0, 3.0,-3.0, 1.0 }, { 0.0, 5.0,-3.0, 1.0 }, { -2.0, 3.0,-3.0, 1.0 }, { -2.0, 0.0,-3.0, 1.0 } }; static int ind[][2] = { { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 }, { 4, 0 }, { 5, 6 }, { 6, 7 }, { 7, 8 }, { 8, 9 }, { 9, 5 }, { 0, 5 }, { 1, 6 }, { 2, 7 }, { 3, 8 }, { 4, 9 } }; Le but de l'exercice est d'afficher cet objet en projection parallèle orthographique en programmant soit-même la transformation géométrique de visualisation qui permet de définir la position Pc de la caméra de visualisation (par exemple (10.0, 6.0, 10.0)) et la position Pv d'un point visé (par exemple (0.0, 2.5, 0.0)) en conservant vertical à l'écran l'axe y (voir chapitre de cours). La matrice de transformation correspondante est la suivante: où est le vecteur normé défini par la direction Pc vers Pv et a =
Exercice n°2 Cet exercice reprend l'exercice n°1 pour transformer l'affichage en projection parallèle orthographique en un affichage en perspective. La matrice de transformation à utiliser est la suivante (voir chapitre de cours): où d est la position en -z (donc d est de valeur négative) de l'écran virtuel de projection (par exemple d = -15.0). Les coordonnées en x et en y obtenues après transformation par cette matrice devront être divisées par w pour achever la mise en perspective de manière à obtenir les coordonnées x et y écran définitives. TD n°8: Clipping par l'algorithme de Cohen-Sutherland L'implantation est réalisée en langage java. a) Définir trois classes de stockage pour: b) Implanter une méthode permettant de calculer le code de Cohen-Sutherland associé à une position vis à vis d'un rectangle. c) Implanter une méthode permettant de calculer l'abscisse de l'intersection d'une droite horizontale avec la droite supportée par un segment. d) Implanter une méthode permettant de calculer l'ordonnée de l'intersection d'une droite verticale avec la droite supportée par un segment. e) Implanter une méthode de calcul du segment clippé d'un segment vis à vis d'un rectangle. TP n°7 : Rastérisation de surfaces Pour ces exercices, on pourra de nouveau utiliser le code source AffichageEcranOrthographique.cpp pour dessiner en coordonnées de modélisation comptées en pixels. Exercice n°1 : Rastérisation d'un cercle On considère un cercle de rayon r entier centré sur l'origine. a) Implanter une fonction de traçage des pixels du bord de ce cercle avec utilisation de l'algorithme de Bresenham. b) Implanter une fonction de remplissage des pixels de ce cercle. Exercice n°2 : Rastérisation d'un triangle On considère un polygone triangulaire quelconque. a) Implanter une fonction de traçage des pixels du bord de ce triangle avec utilisation de l'algorithme de Bresenham. b) Implanter une fonction de remplissage des pixels de ce triangle. Solutions TD n°9: Quelques problèmes mathématiques liés au lancer de rayons Le TD est réalisé en langage C. Les structures suivantes devront être utilisées:
a) Implanter une fonction permettant de tester l'existence d'une intersection entre un rayon lumineux et une sphère. b) Implanter une fonction permettant de déterminer, si elle existe, la distance entre le point d'émission d'un rayon lumineux et l'intersection entre ce rayon et une sphère. c) Implanter une fonction permettant de calculer la direction du rayon réfléchi créé par un rayon incident à l'interface entre deux milieux. d) Implanter une fonction permettant de calculer la direction du rayon transmis créé par un rayon incident à l'interface entre deux milieux. TP n°8 : Plaçage de texture bitmap 2D en OpenGL La portion de code suivante crée un tableau d'octets représentatif d'une bitmap RGB de 8x8 pixels représentant un damier noir et blanc. GLubyte *makeImage(void) { a) Reprendre le cube modélisé par facettes lors du TD n°3 pour le texturer au moyen d'une image bitmap créée par cette fonction. b) Cette fonction peut être utilisée pour modéliser par facettes une sphère: #ifndef M_PI Adapter cette fonction la pour qu'elle intègre la création des coordonnées de texturage de manière à autoriser l'emploi de textures.
c) Les trois fichiers suivants: sont des fichiers au format raw (RGB entrelacé, le nom du fichier indique la résolution).
Développer une fonction de chargement d'un tel fichier en mémoire.
Solutions
TD n°10: Calcul d'une courbe de Bézier Le TD est réalisé en C. On considère les types de données suivants: typedef struct coord_3D { Développer une fonction de calcul de la lignePolygonale représentative
de la courbe de Bézier obtenue en considérant qu'une lignePolygonale définit ses points
de contrôle. On pourra utiliser le code suivant pour initialiser une lignePolygonale de 2 (à 8) points de contrôle: static GLfloat pts[8][4] = {
Solutions TP n°9: Calcul de l'intersection entre une sphère et un rayon, des rayons réfléchi et transmis dans le cadre de l'implantation d'un algorithme de lancer de rayons Le fichier RayTracing.zip contient un
programme de calcul et d'affichage de scènes représentées en lancer de rayons.
Solution TD n°11: Les courbes BSplines On considère les structures de données C suivantes: typedef struct coord_3D { Exercice n°1 Développer une fonction permettant de calculer la position du point P d'une BSpline
correspondant à une valeur de t. Exercice n°2 Développer une fonction de calcul de la lignePolygonale représentative
de la courbe de BSpline par morceaux obtenue en considérant qu'une lignePolygonale
définit ses points de contrôle. Application numérique static coord_3D ptsi[28] = { static lignePolygonale pl = { 28,(coord_3D *) &ptsi[0] }; matrice nrubs = { -0.1667F, 0.5F, -0.5F, 0.1667F,
Solutions |