Discussion :

[dmichel]

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 :

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

1
2
3
 
float modelview[16];
glGetFloatv(GL_MODELVIEW_MATRIX, modelview);

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

Code :

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

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 :

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

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 :

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

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 :

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

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

[fgjdfgjdgj]

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

[TanEk]

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

[dmichel]

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.

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

et comment on fait ca ?

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.

[LeGreg]

À 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

[TanEk]

Chez moi ils sont tous orthogonaux :

Code :

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

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 :

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...

[TanEk]

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 :

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

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 :

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...

[dmichel]

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 :

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

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 :

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

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