Sujets et Corrections |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TD n°1 : Premières scènes OpenGL Exercice n°1
(1) Programmer en OpenGL la scène suivante sous la forme d'une fonction C sans utiliser les fonctions glPushMatrix et glPopMatrix ailleurs
qu'en début et fin de fonction: (2) Reprogrammer en OpenGL 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 OpenGL la scène de la question (2) en utilisant les fonctions glPushMatrix et glPopMatrix pour rendre les objets indépendants les uns des autres et simplifier l'écriture de la fonction scène.
(4) Programmer une scène OpenGL en plaçant 3 cubes de coté 2.0 aux 3 sommets d'un triangle équilatéral défini
avec les caractéristiques suivantes:
Exercice n°2
(1) Programmer la scène OpenGL modélisant un bras robot simplifié composé d'un avant-bras et d'un bras.
(2) Modifier la fonction OpenGL de l'exercice n°1 en remplaçant les parallélépipèdes par des cylindres de tailles équivalentes.
Exercice 3 a) Implanter en OpenGL une fonction de dessin d'une molécule de Benzène (C6H6).
Les atomes de carbone (atomes centraux) ont un rayon égal à 0.5.
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).
Solutions
TD n°2 : Modélisation par facettes Exercice n°1
a) Modéliser par facettes un cube de coté c centré sur l'origine du repère de modélisation. On ne générera
pas les normales.
b) Modifier la modélisation de la question précédente pour ajouter la gestion des normales.
a) Modéliser par facettes un cylindre selon les caractéristiques suivantes:
b) Ajouter un découpage latéral (selon l'axe y) pour une valeur nl.
Solutions
TP n°1 : Premières implantations OpenGL Exercice n°1
Télécharger le fichier archive 2015-2016.zip. Ce fichier archive contient une "solution" Visual Studio 2010.
La solution comprend un seul projet nommé Exemple. Ce projet inclut un seul fichier source Exemple.cpp et est configuré pour une compilation utilisant
OpenGL: a) Extraire l'archive IG-2015-2016. Lancer Visual Studio 2010 et charger la solution. Vérifier la compilation et l'exécution du projet Exemple. Les cylindres n'existent pas dans GLUt, on pourra utiliser le module suivant pour les modéliser: ModuleCylindres.h, ModuleCylindres.cpp. b) Implanter la question (4) de l'exercice n°1 du TD n°1. c) Implanter l'exercice n°3 du TD n°1. TD n°3 : Paramètrage numérique de caméras Exercice n°1
a) On considère une caméra de visualisation en projection parallèle orthographique placée en position (0.0, 0.0, 0.0) orientée selon l'axe (0.0,
0.0, -1.0). On considère une scène centrée sur le point de coordonnées (0.0, 0.0, -100.0) et occupant un volume circulaire de rayon voisin de 10.0.
b) On considère une caméra de visualisation en projection en perspective placée en position (0.0, 0.0, 0.0) orientée selon l'axe (0.0, 0.0, -1.0).
On considère une scène centrée sur le point de coordonnées (0.0, 0.0, -100.0) et occupant un volume circulaire de rayon voisin de 10.0. Exercice n°2 Une caméra de visualisation en perspective OpenGL est obligatoirement placée en position (0.0, 0.0, 0.0) du repère de modélisation. Elle est obligatoirement orientée selon l'axe de projection (0.0, 0.0,-1.0).
a) On considère une scène modélisée au sein d'une fonction C de manière à être centrée autour de l'origine du repère de modélisation associé
à la fonction.
b) On considère la scène de la question (a).
c) On considère la scène de la question (a). Solutions TP n°2 : Scènes OpenGL, GLUT et caméras Exercice n°1 Implanter et tester le fonctionnement de l'exercice n°1 du TD n°1 (quatre cubes).
Exercice n°2 Tester les trois possibilités existant pour ajuster la taille des objets à l'écran de manière à voir la scène en gros plan:
Exercice n°3 a) Ajouter un contrôle clavier pour que les cubes de la scène puissent être remplacés par des sphères (et réciproque). La fonction void glutSolidSphere(double rayon, int n,int m) peut être utilisée pour modéliser une sphère. b) Ajouter un contrôle clavier pour que les objets puissent être affichés soit en mode plein, soit en mode fil de fer (fonction glPolygonMode d'OpenGL).
Exercice n°4 a) Tester les configurations de caméra définies aux 3 questions de l'exercice n°2 du TD n°3. b) Tester la configuration par gluLookAt d'une caméra placée en position (0.0, 100.0, 0.0), orientée vers l'origine et d'axe vertical (0.0, 1.0, 0.0). Solutions TD n°4 : Lumières et matériaux en OpenGL Exercice n°1 a) Développer le code source OpenGL permettant de configuer la lumière n°0 en tant que lumière ponctuelle placée en position (0.0, 0.0, 2.5). Sa composante d'émission diffuse est rouge. Sa composante d'émission spéculaire est blanche.
b) Développer le code source OpenGL permettant de configuer la lumière n°1 en tant que lumière directionnelle de direction d'incidence (1.0, 0.0, 0.0). Sa composante d'émission diffuse est verte. Sa composante d'émission spéculaire est blanche.
c) Développer le code source OpenGL permettant de configuer la lumière n°2 en tant que spot placé en position (2.0, 10.0, 2.0), orienté vers le point de coordonnées (-2.0, 0.0, -2.0) et d'ouverture 20.0°. Sa composante d'émission diffuse est bleue. Sa composante d'émission spéculaire est blanche.
d) Ajouter au code de paramétrage la lumière n°0 les appels OpenGL permettant de configurer une atténuation de l'éclairage en fonction inversement proportionnelle du carré de la distance entre la source lumineuse et le point éclairé.
e) Proposer une solution permettant de choisir la position de placement de la lumière ponctuelle de la question (a) et la direction d'orientation de la lumière directionnelle de la question (b) par rotation d'une valeur d'angle autour de l'axe Oy.
Exercice n°2 a) Développer le code source OpenGL permettant de configurer le matériel pour qu'il adopte la couleur blanche en diffusion et la couleur noire en spéculaire, ambiant et émission.
b) Développer le code source OpenGL permettant de configurer le matériel pour qu'il adopte la couleur rouge en diffusion et la couleur noire en spéculaire, ambiant et émission.
c) Développer le code source OpenGL permettant de configurer le matériel pour qu'il adopte la couleur jaune en diffusion et la couleur noire en spéculaire, ambiant et émission.
d) Développer le code source OpenGL permettant de configurer le matériel pour qu'il adopte la couleur blanche en diffusion et spéculaire et la couleur noire en ambiant et émission. La réflectivité est configurée avec la valeur 64.0.
Solution
TP n°3 : Lumières et matériaux en OpenGL Implanter les exercice du TD n°4 sur la scène du TP n°2 constituée de 4 sphères. Solution
TD n°5 : Mathématiques de l'Informatique Graphique Exercice n°1 Proposer une méthode permettant de tester la planarité d'une facette à 4 sommets. Exercice n°2 a) Développer en C++ une classe CoordonneesHomogenes3D. b) Dériver de la classe CoordonneesHomogenes3D une classe Position3D pour le stockage de positions dans un espace à trois dimensions. c) Dériver de la classe CoordonneesHomogenes3D une classe Direction3D pour le stockage de directions dans un espace à trois dimensions. d) Développer une méthode de calcul du produit scalaire de deux Direction3D. e) Développer une méthode de calcul du produit vectoriel de deux Direction3D. f) Implanter une fonction ou une méthode de test de la planarité de facettes à 4 sommets.
Solutions
TP n°4 : Animation en OpenGL et GLUt
Le but du TP consiste à implanter une animation où une sphère de 20 pixels de rayon se déplace dans une fenêtre de 600x400 pixels et rebondit sur
ses bords horizontaux et verticaux.
Quelques indications: Solution
TD n°6 : Mathématiques de l'Informatique Graphique Exercice n°1 a) Développer en C++ une classe TransformationGeometrique3D en coordonnées homogènes. b) Dériver de la classe TransformationGeometrique3D une classe Translation3D pour le stockage d'opérateurs de type translation de vecteur (tx, ty, tz). c) Dériver de la classe TransformationGeometrique3D une classe Rotation3D pour le stockage d'opérateurs de type rotation d'angle a autour de l'axe (ax, ay, az) passant par l'origine. d) Implanter une méthode de transformation d'une position ou d'une direction par une translation ou une rotation. e) Implanter une méthode de composition d'une transformation géométrique par une transformation géométrique.
Solutions
TP n°5 : Coordonnées homogènes et transformations géométriques Le fichier code source RotationCube_TP.cpp implante un programme de modélisation, d'affichage et d'animation d'un cube en fil de fer. La modélisation du cube est réalisée au moyen d'une primitive graphique OpenGL de type GL_LINES. L'animation est obtenue par la réalisation de deux rotations successives d'angles r1 et r2 avec incrémentation de r1 et r2 entre chaque image. Le code correspondant est à trouver dans la fonction void scene1(void). a) Télécharger, compiler et exécuter ce fichier source. On souhaite ne plus utiliser la fonction glRotatef d'OpenGL. La seule solution à notre disposition consiste à implanter les opérations mathématiques nécessaires à la réalisation de rotations. Le fichier archive MathematiquesIG_TP.zip contient les classes CoordonneesHomogenes3D, Position3D et Direction3D de gestion des coordonnées homogènes ainsi que les classes TransformationGeometrique3D, Translation3D, Rotation3D et Scale3D de gestion de transformations géométriques en coordonnées homogènes. b) Télécharger et compiler les fichiers de cette archive en les intégrant au projet de la question (a). c) Ecrire (remplir) les fonctions compose et transforme de la classe TransformationGeometrique3D. d) Reprendre le code source RotationCube_TP.cpp pour écrire (remplir) la fonction void scene2(void) pour qu'elle réalise les mêmes opérations que la fonction void scene1(void) mais sans utiliser glRotatef. La touche Enter utilisée en cours d'exécution permet de switcher entre scene1 et scene2. Solutions
TP n°6 : Plaçage de texture
L'archive zip suivante contient les fichiers sources d'une librairie de gestion des fichiers png: Png.zip. a) Importer cette archive, en faire l'extraction, inclure l'ensemble des fichiers qu'elle contient dans un projet de développement, vérifier la compilation et l'exécution par importation d'une image png sous la forme d'un tableau de pixels (sans affichage). On pourra se servir de l'image Test.png qui est formée d'une matrice de 64x64 pixels dont la première ligne est bleue. b) Implanter un programme OpenGL de dessin d'un carré de coté 6.0 sur lequel est placée une image bitmap.
c) Implanter un programme OpenGL de modélisation d'un cylindre sur le tube duquel est placée une texture bitmap.
On pourra utiliser et adapter la fonction ci-dessous.
/* Modelisation par facettes d'un cylindre */ On pourra se reporter au chapitre sur le texturage pour une description plus précise des principes utilisés pour cette technique et à la partie 3 du chapitre sur OpenGL pour son application en OpenGL. Solution
TD n°7 : Tracé de courbes B-Splines On souhaite implanter le calcul de courbes lissées de type B-Spline. Exercice n°1
Développer une classe permettant de modéliser une ligne polygonale 3D. Exercice n°2 Les classes développées dans les TD-TP précédents pour modéliser des vecteurs à 4 composantes et des matrices à 4x4 composantes comportent des méthodes de calcul de produits matriciels qui nous seraient utiles pour l'implantation du calcul de courbes B-Splines. Or, il n'est pas souhaitable d'utiliser les classes déjà créées à cette fin car elles seraient détournées de leur usage normal. Un travail de redesign est nécessaire (voir hiérarchie de classes en bas de cette page web). a) Reprendre la classe mère CoordonneesHomegenes3D pour la faire dériver d'une classe mère Vecteur4. b) Reprendre la classe mère TransformationGeometrique3D pour la faire dériver d'une classe mère Matrice4x4. Déplacer dans cette classe les opérateurs de réalisation du produit matrice-vecteur et du produit matrice-matrice. c) Faire dériver de la classe Matrice4x4 une classe MatriceDeBase qui sera spécifiquement utilisée pour la modélisation des matrices de base utilisées pour le lissage des courbes B-Splines. d) Implanter un constructeur de calcul d'une ligne polygonale par lissage d'un quadruplet de sommets 3D au moyen d'une courbe B-Spline. Outre les sommets de contrôle, les paramètres seront la matrice de base et le nombre de sommets. f) Implanter un constructeur de calcul d'une ligne polygonale par lissage d'une ligne polygonale au moyen d'une courbe B-Spline par morceaux. Outre les sommets de contrôle, les paramètres seront la matrice de base et le nombre de sommets.
Solutions
TP n°7 : Clipping par l'algorithme de Cohen-Sutherland
On considère les fichiers sources contenus dans le fichier zip suivant: ClippingCohenSutherlandVide.zip.
Ils constituent une application OpenGL de calcul et d'affichage d'un segment clippé dans un rectangle à bord horizontaux et verticaux au
moyen de l'algorithme de Cohen-Sutherland. Les méthodes correspondant aux questions (a), (b), (c) et (d) suivantes ont été "vidées".
Il convient de les complèter pour que l'application devienne compilable et exécutable. a) Développer une méthode permettant de déterminer le code de Cohen-Sutherland (valeur entière) d'une Position2D vis à vis d'un Rectangle2D. b) Développer une méthode permettant de déterminer l'abscisse de l'intersection entre un Segment2D et une droite horizontale (connue par son ordonnée). c) Développer une méthode permettant de déterminer l'ordonnée de l'intersection entre un Segment2D et une droite verticale (connue par son abscisse). d) Développer une méthode permettant de clipper un Segment2D dans un Rectangle2D (algorithme de Cohen-Sutherland).
Solutions
TD n°8 : Remplissage d'une facette triangulaire Implanter une fonction de remplissage 2D d'un triangle.
Méthode: Remplir un triangle en 2D peut être réalisé en traçant toutes les lignes horizontales de pixels délimitées par ses bords gauche et droit. Il convient donc de déterminer les abscisses extrèmes de ces lignes horizontales pour chacun des y compris entre ymin et ymax où ymin (resp. ymax) est la valeur minimale (resp. maximale) des ordonnées des 3 sommets de définition du rectangle.
Ainsi, deux tableaux xd et xg sont calculés dont les indices correspondent aux ordonnées y des lignes de pixels.
Solutions
TP n°8 : Calcul de la quantité d'énergie diffusée en un point éclairé par une source lumineuse
On considère les classes Rvb, Couleur, Energie suivantes:
On considère les classes Lumiere et LumiereDirectionnelle suivantes: a) Développer une méthode permettant de calculer la quantité d'énergie diffusée sous l'éclairage d'une LumiereDirectionnelle en une Position3D extraite d'une surface où la normale est connue sous la forme d'une Direction3D. Les coefficients de diffusion de la surface sont définis par la donnée d'une Couleur. La formule de calcul à utiliser est la formule de Lambert.
Sphère éclairée par une lumière directionnelle
Pour cette question, il convient de développer une méthode virtuelle dans la classe Lumiere qui sera implantée concrètement dans la classe LumiereDirectionnelle.
Son prototype est:
On considère la classe LumierePonctuelle suivante: b) Développer une méthode permettant de calculer la quantité d'énergie diffusée sous l'éclairage d'une LumierePonctuelle en une Position3D extraite d'une surface où la normale est connue sous la forme d'une Direction3D. Les coefficients de diffusion de la surface sont définis par la donnée d'une Couleur.
Sphère éclairée par une lumière ponctuelle Pour cette question, il convient de développer une nouvelle implantation de la méthode de calcul de diffusion dans la classe LumierePonctuelle.
On pourra utiliser le programme DiffusionsLambertiennes.cpp et les classes mathématiques
MathematiquesIG.zip pour tester les deux méthodes développées. Remarque: Ce code source montre comment utiliser deux (plusieurs par extension) fenêtres ainsi que les menus popup. Solutions
TP n°9 : Lancer de rayons: Calcul des directions de réflexion et transmission
a) Concevoir une méthode de la classe Direction3D permettant de calculer la direction d'un rayon réfléchi lors d'une réflexion spéculaire.
b) Concevoir une méthode de la classe Direction3D permettant de calculer la direction d'un rayon transmis à l'interface entre deux milieux
lors du passage entre ces deux milieux.
Fig 1: Rayon incident en jaune, normale en magenta, rayon réfléchi en rouge, rayon transmis en bleu
Fig 2: ni < nt -> Rayon transmis dévié vers le vecteur opposé au vecteur normal
Fig 3: Cas particulier: Pas de rayon transmis On pourra utiliser le programme RayTracingVide.zip (fonction main dans RayTracing.cpp) pour tester les 2 méthodes développées. Ce programme implante un calcul d'images par lancer de rayons.
Il s'appuie sur l'ensemble des classes développées depuis le début des séances de TD et de TP (voir ci-dessous). Solutions
TP n°10 : Transformations géométriques pour la visualisation a) On donne les lignes de code suivantes:
static const int nbP = 30; Ces lignes réalisent la déclaration dans le tableau smmts de nbP = 30 sommets en trois dimensions et la déclaration dans le tableau sgmts de nbS = 34 segments de droite par la donnée de 34 couples d'indices de sommet du tableau smmts. Utiliser ces données pour afficher en fil de fer l'objet ainsi modélisé. b) Le but de la suite du TP est d'implanter les transformations géométriques de visualisation telles que réalisées au sein d'OpenGL.
On connait les coordonnées des objets modélisés dans le repère global (coordonnées ci-dessus).
On souhaite transformer du repère global vers le repère observateur les coordonnées des objets modélisés.
La matrice de transformation utilisée est: Dériver de la classe TransformationGeometrique3D une classe LookAt implantant la transformation géométrique ci-dessus. Utiliser cette classe pour réaliser la transformée des positions définies dans le tableau smmts. On choisira Po = (200.0,60.0,120.0) et Pv = (0.0,0.0,0.0).
Utiliser les coordonnées obtenues pour afficher l'objet modélisé en implantant une visualisation en projection parallèle orthographique. Pour
ce faire, on utilisera uniquement les coordonnées x et y, z étant considéré avoir pour valeur 0.0. c) On souhaite visualiser la scène en utilisant une projection en perspective plutôt qu'une projection parallèle orthographique. Implanter une visualisation en perspective est réalisé en transformant chaque sommet (obtenu après la transformation géométrique repère global -> repère observateur) par division de sa coordonnée x (resp. y) par sa distance en z pour obtenir sa coordonnée écran x' (resp. y') puis en utilisant (x',y') comme coordonnées d'affichage.
d) On souhaite maintenant réaliser une animation de caméra consistant à déplacer la position de l'observateur sans changer le point qu'il
regarde.
static const int nbT = 18;
Pour générer cette courbe lissée, on pourra utiliser la classe LignePolygonale qui permet de modéliser des lignes brisées et de les lisser et la
classe MatriceDeBase qui décrit des matrices de base utilisables pour créer des B-Splines.
Hiérarchie de classes
|