conversion opengl -> povray

Voila, je veux "convertir" une scene creer avec opengl/glut en C en script povray.
Je coince au niveau de l'orientation et position de la camera dans povray.

Dans le code C, je peux obtenir la matrice modelview qui contient en principe toutes les informations de rotation, translation de la scene:

Code:

---

1 2 3

float modelview[16]; glGetFloatv(GL_MODELVIEW_MATRIX, modelview);

---

Par example, apres quelques rotations, j'obtient la matrice suivante:

Code:

---

1 2 3 4 5 6

modelview matrix: a1=0.484810 a5=0.000000 a9=-0.874620 a13=0.000000 a2=-0.383408 a6=0.898794 a10=-0.212527 a14=0.000000 a3=0.786103 a7=0.438371 a11=0.435744 a15=-6.000000 a4=0.000000 a8=0.000000 a12=0.000000 a16=1.000000

---

Pour convertir en povray, il faut avoir les vecteurs, location, direction, right et up:

Code:

---

1 2 3 4 5 6 7

camera{ perspective location <x,y,z> direction <x,y,z> right <x,y,z> up <x,y,z> }

---

Je'ai cru comprendre que:

Code:

---

1 2 3 4 5

right = <a1,a2,a3> up = <a5,a6,a7> direction = <a9,a10,a11> location = <a13,a14,a15>

---

mais si je lance povray avec ca, j'obtient cette erreur:

Code:

---

1 2	Creating vista buffer.Slab Building Error: Cannot use non-perpendicular camera vectors with vista buffer.

---

En verifiant a la main, Les vecteurs <a1,a2,a3> et <a5,a6,a7> sont perpendiculaires, ainsi que <a5,a6,a7> et <a9,a10,a11>. Les autres sont non-perpendiculaires....

une idee ?

merci d'avance

Dave

tu as bon pour location, mais le reste il faut que tu le calcules

si tu pouvais modifier ton application pour utiliser gluLookAt à la place, ça te simplifirait la vie pour faire la transition

Inverse le sens du vecteur direction (prend -a9, -a10, -a11) voir.... C'est peut-être une histoire de repère direct/indirect.

Citation:

---

TanEk: Inverse le sens du vecteur direction (prend -a9, -a10, -a11) voir.... C'est peut-être une histoire de repère direct/indirect.

---

Nan, ca change rien, meme erreur.

Citation:

---

fgjdfgjdgj: tu as bon pour location, mais le reste il faut que tu le calcules

---

et comment on fait ca ?

Citation:

---

fgjdfgjdgj: si tu pouvais modifier ton application pour utiliser gluLookAt à la place, ça te simplifirait la vie pour faire la transition

---

Pour une scene statique peut-etre, mais j'ai une scene dynamique ou l'orientation de la scene change constament par des rotations donnees par les mouvements de la souris
L'idee est de trouver une bonne orientation en utilisant le code C/opengl et faire un ray-trace avec povray pour avoir une bonne resolution.

À vrai dire je ne connais pas l'historique de ton projet donc je suis probablement à côté de la plaque, mais povray et opengl me semblent deux api distinctes donc je ne sais pas pourquoi tu veux absolument faire le lien entre les deux ? tu essaies de faire un wrapper d'applications existantes ? autre chose ?

Si tu as un format de scène bien construit et documenté, ne serait-il pas plus simple de voir comment le convertir au format PovRay (avec un cout d'oeil aux tutoriaux pour comprendre ce à quoi sert chaque paramètre passé à povray) ? Bref comprendre les matrices de transformation, les objets camera de povray, etc. ce serait beaucoup plus instructif et probablement plus simple que la situation actuelle.

LeGreg

Chez moi ils sont tous orthogonaux :

Code:

---

1 2 3 4 5 6 7 8

Vector3d right = new Vector3d(0.484810,-0.383408,0.786103); Vector3d up = new Vector3d(0.000000,0.898794,0.438371); Vector3d direction = new Vector3d(-0.874620,-0.212527,0.435744);   System.out.println("test1 : " + right.dot(up)); System.out.println("test2 : " + right.dot(direction)); System.out.println("test3 : " + direction.dot(up));

---

Donne comme résultat :

Citation:

---

test1 : -5.173899997323872E-8
test2 : -3.045519999522739E-7
test3 : -4.594139999813951E-7

---

Comme la précision des chiffres est de E-6 il est normal de trouver un dot aux environs de E-7 ou E-8 encore ça veut dire 0 donc les 3 vecteurs sont bien orthogonaux entre eux. A mon avis c'est juste une histoire de précision... PovRay doit bosser en double et tu lui envoies une précision en flottant alors forcément lui il aime pas... Il faut que tu retrouves un vecteur en double perpendiculaire de telle sorte qu'il soit le plus prêt possible de la valeur en flottant... Tu résoudras ça par une méthode des moindres carrés. Ou y'a peut-être plus simple...

J'ai trouvé une solution. Bon posons X(Xx,Xy,Xz),Y(Yx,Yy,Yz),Z(Zx,Zy,Zz) les vecteurs de ta matrice. Tu as :

Code:

---

1 2 3

right = X up = Y direction = -Z (j'insiste)

---

Bon maintenant on va faire tous les calculs qui suivent en précision double. Tu vas retrouver Z(x,y,z) en résolvant ce système

x * Xx + y * Xy + z * Xz = 0 (1) // Ca veut dire que Z perp X
x * Yx + y * Yy + z * Yz = 0 (2) // Ca veut dire que Z perp Y

Deux équations trois inconnues donc pas de solution unique donc tu vas trouver Z = k * (x,y,z) et tu sais que k = 1 / norm(x,y,z) car Z doit être normé. Donc tu as Z perpendiculaire à X et Y avec une précision en double.

Voici le système résolu :

Citation:

---

Si Xz != 0 :
(1) <=> z = - x * Xx / Xz - y * Xy / Xz
donc on remplace z pas ça dans (2) :
x * Yx + y * Yy - x * Xx / Xz - y * Xy / Xz = 0 <=>
x * (Xz * Yx - Xx) / Xz = y * (Xy - Yy * Xz) / Xz <=>
x = y * (Xy - Yy * Xz) / (Xz * Yx - Xx) = y * A
On remplace x par ça dans (1) modifié on obtient :
z = y * A - y * Xy / Xz = y * (A * Xz - Xy) / Xz = y * B

et on doit avoir sqrt(x * x + y * y + z * z) = 1 <=>
sqrt(y*y*A*A + y*y + y * y * B * B) = 1 <=>
abs(y) * sqrt(A*A + 1 + B * B) = 1 <=>
abs(y) = 1 / sqrt(A* A + 1 + B * B)
Donc on prend Z tel que :
y = 1 / sqrt(A* A + 1 + B * B)
x = y * A
z = y * B
Fin si

Si Xz == 0 :
(1) <=> x * Xx + y * Xy = 0 <=> x = - y * Xy / Xx = - y * C
Si Yz != 0 :
On remplace x par ça dans (2) :
- y * C * Yx + y * Yy + z * Yz = 0 <=>
z = y * (C * Yx - Yy) / Yz = y * D
or norm(Z) = 1 <=> abs(y) = 1 / sqrt(C*C + 1 + D * D)
Donc on prend Z tel que :
y = 1 / sqrt(C*C + 1 + D*D)
x = - y * C
z = y * D
Sinon si Yz == 0 :
On a (2) <=> x * Yx + y * Yy = 0 et x = - y * C
<=> - y * C * Yx + y * Yy = 0 <=> y * E = 0 => y = 0 ou y appartient aux réels
Pour gérer ça on peut se dire qu'il n'y a aucune contrainte sur z donc z appartient aussi aux réels mais on doit avoir norm(Z) = 1 donc si on prend y = 0 on doit avoir z = 1 Donc dans tous les cas on a :
Z = (0, 0, 1)
Fin si

---

Seulement X et Y ne sont pas perpendiculaires entre eux en double précision. Qu'à cela ne tienne on sait que par définition X = Y^Z (produit vectoriel de Y et Z). Donc tu calcules X avec cette formule et tu auras X perp Y perp Z en double précision et ça devrait marcher sur povray.

Voilou ;).

Edit : j'ai simplifié l'algo...

Merci pour ta solution !! J'ai refais les calcules aussi et je suis arrive au meme point... mais j'ai trouve beaucoup plus simple: comment l'avait suggerer fgjdfgjdgj, j'ai modifier mon appli pour utiliser gluLookAt et tout devient super simple

Code:

---

1 2 3 4 5 6 7 8 9 10

gluPerspective (view_angle,aspect_ratio,near_clip,far_clip);   gluLookAt(cam_pos_x+trans_x,cam_pos_y+trans_y,pos_z,trans_x,trans_y,0.0,0.0,1.0,0.0);   glRotatef(-angle_y,1.0,0.0,0.0);   glRotatef(-angle_x,0.0,1.0,0.0);   glRotatef(-angle_z,0.0,0.0,1.0);

---

devient en povray

Code:

---

1 2 3 4 5 6 7 8 9

camera{ perspective angle view_angle; location <cam_pos_x+trans_x,cam_pos_y+trans_y,cam_pos_z> look_at <trans_x,trans_y,0.0> right <-window.aspect_ratio,0.0,0.0> up <0.0,window.aspect_ratio,0.0> rotate <angle_x,angle_y,angle_z> }

---

merci a tous pour vos suggestions

Dav