Discussion :

[DebutantOpenGL]

Bonjour,

Comme l'indique mon pseudo, je suis debutant sur opengl.

Cela fait trois semaines que je me bats pour retrouver les vertices qui constituent le contour de mon modele 3D (en mouvement). Le programme sur lequel je travaille se base sur le code source disponible sur http://www.sgi.com/products/software...e/silhouette.c
Mais le modele 3D est different.

Donc d'abord je trace le contour en utilisant le stencil buffer. Tout va bien jusque la.

Pour retrouver les vertices sur la silhouette. Voici ma demarche tres certainement naive a defaut d'avoir trouve mieux :
1. Stockage la carte de profondeur avec glReadPixels.
2. Stockage des coordonnees des pixels constituant le contour.
3. "Deprojeter" avec gluUnProject() pour retrouver les "world coordinates" des pixels du contour.
4. A partir des "object coordinates" des vertices de mon modele, retrouver les "world coords" de mes vertices en multipliant par la matrice MODELVIEW.
5. Connaissant maintenant les "world coords" de mes pixels, rechercher le vertex le plus proche par un critere de distance euclidienne par exemple.

Theoriquement je pense que cela pourrait marcher, ce n'est pas le cas malheureusement.
Les etapes 1,2 se sont bien passees a mon avis.
L'etape 3 pose deja probleme lorsque je redessine les world coordinates des pixels, je m'apercois qu'il manque des parties de ma silhouette. C'est inquietant...

Les etapes 4 et 5 sont catastrophiques, il y a beaucoup trop de vertices ne sont meme pas sur le contour ! Effectivement en affichant les distances minimales calculees , j'obtiens des valeurs aberrantes. Les coordonnes de mes pixels deprojetes ne sont pas du tout proches de meme des vertices. (l'ordre de grandeur des valeurs reste correcte mais pas pour le depth buffer.)

D'ou ma question : gluUnProject() est-il vraiment la panacee ?
Ou est l'erreur dans ma demarche ? Sachant que malgre mon debuggage, je ne sais pas ou est l'erreur.
J'ai tente de changer la position de la camera pour l'eloigner raisonnablement du near plane, de bien coincer mon modele entre mon near Plane et mon far plane pour bien repartir les valeurs du depth buffer des points visibles.
Rien n'y fait. Je suis desespere.
L'approche que j'ai tente ne me semble donc pas bonne.

J'ai tente une autre approche egalement infructueuse (trop lente et on ne voit rien !) mais on tourne toujours autour du pot :
1. Stockage la carte de profondeur avec glReadPixels.
2. Stockage des coordonnees des pixels constituant le contour.
3. A partir des "object coordinates" des vertices de mon modele, retrouver les "world coords" de mes vertices en multipliant par la matrice MODELVIEW.
4. Projeter les "world coords" de mes vertices avec gluProject() pour retrouver les "screen coordinates" des vertices du contour.
5. Connaissant maintenant les "world coords" de mes pixels, rechercher le vertex le plus proche par un critere de distance euclidienne par exemple.

Bref je soupconne, entre autres, la precision du depth buffer. Mais comment y remedier : la faq d'opengl ne me dit pas grand chose. J'ai google partout sans succes.

Donc je voudrais avoir une discussion et les critiques sont bienvenues. (Et surtout si vous avez d'autres methodes !)
Merci,
David.

[raptor70]

Si je comprend bien, tu essayes de récupérer les bords de ton modèle 3D, certainement pour un rendu cell-shading.

Dans ton étape 5, tu dis que tu calcules tes distances euclidiènes ... par rapport à quoi ? (1ere méthode)

As tu des screenshots de tes rendus problématiques ?

[DebutantOpenGL]

J'ai ete deconnecte pendant que je redigeais le message...

Tres succinctement, pour chaque pixel deprojete par gluUnProject, je recherche le vertex qui minimise la distance euclidienne par rapport a ce point.

Je redigerai un bout de code quand j'aurai le temps et je n'ai pas de screenshots (ca va etre difficile a en faire, j'ai rendu le mini projet a mon superviseur.)

Bref je suis desole de ne pas avoir fait avance la discussion plus que ca.

David.

[TanEk]

4. A partir des "object coordinates" des vertices de mon modele, retrouver les "world coords" de mes vertices en multipliant par la matrice MODELVIEW.
5. Connaissant maintenant les "world coords" de mes pixels, rechercher le vertex le plus proche par un critere de distance euclidienne par exemple.

Je ne sais pas si j'ai suivi mais tu ne dois pas multiplier les vertices de ton modèle par la modelview. Tu dois les multiplier par la matrice de transformation qui te fait passer de ton repère objet au repère monde si ton repère objet est différent de ton repère monde.

En effet gluUnproject te fais passer du repère viewport au repère monde. Quand tu multiplies un vertice par la modelView tu passes du repère monde au repère caméra.

[LeGreg]

Pour l'extraction de silhouette il y a des méthodes géométriques plus ou moins compliquées.

Par exemple dans ce papier ils prétendent avoir une méthode très rapide d'extraction de silhouette (indépendante de leur algorithme de silhouette clipping) :
http://www.cse.ust.hk/~psander/docs/silclip.pdf

/HS
désolé c'est hors sujet mais ça m'a fait sourire :

je n'ai pas de screenshots (ca va etre difficile a en faire, j'ai rendu le mini projet a mon superviseur.)

LeGreg

[acx01b]

salut t'as divisé par W ?

gluunproject te donne v = (x,y,z,w) toi ce qui t'intéresse c'est
v' = (x/w,y/w,z/w,1)

[acx01b]

oui pour revenir sur les matrices je ferais comme ça:

O : matrice de passe object -> world
M : matrice de passage world -> eye
Proj : matrice de passage eye -> screen
ModelView: matrice de passage object -> eye = M x O

- tu dessines ton objet en multipliant tes vertices par Proj x ModelView
- tu "unproject" en multipliant par inv(Proj x ModelView)
- tu obtiens des vertices en coordonnées object
que tu compares avec la distance euclidienne à tes vertices en coordonnées object de départ