Université de Khemis Miliana 2016 / 2017

3ème année Informatique matière : infographie- opengl

Corrigé de l'Examen Final 20

Partie I): 20

Question 1 (0.75 point): Quelle(s) librairie(s) ne fait (font) pas partie du monde opengl
-Aux ☐
-Glu ☐ 0.75
-Glx ☐
03
-Tux ☐X
Question 2(0.75 point): La technique de Z buffer consiste à 03
-Masquer une partie de l’image (masque de Zorro) ☐
-Remplissage d’une matrice écran ☐X
-Une subdivision de segments ou faces se coupant ☐ 0.75

-Remplir une zone en parcourant les pixels en Z ☐

Question 3(0.75 point):A quoi fait référence le A de GL_RGBA
-A la valeur Ambiante ☐
-A indiquer que les couleurs sont en décimal ☐ 0.75
-A gérer les paramètres d’atténuation ☐
-A gérer le paramètre de transparence ☐ X
Question 4(0.75 point): Cette image est caractéristique d’une :
-Projection en perspective 
☐
-Projection orthogonale ☐
X
-Projection parallèle ☐
X 0.75

-Projection symétrique ☐

07
Partie II):
07
1 • Que signifie openGL ?(1point)
OpenGL est une librairie graphique 3D disponible sur de nombreuses plate-formes
(portabilité) qui est devenu un standard en infographie. C’est un langage procédural
(environ 200 fonctions) qui permet de donner des ordres de tracé de primitives graphiques
1
(segments, facettes, etc.) directement en 3D
2 • Que signifie glut ?(1point)
OpenGL Utility Toolkit (GLUT) 1

Bibliothèque écrite pour rendre simple la programmation de petites applications dans le cadre
d'interfaces graphiques interactives simples.
3 • Quelles sont les propriétés d’openGL ?(1point)
C’est une machine à états qui permet de définir un contexte de tracé : position de caméra,
projection 2D, couleurs, lumières, matériaux... OpenGL se charge de faire les changements
de repère, la projection à l'écran, le « clipping » (limites de visualisation), l'élimination des
parties cachées, l'interpolation les couleurs, et de la « rasterisation » (tracer ligne à ligne) des
faces pour en faire des pixels. 1
Fonctions de base pour l'affichage 3D en OpenGL:
• Dessin de sommets, de segments de droite et de facettes
• Matériaux et lumières • Transformations géométriques • Caméras
• Textures • Gestion des paramètres de rendu • ...
Pas de fonction pour la construction d'une interface utilisateur (fenêtres, souris, clavier,
gestionnaire d'événements, ...)
-Préfixe des fonctions:gl -Librairie standard -En langage C, déclarations dans le fichier
GL/gl.h
4 • Quelles sont les propriétés de glut ?(1point)
• Gestion d'une fenêtre d'affichage • Gestion de la souris • Gestion du clavier • ...
Programmation événementielle • Gestion des menus
• Gestion des environnements multifenêtrés
• Existence de polices de caractères bitmap et vectorielles intégrées
• Gestion de périphériques d'entrée supplémentaires
• ... 1

plus grande puissance et mais plus grande complexité Préfixe des fonctions: glut
Librairie non standard mais très couramment utilisée -Librairie non spécifique à un système
d'exploitation -En langage C, déclarations dans le fichier GL/glut.h
5 • Que fait la fonction glEnable(GL_LIGHTING)?(1point)
Activation de la gestion des lumières et des matériaux, 1

6 • Que fait la fonction glOrtho(left, right, bottom, top, near ,far) ?(1point) 1
Pour la projection orthogonale appelée projection orthographique le volume de vue est un
parallélépipède rectangle. Ainsi la taille des objets n’est pas influencée par la distance au
point de vue.

7 • Que fait la fonction glMaterialfv (GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess)?(1point)

Permet de modifier les paramètres du matériau courant: la face arrière et avant, couleur
ambiante/diffuse/spéculaire, brillance,….. 1

Exercice1 :
Les matrices de transformation en coordonnées homogènes pour chaque type de
transformation sont:
1 0 0 0 2.5
  0.5
 0 cos(ax)  sin(ax) 0 
Rotation R1   2.5
0 sin(ax) cos(ax) 0 
 
0 1 
 0 0
1 0 0 dx1
 
0 1 0 dy1
Translation T1 
 0.5
0 0 1 dz1
 
0 0 0 1 

 1 0 0 dx 2 
 
0 1 0 dy 2 
Translation T2 

0 0 1 dz 2  0.5
 
0 0 0 1 

 cos( ax) 0  sin(ax) 0 
 
 0 1 0 0 0.5
Rotation R2 
sin(ax) 0 cos(ax) 0 
 
 0 1 
 0 0
Matrice globale de transformation en coordonnées homogènes 

0.5

 cos(ax) 0  sin(ax) 0  1 0 0 dx 2  1 0 0 dx1 1 0 0 0  1 0 0 0

     
 0 1 0 0  0 1 0 dy 2  0 1 0 dy1 0 cos(ax)  sin(ax) 0  0 1 0 0
 sin(ax) 0 cos(ax) 0  0 0 1 dz 2  0 0 1 dz1 0 sin(ax) cos(ax) 0  0 0 1 0
     
 0 1  0 0 0 1  0 0 0 1  0 1  0 0 0 1 
 0 0 0 0

Exercice2 :
7.5

7.5

Pour ceci, on divisera la fusée en trois parties: un cylindre, un cône et les ailerons.
axe Z Axe Y

1.5

axe X/Y
3
20° Axe X
2

1
 Programme OpenGL
#include <stdio.h>
#include <math.h>
0.5
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
void init(void);
void cylindre(float r, float h);
void cone(float r, float h);
void ailerons(float r, float h); 0.5
void scene(void) ;
void display(void);
void reshape(int x,int y);

/* Variables et constantes globales */

static const float blanc[] = { 1.0F,1.0F,1.0F,1.0F };
static const float gris[] = { 0.7F,0.7F,0.7F,1.0F };
static int aff = 1;
/* Fonction d'initialisation des parametres */
void init(void) { 0.5
const GLfloat mat_shininess[] = { 50.0 };
glMaterialfv(GL_FRONT,GL_SPECULAR,blanc);
glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);
glLightfv(GL_LIGHT0,GL_DIFFUSE,gris);
glLightfv(GL_LIGHT1,GL_DIFFUSE,gris);
glLightfv(GL_LIGHT2,GL_DIFFUSE,gris); glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); glEnable(GL_LIGHT2);
glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE);
glEnable(GL_AUTO_NORMAL); }
/* Scene de dessin d'un cylindre */
Void cylindre(float r,float h)
{ 1
glPushMatrix();
glBegin(GL_POLYGON);
glColor3ub(255,0,0); //face rouge
for(i=0,i<n,i++)
{
glVertex3d(r*cos(t*i),r*sin(t*i),0);
}
glEnd();
glBegin(GL_POLYGON);
glColor3ub(255,0,0); //face rouge
for(i=0,i<n,i++)
{
glVertex3d(r*cos(t*i),r*sin(t*i),h);
}
glEnd();
for(i=0,i<n,i++)
{glBegin(GL_QUADS);
glColor3ub(255,0,0); //face rouge
glVertex3d(r*cos(t*i),0.5*sin(t*i),0);
glVertex3d(r*cos(t*(i+1)),r*sin(t*(i+1)),0);
glVertex3d(r*cos(t*(i+1)),r*sin(t*(i+1)),h);
glVertex3d(r*cos(t*i),r*sin(t*i)),h);
glEnd();
}
glFlush();
glPopMatrix();
}

Void cone(float r,float h)

{ 1
glPushMatrix();
glBegin(GL_POLYGON);
glColor3ub(255,0,0); //face rouge
for(i=0,i<n,i++)
{
glVertex3d(r*cos(t*i),r*sin(t*i),0);
}
glEnd();
glBegin(GL_TRIANGLE_FAN);
glColor3ub(255,0,0); //face rouge
glVertex3d(0,0,h);
for(i=0,i<n,i++)
{
glVertex3d(r*cos(t*i),r*sin(t*i),0);
}
glEnd();
glFlush();
glPopMatrix();
}
Void ailerons (float r1, float r2,float t)
{
glPushMatrix();
glBegin(GL_POLYGON);
………………………………
1

Car l'image sur le sujet d'examen n'est pas claire, alors l'essentiel
il faut définir quatre faces polygonale
………………………………
glFlush();
glPopMatrix();
}
}
/* Scene dessinee */
void scene() {
glPushMatrix(); 1
glPushMatrix();
cone(1.5,1.5);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0F,0.0F,-3.0F);
cylindre(1.5,3.0)
glPopMatrix();
glPushMatrix();
glTranslatef(1.5F,0.0F,0.0F);
ailerons(1.0,1.0,20.0)
glPopMatrix();
glPushMatrix();
glRotatef(90.0F,0.0F,0.0F,1.0F);
ailerons(1.0,1.0,20.0)
glPopMatrix();
glPushMatrix();
glRotatef(90.0F,0.0F,0.0F,1.0F);
ailerons(1.0,1.0,20.0)
glPopMatrix();
glPushMatrix();
glRotatef(90.0F,0.0F,0.0F,1.0F);
ailerons(1.0,1.0,20.0)
glPopMatrix();
glPopMatrix(); }
/* Fonction de dessin */
void display(void) { 0.5
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
const GLfloat light0_position[] = { 1.0,1.0,1.0,0.0 };
const GLfloat light1_position[] = { -1.0,1.0,1.0,0.0 };
const GLfloat light2_position[] = { 1.0,-1.0,1.0,0.0 };
glLightfv(GL_LIGHT0,GL_POSITION,light0_position);
glLightfv(GL_LIGHT1,GL_POSITION,light1_position);
glLightfv(GL_LIGHT2,GL_POSITION,light2_position);
glPushMatrix();
scene();
glPopMatrix();
glFlush(); }
/* Fonction d'ajustement de la camera de visualisation */
void reshape(int x,int y) { glViewport(0,0,x,y);
glMatrixMode(GL_PROJECTION);
glLoadIdentity(); 0.5
gluPerspective(22.0F,(float) x/y,1.0,50.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0,10.0,15.0,0.0,0.0,0.0,0.0,1.0,0.0);
}
/* Fonction principale */
int main()
{ 1
glutInit( );
glutInitWindowSize(450,300);
glutInitWindowPosition(50,50);
glutCreateWindow("Quatre cubes");
init();
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutMainLoop();
return(0); }