Version imprimable
Bonjour à tous
Je dois afficher une animation d'une capture de mouvement et je n'arrive pas a afficher mes points à l'écran. comment dois-je positionner la vue.
J'ai essayé avec glPerspective et gllookAt et je n'ai rien à l'écran.
Je connait le volume qu'occupe mon acquisition (MinX, MaxX, MinY, MaxY, MinZ, MaxZ)
Je développe sous matlab avec la toolbox psychtoolbox qui fournit une interface OpenGl pour la 3D.
Merci d'avance pour votre aide
IL faut normalement dire à OpenGL quelles sont les dimensions de ta fenêtre avec glViewport (je l'utilise comme ceci : glViewport( 0, 0, windowWidth, winwdowHeight))
Ensuiste il faut utiliser gluPerspective ou glOrtho (pour gluPerspective : gluPerspective( FieldOfViewY, ratioWidthOverHeight, NearView, FarView), pour glOrtho : glOrtho( left, right, bottom, top, near, far)).
Il faut faire ces opérations en ayant passé la matrice en mode projection (glMatrixMode( GL_PROJECTION)) puis la repasser en mode model view (glMatrixMode( GL_MODELVIEW))
Merci pour ta réponse, je vais regarder ca
Je n'y arrive pas, toujours un écran noir, je ne vois pas quoi faire
Voici les proportions de ma zone
les X vont de -114 à 516
les Y vont de -123 à 457
les Z vont de -28 à 577
Dois-je translater mes points étant donné que le glPerspective nous place en 0, 0, 0.
Salut,
Il serait plus efficace de nous montrer un peu de code, histoire de savoir exactement ce que tu fais de travers... ;)
En particulier la définition de la vue et la boucle d'affichage.
Alors je charge mes données depuis un fichier C3D dans une structure
Dans cette structure, j'ai un tableau de cellules contenant les marqueurs
Pour chaque marqueur, je mémorise le label et les Coordonnées
Pour l'instant j'essaye d'afficher tous les marqueurs pour la première Frame,
J'ai également calculé les Min et Max pour chaque dimensions pour connaitre les dimensions de mon animation mais je ne voit pas ou utiliser ces paramètres.Code:
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
61
62AssertOpenGL; % On récupère l'identifiant de l'écran Ecran = max(Screen('Screens')); % ON initialise OpenGL InitializeMatlabOpenGL([],[],[], 0); [win , winRect] = Screen('OpenWindow', Ecran, 0,[],[],[],0,0, 0); Screen('BeginOpenGL', win); % Activation de la matrice de projection pour définir un nouveau champs de vision. glMatrixMode(GL.PROJECTION); % Réinitialisation de la matrice courante. glLoadIdentity; % Création d'une nouvelle matrice de projection (espace visible). gluPerspective(45, winRect(3) / winRect(4), 0.1, 100); % Ré-activation de la matrice de modélisation-visualisation. glMatrixMode(GL.MODELVIEW); % Réinitialisation de la matrice courante. glLoadIdentity; % Définition du point de vue. gluLookAt(0, 0, 100, 0, 0, 0, 0, 1, 0); % On définit la couleur d'arrière-plan à noir glClearColor(0,0,0,0); glClear; % Couleur blanche pour les marqueurs glColor3f(1,1,1); % On va balayer chaque marqueur for i = 1 : size(C3D.Marqueurs, 2) % On récupère le marqueur Marqueur = C3D.Marqueurs{1, i}; % On mémorise la matrice glPushMatrix(); % On se positionne à l'endroit ou l'on veut dessiner le marqueur glTranslatef(Marqueur.Coordonnees(1, 1), Marqueur.Coordonnees(1, 2), -Marqueur.Coordonnees(1, 3)); % On dessine la sphère glutSolidSphere(10, 100, 100); % On recharge la matrice glPopMatrix(); end Screen('EndOpenGL', win); % On dessine l'écran Screen('Flip', win);
Alors, les commentaires que je ferais...
- tu places ta caméra en (0,0,100) qui vise (0,0,0)... pas très judicieux pour observer des positions allant de -123 à +577
- tu limites ta profondeur de champ entre 0.1 et 100... avec les positions déjà citées précédemment
- utiliser un glutSolid sans lumière n'est pas hyper utile. Surtout avec 100 comme précision du solid.
Donc recule ta caméra, règle ta profondeur de champ en fonction de ce que tu veux voir, et commence à tester en mettant un simple cube en (0,0,0). Une fois que tu le vois, monte en complexité en rajoutant une sphère à l'origine, puis une de tes sphères, puis toutes tes sphères.
C'est ca mon souci en fait car je n'arrive pas à savoir quoi mettre dans le glPerspective car étant donné que j'ai des valeurs négatives et que cela nous place forcément à l'origine regardant vers les -Z
Pour la position de la caméra glLookAt, là je pense avoir piger et c'est clair que ma caméra est trop proche.
Je vais faire les test que tu me conseil
Merci en tout cas, mais si tu pouvais me donner un petit coup de main sur le glPerspective, cela ne serais pas de refus car j'avoue m'y perdre
Les deux premiers paramètres sont ok.Citation:
Envoyé par kurul1
Les 3ème et 4ème (ton 0.1 et ton 100) te permettent de définir ta profondeur de vision, c'est à dire entre quelles distances de la caméra tu vas voir (donc où OpenGL va afficher). Tout ce qui sera en dehors de ces bornes ne sera pas affiché.
Avec 0.1 et 100, tu lui demandes d'afficher tout ce qui se trouve entre 0.1 et 100 unités de la caméra (autrement appelés znear et zfar). Imagine que tu mettes ta caméra en (100,0,0), visant (0,0,0), tu verras tout ce qui se trouve entre 0.1 et 100 de la caméra, soit tout ce qui est entre x=0.99 (100-0.1) et x=0 (100-100). Donc tout ce qui est à x<0 n'est pas affiché.
Tu vas dire ok, alors je mets le znear à 0 et le zfar à 3 millions et des brouette, et j'aurais tous mes points. Oui mais non... car tu vas bousiller la précision du zbuffer et avoir des soucis d'affichage. Donc jamais de znear à 0, et limiter le zfar.
A partir des coordonnées des objets que tu veux afficher et de la position de ta caméra, tu peux facilement calculer ces deux valeurs afin d'optimiser ton zbuffer. Par exemple, si tu sais que tes points sont dans un rayon de 50 autour de l'origine, et que ta caméra sera toujours positionnée à une distance 100 de l'origine, tu peux très bien mettre le znear à 45, et le zfar à 155.
Merci beaucoup pour ton aide, cela fonctionne maintenant
Cela fait plus de 10 ans que je n'ai pas touché à OpenGl et je suis un peu rouillé
Voilà mon bout de code corrigé pour ceux que cela intéresse
Ou MinX, MaxX, MinY, MaxY, MinZ, MaxZ sont mes bornes sur chaque axeCode:
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81AssertOpenGL; % On récupère l'identifiant de l'écran Ecran = max(Screen('Screens')); % ON initialise OpenGL InitializeMatlabOpenGL([],[],[], 0); [win , winRect] = Screen('OpenWindow', Ecran, 0,[],[],[],0,0, 0); Screen('BeginOpenGL', win); % On convertit l'angle de vision pour les X qui est en degré en radian AngleRadX = (pi * (45 / 2)) / 180; % On calcule le Recule en X ReculeX = (TailleX / 2) / tan(AngleRadX); % Activation de la matrice de projection pour définir un nouveau champs de vision. glMatrixMode(GL.PROJECTION); % Réinitialisation de la matrice courante. glLoadIdentity; % Création d'une nouvelle matrice de projection (espace visible). gluPerspective(45, winRect(3) / winRect(4), 0, TailleZ + ReculeX); % Ré-activation de la matrice de modélisation-visualisation. glMatrixMode(GL.MODELVIEW); % Réinitialisation de la matrice courante. glLoadIdentity; % Définition du point de vue. gluLookAt(0, 0, MaxZ + ReculeX, 0, 0, 0, 0, 1, 0); % On va gérer la lumière glEnable(GL.LIGHTING); % On actrive la première source de lumière glEnable(GL.LIGHT0); % Our point lightsource is at position (x,y,z) == (1,2,3)... glLightfv(GL.LIGHT0,GL.POSITION,[0 0 (-MaxZ - ReculeX) 0]); % On définit la couleur d'arrière-plan à noir glClearColor(0,0,0,0); glClear; % Couleur blanche pour les marqueurs glColor3f(1,1,1); % On va balayer chaque marqueur for i = 1 : size(C3D.Marqueurs, 2) % On récupère le marqueur Marqueur = C3D.Marqueurs{1, i}; % On mémorise la matrice glPushMatrix(); % On met la couleur à Rouge glMaterialfv(GL.FRONT_AND_BACK,GL.AMBIENT, [ 1 1 1 1 ]); glMaterialfv(GL.FRONT_AND_BACK,GL.DIFFUSE, [ 1 1 1 1 ]); % On se positionne à l'endroit ou l'on veut dessiner le marqueur glTranslatef(Marqueur.Coordonnees(1, 1), Marqueur.Coordonnees(1, 2), -Marqueur.Coordonnees(1, 3)); % On dessine la sphère glutSolidSphere(10, 100, 100); % On recharge la matrice glPopMatrix(); end Screen('EndOpenGL', win); % On dessine l'écran Screen('Flip', win);
TailleX, TailleY, TailleZ sont la taille de chaque dimension
Gnaaaaaaaaaaaaaaaaaaaaar, jamais à 0 le znear j'ai dit !!!! ::lol::lol::lol:Code:
2gluPerspective(45, winRect(3) / winRect(4), 0, TailleZ + ReculeX);