Discussion :

[Mic75]

Bonjour à tous,
Je travail actutellement sur le module de visualisation 3d d'un logiciel d'imagerie médicale qui utilise openGl, couplé avec le widget GtkGlArea. L'une des fonctionalités liées au module 3d de ce logiciel est la possibilié de déplacer un curseur (une croix) au sein de la scène 3d en cliquant sur la molette de la souris. Par ailleurs le comportement de ce curseur a été codé de telle sorte que si on clique dans le "vide", le curseur disparait, sinon il reste "collé" à la surface de l'objet.

J'en viens à mon problème :
Si l'on déplace (lentement) le curseur en gardant la molette enfoncée, celui ci ce déplace bien, mais on constate 2 problèmes majeurs :

• la taille du curseur ce modifie -> les segments de la croix augmentent en taille
• il ne colle plus à la surface -> on peut se déplacer dans le vide.

J'ai volontairement omis de balancer des lignes de code pour d'abord vous décrire le problème de manière globale. Personnellement je vois 2 hyposthèse envisageables :

1. problème de mise à jour du tampon de profondeur, car la fonction : glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &prof), associe une valeur différente de 1 à prof. Et mon curseur se retrouve dans "les airs" et "le vide" -> la profondeur est erronée

2. problème de réaffichage car mon curseur (une croix) grandit quand je le déplace

Ces 2 phénomènes se produisent UNIQUEMENT quand je déplace mon curseur lentement (molette préssée+déplacement lent).

Comme vous l'avez surement devinez je travail sur un code qui n'est pas de moi, et je suis en train d'apprendre OpenGl sur le tas. Je n'ai donc que les connaissances de bases en la matière et encore , mais je suis en train d'y remédier.

Merci d'avance pour ceux qui prendront le temps de répondre

[shenron666]

Salut et bienvenue

pour commencer, es tu certain que le module 3D se sert des informations du tampon de profondeur pour savoir si le curseur doit coller à un objet ou non ?

pour le problème de taille, ta croix grandit toujours ? elle ne rétrécit jamais ? ce n'est pas un effet de profondeur ? (si elle se rapproche, normal qu'elle "grandit")

est-ce que tu te sert de ce module pour apprendre OpenGL ?
si oui, si tu veux mon avis, je ne suis pas certain qu'il s'agisse de la meilleure méthode, ou du moins pas la plus simple

[Mic75]

Salut shenron,
Je te remercie d'avoir répondu et aussi rapidement qui plus est.
Pour répondre à tes questions :

• es tu certain que le module 3D se sert des informations du tampon de profondeur pour savoir si le curseur doit coller à un objet ou non

-> Je n'en suis pas sûr à 100% vu mon manque de connaissance, mais juge par toi même :

Code :

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
int UnProject(GLint x, GLint y, dpoint3d *pos3d)
  {
    GLfloat prof;
    GLdouble ModelView_Matrix[16], Projection_Matrix[16];
    GLint Viewport_Matrix[4];
    int status;
 
    /* On récupe l'information de profondeur */
    glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &prof);
    if (prof == 1.0)
    {
      /* On a pointe dans le vide */
      pos3d->x = 0.0;
      pos3d->y = 0.0;
      pos3d->z = 0.0;
      status = -1;
    }
    else
    {
      /* On recupere le reste : les matrices de modele, de projection et le viewport */
      glGetDoublev(GL_MODELVIEW_MATRIX, ModelView_Matrix);
      glGetDoublev(GL_PROJECTION_MATRIX, Projection_Matrix);
      glGetIntegerv(GL_VIEWPORT, Viewport_Matrix);
 
      /* Et enfin les coordonnées 3D qui correspondent */
      gluUnProject((GLdouble)x, (GLdouble)y, (GLdouble)prof, ModelView_Matrix,
                 Projection_Matrix, Viewport_Matrix, &(pos3d->x),&(pos3d->y),&(pos3d->z));
      status = 0;
  }
  return status;
  }

D'après le RedBook , et si j'ai bien compris , GluUnProject affect à pos3d->x,y,z les coordonnées objets en fonction des coordonnées fenêtres passées en paramètre (x,y, et prof)

• ta croix grandit toujours ? elle ne rétrécit jamais ? ce n'est pas un effet de profondeur ? (si elle se rapproche, normal qu'elle "grandit")

->Concernant cette partie je peux t'assurer qu'il ne s'agit pas d'un effet de profondeur. La croix se contente de grandir, mais le "relief" n'influe pas sur sa croissance. Je le répète se phénomène ne se produit que lorsque l'on se déplace lentement.
D'autre part , tu as surement remarqué dans le code précédent qu'on vérifie si l'on pointe dans le vide ou non. Dans une autre partie du code, on décide de rendre le curseur invisible dans le cas où on pointe dans le vide.
Et bien en déplaçant lentement le curseur , on arrive a se "promener" dans le vide, j'ai donc vérifié la valeur de prof dans ces cas là et bien évidemment elle est différente de 1,donc la profondeur calculée est fausse, d'ou mon rapprochement avec le tampon de profondeur.
Autre bizarrerie : dans le code la taille de la croix est constante et rien dans la façon dont elle est créée ne laisse présager un changement de taille, c'est pour cette raison que je pense à un problème de réactualisation de l'affichage.

• est-ce que tu te sert de ce module pour apprendre OpenGL?

Non, je ne me sers pas de ce module pour apprendre openGl, j'essaie de me documenter et suivre des tutos en parallèle.
Cependant que fais tu du viel adage qui dit que c'est en forgeant qu'on devient forgeron. C'est sûr que c'est de loin pas la méthode la plus facile pour apprendre, étant donné qu'il s'agit d'un code d'autres développeurs chevronnés, par ailleurs il s'agit de mon projet de stage de DUT,je prend donc des risques, mais c'est également une source motivation importante.

Toujours est-il que je te remercie d'avoir montré un intérêt à mon problème et je reste attentif à toutes les suggestions.

[shenron666]

Code :

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

if (prof == 1.0)

Ce genre de test, je n'aime pas trop, un test d'égalité de variable flotante c'est relativement imprécis, le code est de toi ?
j'imagine que non d'après ce que tu disais avant, cela doit faire partie du module 3D en question
je préfère dans ces cas là tester une valeur supérieure ou égale avec un epsilon, autant que possible, ça évite des erreurs de précision

en tout cas, c'est certain que seul le tampon de profondeur est utilisé pour le test

pour le changement de taille du curseur, si le Z est bien la coordonnée indiquant l'éloignement, celui-ci est-il constant ?
la croix est dessinée en mode orthogonal ou en mode projection ? (gluOrtho2D ou gluPerspective ?)

[Mic75]

Ce genre de test, je n'aime pas trop, un test d'égalité de variable flotante c'est relativement imprécis, le code est de toi ?
je préfère dans ces cas là tester une valeur supérieure ou égale avec un epsilon, autant que possible, ça évite des erreurs de précision

En effet le code n'est pas de moi, par contre je ne vois pas trop ou tu veux en venir concernant le test de la profondeur. On ne s'intéresse ici qu'au cas ou l'on pointe dans le vide , donc celle ci doit être maximale ( i.e égal à 1.0). Or il se trouve, que ce test marche en "point par point", c'est a dire lorqu'on est ne se déplace pas lentement avec la mollette enfonçée, mais qu'on effectue un simple clic.
Je persiste à penser qu'il s'agit d'un problème de réactualisation d'un tampon ou je ne sais trop quoi, car le fait de déplacer le curseur en gardant la molette enfoncée génère beaucoup d'appels à la fonction contenant le code que je t'ai fournit (autant qu'il ya de points concernés). Si ça te parait confus, n"hésite pas à me reprendre, il est possible que je sois en train de dire n'importe quoi

pour le changement de taille du curseur, si le Z est bien la coordonnée indiquant l'éloignement, celui-ci est-il constant ?
la croix est dessinée en mode orthogonal ou en mode projection ? (gluOrtho2D ou gluPerspective ?)

Comme tu peux le voire ci dessous , pour dessiner le curseur, on se base sur ses coordonnées dans l'espace , et d'une taille constante size_p. Je ne comprend pas l'origine de ce changement de taille.

Code :

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
float size_p = 0.05 ;
      float x_p = scene->x_pointeur;
      float y_p = scene->y_pointeur;
      float z_p = scene->z_pointeur;
      glDisable(GL_LIGHTING);
      glLineWidth(2.0);
      glColor3f(0.0, 0.2, 1.0);
      glBegin(GL_LINES);
      glVertex3f(x_p - size_p, y_p - size_p, z_p + size_p);
      glVertex3f(x_p + size_p, y_p + size_p, z_p - size_p);
      glVertex3f(x_p - size_p, y_p + size_p, z_p - size_p);
      glVertex3f(x_p + size_p, y_p - size_p, z_p + size_p);
      glVertex3f(x_p - size_p, y_p - size_p, z_p - size_p);
      glVertex3f(x_p + size_p, y_p + size_p, z_p + size_p);
      glVertex3f(x_p - size_p, y_p + size_p, z_p + size_p);
      glVertex3f(x_p + size_p, y_p - size_p, z_p - size_p);
      glEnd();

Pour répondre à ta dernière question , tous les objets sont dessinés en mode projection, enfin il me semble...

[shenron666]

ok j'ai peut-etre une idée d'où peut venir ton problème :
lorsque tu dessines ta croix, tu écris des infos dans le zbuffer, et donc tu modifies le z
essaies de désactiver l'écriture dans le zbuffer lorsque tu dessines ta croix pour voir (avec glDepthMask(0) je crois)

pour ce qui est du problème de taille, tu dessines ta croix en perspective et avec des coordonnées spaciales, si ton z_p change (la croix se rapproche de toi par exemple) elle grandira, l'effet de perspective, plus un objet se rapproche plus il grandit

[Mic75]

Une fois encore, merci pour tes suggestions.
Cependant, le fait d'avoir désactiver l'écriture dans le z-buffer n'arrange pas les choses. Mon curseur disparait , et mon objet acquiere un genre de transparence : on peut voire les faces arrières et la texture a un aspect de "dentelles"

pour ce qui est du problème de taille, tu dessines ta croix en perspective et avec des coordonnées spaciales, si ton z_p change (la croix se rapproche de toi par exemple) elle grandira, l'effet de perspective, plus un objet se rapproche plus il grandit

Je pense ne pas t'avoir assez donné de détails concernant les problèmes de tailles du curseur, car je peux t'assurer qu'ils n'ont rien a voir avec la perspective.
En fet, ma croix change de taille quand je garde la molette enfoncée et que je déplace la souris en même temps. Si tu veux, la croix suit les mouvement de la souris. Le problème est, que quand je déplace ma souris lentement, a ce moment la croix grandit en taille, sans tenir compte de la profondeur.
Preuve en est, en déplaçant ma croix de cette façon, je peux me déplacer dans le vide, chose théoriquement impossible d'après :

Code :

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

1
2
3
4
5
6
7
8
9
10
 /* On récupe l'information de profondeur */
    glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &prof);
    if (prof == 1.0)
    {
      /* On a pointe dans le vide */
      pos3d->x = 0.0;
      pos3d->y = 0.0;
      pos3d->z = 0.0;
      status = -1;
    }

de la fonction UnProject décris précédemment. L'erreur se situe au niveau de glReadPixel, mais je pense que cela est liée au paramètre GL_DEPTH_COMPONENT. Qu'en penses tu ?

Je pense qu'il te manque surement des informations pour bien saisir le problème, n'hésite pas à demander.
Dans tous les cas merci pour ta patience

[Mic75]

Bon, je reformule un peu le problème, après l'avoir étudier plus en détail.
En fait, il s'agit d'un problème de récupération de coordonnée d'un point cliqué :
Quand je clique sur mon objet (une fois), les coordonnées renvoyées sont correctes, étant donné que mon curseur se place au bon endroit (il colle à la surface).

Maintenant, je clique juste à coté (tout petit déplacement) et bien la, la valeur de la profondeur n'est pas correcte, ce qui induit le fait que je peux positionner mon curseur dans le vide.
En fait ce problème est du à glReadPixel, et une histoire de tampon de profondeur, mais ça dépasse de loin mais faible compétence, et c'est la que je besoin que quelqu'un vienne a mon secours.

[shenron666]

tu pourrais nous montrer :

-le code de ta routine d'affichage
-la portion de code qui fait appel à la récupération des coordonnées du clic souris
-l'appel de l'affichage du curseur

ce era peut-etre plus clair

[Mic75]

Euh pour la routine d'affichage ça risque d'être un peu long quand même, il y a environ 300 lignes. Précise moi la portion qui serait suceptible de t'aider.

Pour la récupe du clique de souris ça se passe de cette façon, si on détecte un mouvement de la souris alors on teste quel bouton est pressé, en l'occurence ce qui nous interesse c'est cette portion du code je pense :

Code :

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

1
2
3
4
5
6
7
8
gint Visu3d_GlArea::motion_notify_event_impl(GdkEventMotion* event)
{
 
  //Mode de pointage
  if(button_pressed ==2) 
  {
      MiddleButtonPressed(event->x, event->y, true);
  }

sachant que la classe VIsu3d_GlArea, hérite de GTK_glArea et qu'il s'agit d'un widget permettant de coupler OpenGl à GTK (pour ce que j'ai compris).

Et donc la gestion du clique sur la molette se passe dans la fonction MiddleButtonPressed que voici (allégée pour se concentrer sur la partie qui nous intéresse) :

Code :

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
void Visu3d_GlArea::MiddleButtonPressed(float event_x, float event_y, bool motion)
{
  dpoint3d pos3d;
  double pos_mri_x, pos_mri_y, pos_mri_z;
 
  if (UnProject((GLint)event_x, (GLint)height() - (GLint)event_y -1, &pos3d) != 0){
    // On a pointe dans le vide donc on affiche pas le curseur
    if (m_scene->mode_pointage == CROIX || POINTEUR_COUPE){
      m_scene->pointeur = FALSE;
      m_scene->up_to_date_gche = FALSE;
      m_scene->up_to_date_dte = FALSE;
    }
} 
....
//on affecte les bonnes coordonnées à la croix
switch (m_scene->mode_pointage){
      case CROIX :
    m_scene->pointeur = TRUE;
    m_scene->x_pointeur = pos3d.x;
    m_scene->y_pointeur = pos3d.y;
    m_scene->z_pointeur = pos3d.z;
    m_scene->up_to_date_gche = FALSE;
    m_scene->up_to_date_dte = FALSE;
    if (m_scene->tala_hires_old == TRUE) m_scene->tala_hires = TRUE;
    break;
....
  m_parent->RefreshGL();
 
  last_y=event_y;
  last_x=event_x;
}

UnProject a déjà été décrit précédemment, c'est elle qui se charge de calculer à proprement parler la position de mon curseur dans la scène 3D.

Par ailleurs on dessine le curseur dans la routine d'affichage en fesant un test sur ma_scene->pointeur :

Code :

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
if (scene->pointeur == TRUE)
    {
      float size_p = 0.05 ;
      float x_p = scene->x_pointeur;
      float y_p = scene->y_pointeur;
      float z_p = scene->z_pointeur;
      glDisable(GL_LIGHTING);
      glLineWidth(2.0);
      glColor3f(0.0, 0.2, 1.0);
      glBegin(GL_LINES);
      glVertex3f(x_p - size_p, y_p - size_p, z_p + size_p);
      glVertex3f(x_p + size_p, y_p + size_p, z_p - size_p);
      glVertex3f(x_p - size_p, y_p + size_p, z_p - size_p);
      glVertex3f(x_p + size_p, y_p - size_p, z_p + size_p);
      glVertex3f(x_p - size_p, y_p - size_p, z_p - size_p);
      glVertex3f(x_p + size_p, y_p + size_p, z_p + size_p);
      glVertex3f(x_p - size_p, y_p + size_p, z_p + size_p);
      glVertex3f(x_p + size_p, y_p - size_p, z_p - size_p);
      glEnd();

Voilà j'espère que c'est un peu plus claire.

[shenron666]

Euh pour la routine d'affichage ça risque d'être un peu long quand même, il y a environ 300 lignes. Précise moi la portion qui serait suceptible de t'aider.

En fait, ce qui m'intéresse dans ta procédure d'affichage, c'est l'ordre dans lequel tu traites l'affichage, la récupération de l'information "position du clic" et le dessin du curseur

et en me montrant ta fonction

Code :

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

gint Visu3d_GlArea::motion_notify_event_impl(GdkEventMotion* event)

j'imagine le problème où la fonction

Code :

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

MiddleButtonPressed(event->x, event->y, true);

dans laquelles tu appeles du code OpenGL soit exécutée avant la fin complète de ton dessin

il faudrait que dans la fonction motion_notify_event_impl tu récupères l'information de position de la souris et d'état du (ou des) boutons et que tu fasses l'appel à UnProject dans ta boucle d'affichage, avant l'affichage de ton curseur

[Mic75]

il faudrait que dans la fonction motion_notify_event_impl tu récupères l'information de position de la souris et d'état du (ou des) boutons et que tu fasses l'appel à UnProject dans ta boucle d'affichage, avant l'affichage de ton curseur

Mais c'est ce qui se passe en fait. Dans un premier temps motion_notify_event_impl détecte le mouvement de la souris et récupère les nouvelles coordonnées x et y, elles les passent ensuite à MiddleButtonPressed si la molette est enfoncée, qui appelle UnProject pour calculer les coordonnées de mon curseur dans ma scène 3d.

Puis on appelle la procédure d'affichage à la fin de MiddleButtonPressed, donc on récupère déjà les infos de la position de la souris avant l'affichage du curseur.
Ou alors j'ai rien compris et je dis n'importe quoi, et dans ce cas je m'en excuse.

[shenron666]

je suis d'accord, tu récupères les informations de position de la souris avant d'afficher le curseur, sinon il ne serait pas au bon endroit

le problème auquel je pense est que tu récupères également les informations de position de la souris avant la fin de la procédure d'affichage, si un swapbuffer est arrivé tu ne sais pas ce qu'il y a dans tes buffers

hors ta fonction qui gère les évévnements de la souris effectue un appel à glReadPixels sur le zbuffer au mauvais moment (je pense)

si ta fonction motion_notify_event_impl mémorisait les infos nécessaires genre

Code :

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

1
2
int mouse_x, mous_y;
bool button_pressed;

et que ta fontion de dessin faisait (en pseudo code) :

Code :

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

1
2
3
4
-affichage de la scène
-si button_pressed=true alors > récupération des infos curseur
-si on doit afficher le curseur alors > affichage du curseur
-swap des buffers

le problème ne devrait pas se poser

[Mic75]

A vrai dire je ne te suis pas vraiment. Si il y avait effectivement un problème au niveau du swapbuffer, le problème de profondeur se posera à chaque clique et nimporte ou dans la scène.
Or celui ci ne survient en fait que dans le cas ou je clique juste à coté de l'ancienne position.
Si maintenant je clique sur l'objet , mais à un endroit éloigné du premier clique, il n'y aura aucun problème au niveau de la profondeur.
Comment explique tu ça ?

[shenron666]

Comme je l'ai dit précédemment :

le problème auquel je pense est que tu récupères également les informations de position de la souris avant la fin de la procédure d'affichage, si un swapbuffer est arrivé tu ne sais pas ce qu'il y a dans tes buffers

c'est soit une coincidence soit le problème ne se situe pas là
le fait de rester appuyé sur le bouton et de bouger la souris génère des événements plus fréquents

[Mic75]

Bonjour Shenron,
Et bien en fait dans l'un des messages précédents je précise bien que finalement le problème n'est pas lié au mouvement de la souris en même temps que le clique.

En effet si je procède clique par clique, en cliquant à des positions successives très proches les unes des autres le problème apparait également.
Par exemple si je suis au bord et qu'en suite je clique juste à coté, mais dans "le vide", mon curseur s'affiche, et la valeur de prof est quasiment identique à la précédente, une variation de l'ordre d'un millième, alors qu'elle devrait prendre la valeur 1

[shenron666]

il y a une chose que tu pourrais faire pour tester
c'est récupérer le zbuffer entier avant d'utiliser UnProject :

Code :

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

1
2
GL_FLOAT* buffer = new GL_FLOAT[taille_ecran_x * taille_ecran_y];
glReadPixels(0, 0, taille_ecran_x, taille_ecran_y, GL_DEPTH_COMPONENT, GL_FLOAT, buffer);

et le convertir en image en niveaux de gris afin de voir ce qu'il contient réellement
note: je ne sais pas si en mettant GL_UNSIGNED_BYTE à la place de GL_FLOAT dans le glReadPixels tu ne récupères pas les infos en intervale [0,255] ce qui serait polus facile pour exporter l'image

[Mic75]

Euuh comment on fait au juste ?

[shenron666]

le code que j'ai mis alloue un bloc en mémoire pour stocker le zbuffer (1ère ligne)
puis récupère le zbuffer (2ème ligne) dans le bloc
il faut que tu remplaces "taille_ecran_x" et "taille_ecran_y" par les dimension x et y de ta surface OpenGL

ensuite tu convertis le contenu récupéré en valeur [0-255] en multipliant chaque pixel par 255 tout simplement vu que ce sont des valeurs [0-1]

les valeurs [0-255] tu les stocke dans un autre buffer de type "unsigned char" par exemple et tu balances ce buffer dans un fichier
alors ou bien tu as une bibliothèque pour écrire un fichier image, ou tu l'écris en raw (en brut) si tu as un logiciel pour lire le raw bien entendu

[Mic75]

Merci encore une fois shenron pour tes propositions.
Je pense quand même que je vais tenter une autres approche. Jusqu'à maintenant j'essayer de réutiliser l'existant pour récupérer les coordonnées spatiales de mon curseur, notemment avec le glReadPixel qui semble poser problème.
Ma question est la suivante :
Comment récupérer les coordonnées spatiales d'un point d'après la position de la souris au moment du clic ?