Salut,
je vais vous expliquer mon problème.
 
C'est de l'open gl comme le dit le titre.
Dans ma fenetre openg gl j'ai une sphere. Je connais les coordonée de son centre et son rayon par rapport à son repere local. Il faut que je calcule la surface projetée sur l'écran de cette sphere.
 
Pour cela il me faut connaitre les coordonnée du repere local de la sphère dans le repere absolu. Mon idée était la suivante:
Au début le repere local de la sphere est au centre de ma fenetre opengl. Puis je fais des rotations et des translations sur ce repere. Je pensais récupérer la matrice GL_MODEL_VIEW et multiplier la position de début du repere par cette matrice.  
 
Le problème est que cette méthode me donne des résultats bizzares dès que je fais une rotation.
 
Ensuite une fois que j'aurais les coordonnée de ce point je pourrais calculer la distance avec le point d'origine et avec cela caluler la surface de projection de la sphère.
 
Si il y a une méthode plus simple je suis preneur, peut etre un truc avec la matrice de projection.
 
J'espère que j'ai été assez clair je sais que mon pb est un peu chaud mais j'espère qu'il y a une méthode simple pour le résoudre
 
merci de me répondre

pas tout (rien ?) compris. tu mélangerais pas un peu les repères ?
 
'les coordonnées du centre de la sphère et de son rayon par rapport à son repère local' ... hein ? sauf si tu as l'esprit vraiment tordu ou que tu utilises un pivot, le centre de la sphère dans son repère local est (0, 0, 0), quant à la 'coordonnée du rayon' ... hein (bis) ?  
 
tu as  
* la matrice de l'objet qui le transforme dans le repère world
* la matrice 'view' qui transforme le world dans le repère caméra
* la matrice projection qui transforme le repère caméra en coordonnées écran
 
matriceobjet * matrice view = GL_MODELVIEW (passage repère local -> repère caméra)
matrice projection = GL_PROJECTION (passage repère caméra -> repère écran)
matriceobjet * matrive view * matrice projection = GLMODELVIEW * GL_PROJECTION (passage repère local -> repère caméra, on va l'appeler localToScreen)
 
pour calculer la surface de projection, on va prendre son rayon : centre de la sphère transformé en repère écran (p1) - point situé sur la sphère en repère écran (p2).
 
pour calculer les coordonnées du centre projeté (p1), tu multiplies le centre de ta sphère dans ton repère local (qui devrait être (0, 0, 0)) par localToScreen.
 
pour calculer l'autre point (p2), on transforme le centre avec GL_MODELVIEW, puis on rajoute à cette coordonnée un delta de manière à le situer sur la sphère (rayon, 0, 0). ensuite, transformation de ce point par la matrice de projection.
 
puis surface = pi * (p2-p1)²
 
ATTENTION, ça ne donne pas la surface de la sphère projetée, mais la surface du disque tourné vers la caméra, comme un billboard en fait. enfin je suppose que c'est ce que tu veux obtenir, car sinon c'est un peu plus compliqué (et là je peux pas t'aider )

[citation][nom]youdontcare a écrit[/nom]pas tout (rien ?) compris. tu mélangerais pas un peu les repères ?
 
Je te remercie vraiment pour ton message c'est méchament plus clair maintenant.
 
Bon en fait mon objet est un ensemble de sphère. Donc le centre de mon repère local n'est pas le centre de ma sphère.  
Sinon là dans le message que tu m'as écris tu travailles avec des coordonnées cartésiennes. Or les matrices MODELVIEW et PROJECTION sont des matrices 4*4. Donc je pense qu'il faudrait travailler avec des coordonées homogènes. Si je ne me trompes pour passer en coordonées homogènes il suffit de mettre un 1 en quatrième coordonées.
 
L'erreur que je faisais c'est que je multipliais la position à l'écran par la matrice MODELVIEW en espèrant retrouver ses coordonées dans le repère caméra. Enfin j'étais un peu pomé quoi.
 
 
pour calculer les coordonnées du centre projeté (p1), tu multiplies le centre de ta sphère dans ton repère local (qui devrait être (0, 0, 0)) par localToScreen.  
 
Ouais c'est ici pour les coordonées homogènes. Je pense donc qu'il faut rajouter un 1.
 
 
ATTENTION, ça ne donne pas la surface de la sphère projetée, mais la surface du disque tourné vers la caméra, comme un billboard en fait. enfin je suppose que c'est ce que tu veux obtenir, car sinon c'est un peu plus compliqué (et là je peux pas t'aider )
 
Ouais c'est bien ce que je veux obtenir. De toute façon je ne pense pas qu'il y est de différence entre la sphère projetée et la surface du disque tourné vers la caméra pour une sphère totalement ronde.
 
Merci encore à toi et si tu réponds à mon pb sur les coordonnées homogènes je pense que j'en aurais fini pour les questions
 
A+

[edit]--Message édité par spockykiller--[/edit]

hein (bis bis) ?
 
les coordonnées homogènes sont elles aussi des coordonnées cartésiennes : elles sont exprimés suivant le repère que tout le monde connaît ( (x, y), (x, y, z), bref avec les axes perpendiculaires les uns aux autres), par opposition (par ex) aux coordonnées sphériques ou cylindriques.
 
pour les coordonnées homogènes, le quatrième terme est effectivement toujours 1 tant que tu fais de l'algèbre linéaire (cad des transformations réversibles, comme la translation, la rotation, le scaling, le mirror, etc).
 
donc ton point est toujours de la forme (x, y, z, 1). tu peux donc faire une classe Matrix44 (pour des transformations homogènes) qui prend en paramètre pour l'opérateur multiplication un Point3 (x, y, z) et qui retourne un autre Point3. tu peux ainsi exprimer n'importe quel point(x, y, z) dans n'importe quel repère linéaire (et ici, exprimer n'importe quel point de ton objet dans le repère world ou caméra).
 
pour la projection, tu as raison : c'est ici qu'on utilise vraiment les coordonnées homogènes (ou w sert enfin à qq chose ) tu peux te faire une ptite fonction Project() qui prend en paramètre un Point3, une Matrix44, et qui retourne un Point4 (les coordonnées écran) :

en passant à cette fonction un point d'un objet dans son repère local, ainsi que sa matrice localToScreen, tu obtiendras ses coordonnées écran. ne la copie colle pas brut de pomme, peut être utilises tu l'autre sens pour la multiplication des matrices. les quatre premières lignes peuvent être résumées à h = p * m si tu fais un opérateur qui retourne un Point4 dans ta classe Matrix44.
 
pour tes sphères, tu peux faire une hiérarchie de sphères ayant toutes un parent commun, histoire d'avoir (0, 0, 0) pour le centre sinon tu bidouilles avant de faire ton calcul (pas bô ). enfin, fais déjà marcher ton truc, ensuite je t'encouragerais à faire un système bien souple avec un jolie hiérarchie et des jolies classes Point3, Point4, etc ... tu peux mater la sdk de max pour voir les headers de leurs classes, y'a des sources dans directx, également plein de trucs sur le net.  
 
si ça peut paraître chiant et compliqué au début, une fois que tu as des classes bien clean et que tu peux exprimer tes points dans n'importe quel repère, ça devient tout de suite compréhensible.
 
ah, et la surface de la sphère n'est égale à la surface du disque seulement lorsque la sphère est située juste devant la caméra ( position sphère = (0, 0, z) dans le repère caméra), à cause de la déformation dûe à la perspective. et encore il faut que la sphère ne soit pas trop proche c'est juste vrai pour les vues isométriques, où, justement, il n'y a pas de 'projection', on gicle juste une coordonnée). enfin ça c'était juste histoire d'être précis