Notion de visualisation et projection

**Ceylo** · 07/07/2007, 18h19

Bonjour,

Je me suis mis depuis quelques temps à étudier (en douceur) la bibliothèque OpenGL. Pour y voir plus clair j'ai acheté le Guide officiel OpenGL (Red Book) en français et feuilleté ce qui me paraissait intéressant.

Mais voilà, je m'embrouille avec les fonctions qui concernent la matrice de modélisation-visualition et la matrice de projection. Et tout ça parce que je ne comprends pas la différence entre visualisation et projection.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
/*
 *  cube.c
 *  This program demonstrates a single modeling transformation,
 *  glScalef() and a single viewing transformation, gluLookAt().
 *  A wireframe cube is rendered.
 */
#include <GL/glut.h>
#include <stdlib.h>
 
void init(void) 
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);
}
 
void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT);
   glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();             /* clear the matrix */
           /* viewing transformation  */
   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glScalef (1.0, 2.0, 1.0);      /* modeling transformation */ 
   glutWireCube (1.0);
   glFlush ();
}
 
void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
   glMatrixMode (GL_MODELVIEW);
}
 
void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}
 
int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;
}

En suivant la progression du programme :
GLUT est initialisée, puis on créé une fenêtre et on appelle la fonction init().
On dit à GLUT les fonctions dont il va se servir, puis on lance la boucle principale.
Au premier affichage de la fenêtre, reshape() est appelée.
On fait la transformation de cadrage. Puis on positionne la matrice active comme étant celle de projection, on effectue des transformations de projection, et on remet la matrice active comme étant celle de modélisation.

Jusque là tout va bien.
Ensuite pour dessiner la fenêtre, la fonction display() est appelée.
On vide la fenêtre. On vide la matrice active (qui est donc ici la matrice de modélisation-visualisation. Et là... on appelle gluLookAt().

C'est là que je coince. On me dit que c'est une transformation de visualisation, mais lorsque j'y pense, pour moi c'est plutôt une transformation de projection et aussi de visualisation. Je suis complètement embrouillé sur la différence entre visualisation et projection !

Est-ce que quelqu'un peut m'expliquer la différence ?

Merci, et bon développement

**Laurent Gomila** · 07/07/2007, 18h33

Matrice model-view (visualisation) : c'est la matrice qui permet d'avoir une certaine vue de la scène 3D ; tu peux voir cette matrice comme une caméra. De plus, la transformation qu'elle effectue c'est d'un espace 3D vers un espace 3D.

Matrice de projection : c'est la matrice qui permet de projeter ta scène 3D sur un écran 2D. La transformation qu'elle effectue est donc d'un espace 3D à un espace 2D (en fait c'est toujours 3D après projection, mais oublie ça pour le moment).

En gros, avec la matrice modelview tu vas pouvoir te déplacer dans ta scène, tourner, etc... Alors qu'avec la matrice de projection tu vas plutôt définir le zoom, la perspective, etc...

Et il ne faut pas oublier que tout ça c'est seulement un rôle qu'on leur donne, mais qu'en interne les deux matrices seront simplement multipliées entre elles avant de transformer les sommets. Par exemple si tu n'utilisais qu'une seule de ces deux matrices (vue 2D par exemple), tu pourrais indifféremment utiliser l'une ou l'autre.

**bafman** · 07/07/2007, 18h37

pour faire simple (et efficace) :
la matrice de projection represente le cone de vision de la camera (l'angle d'ouverture de l'objectif)
la matrice de modelview represente la position et la direction dans laquelle regarde la camera.

en fait, la matrice de projection est appelée ainsi car c'est elle qui permet de projeter une position 3D sur un ecran 2D

**Ceylo** · 07/07/2007, 19h53

Je ne sais pas encore si j'ai tout compris, faut que je digère vos explications

.

En tout cas merci.

**smashy** · 09/07/2007, 09h02

tentative d explication numero 3.

1 - Modelview

Quand tu definis les vertex d un objet 3D, tu ecris du code comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
 
glBegin(...)
 
  glVertex3f(....)
 
  ...
 
glEnd();

Ce code d ecris l objet dans un repere qui lui est propre. Si tu dessines deux fois le meme objet dans une meme scene, mais a deux endroits differents, tu ne vas pas t amuser a changer les coordonnees x,y,z de chaque appel a glVerte3f. Tu vas plutot definir une suite de transformations a appliquer a tous les vertex pour obtenir l objet tel que tu veux qu il soit placer dans la scene.

Donc en fait, pour chaque instance de ton objet, tu as une matrice qui permet, pour chaque vertex de savoir ou tu veux qu'il soit reellement dans un repere absolu a la scene.

Tu peux imaginer le code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
 
  voiture1.positionner_matrice_de_transformation()
 
  dessiner_une_voiture()
 
 
  voiture2.positionner_matrice_de_transformation()
 
  dessiner_une_voiture()

1.1 la camera (MODELVIEW suite)

Pour compliquer un peu, le dessin d un objet dans une scene3D est tributaire de "l'angle" sous lequel tu le regarde (ou est positionner la camera)
La camera possede donc elle aussi une matrice qui permet de transferer un vertex dans le repere absolu par un vertex dans son repere propre.

note : tout est relatif : regarder un objet situe a 10 m de soit, c est comme regarder un objet a 20 m mais en avancant soit meme de 10m.

1.2 MODELVIEW resume

l idee est donc de prendre un vertex (exprime dans le repere du model) et de le transformer de telle sorte que l on obtienne les coordonnnees exprimees dans le repere de la camera. On passe pour cela en intermediaire par un repere absolu.

vertex rep.model --> vertex rep. absolu --> vertex rep. camera

Cette suite de transformation est la matrice de MODELVIEW

Quand tu ecris gluLookAt , tu exprimes en fait la transformation

vertex rep. absolu --> vertex rep. camera

2 - PROJECTION

Maintenant que tu connais ton vertex exprime dans le repere camera, il faut le projete. Typiquement, il "suffit de diviser" ses coordonnees par Z. Pour cela on utilise de vertex 4D sachant que

(x y z w) <=> (x / w , y / w , z /w , w / w = 1)

Le role de la matrice de projection est donc de prendre le vertex

(x y z 1) et de le transformer en (x y z z)

**Yno** · 09/07/2007, 11h16

Sans avoir vraiment lu ton problème (désolé) je tiens à signaler que le livre que tu possèdes, s'il est en version française, est rempli d'erratas. Par exemple, le schéma sur l'importance de l'ordre des transformations (rotation/translation) est erroné, la vérité est tout à fait l'inverse.

Bon, si je voulais critiquer ce livre ça me prendrait des pages entières alors bon, je vais en rester là