Discussion :

[rob24]

Bonjour,
Je veux faire tourner un objet genre cubique.
Je le dessine à partir d'un tableau T reprenant les coordonnées X,Y,Z de tous ses points. (je n 'utilise que X et Y)
A l'aide de la souris je fais tourner ; le tableau T est recalculé en utilisant une matrice de rotation.Autour de l'axe X tout se passe bien.
De temps en temps j'ai une symetrisation de l'image qui ce déclenche sur l'axe Y . La face gauche passe automatiquement à droite et l'inverse.
Ca se passe lorsque les faces gauche et droite se superposent ou viennent de se superposer....
Je n'arrive pas à comprendre d'ou cela peut venir...

Est-ce que ça vous dit quelque chose ce problème, est-ce qu'il est connu ?
Quelle est la solution ?
Je galère avec ça depuis un bon moment...
Merci de bien vouloir me renseigner
Robert

[plegat]

Salut

Sans plus de détails sur les calculs que tu fais pour avoir ta matrice de rotation et comment tu l'utilises, ça va être difficile de te répondre...

On ne va pas répondre "gimbal lock" tout de suite mais je pose une option quand même

[rob24]

Bonsoir,
Merci pour ta réponse.

Effectivement d'après ce que je viens de voir sur le net ca ressemble au gimbal lock que je ne connais pas car je suis un amateur.

Voila la fonction que j'utilise. 3 rotations successives.
Y a t-il une solution ? Changer l'ordre des rotations ?

Pourrais-tu me poster un bout de code pour que ca marche ?

A l'avance , merci.

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
32
33
34
35
36
37
38
39
40
41
 
//MaxFaces,Points,XYZ en variables globales
 
void CObjet3D::Rotation(float dx,float dy,float dz,float T[Maxfaces][Points][XYZ])
{	
	float X,Y,Z,X1,Y1,Z1; 
	int b,c;
 
	for (b=0;b<Maxfaces;b++)
	{
		for (c=0;c<4;c++)
		{
		 X1=T[b][c][0];
		 Y1=T[b][c][1];
		 Z1=T[b][c][2];
 
 
		 //Rotation autour de X
		 X=X1;
		 Y= Y1*cos(dx) + Z1*sin(dx);
		 Z=-Y1*sin(dx) + Z1*cos(dx);
		 X1=X;Y1=Y;Z1=Z;
 
		 //Rotation autour de Y
		 X= X1*cos(dy) + Z1*sin(dy);
		 Y=Y1;
		 Z=-X1*sin(dy)+ Z1*cos(dy);
		 X1=X;Y1=Y;Z1=Z;
 
		 //Rotation autour de Z
		 X= X1*cos(dz) + Y1*sin(dz);
		 Y=-X1*sin(dz) + Y1*cos(dz);
		 Z=Z1;
		 X1=X; Y1=Y;Z1=Z;
 
		 T[b][c][0]=X1;
		 T[b][c][1]=Y1;
		 T[b][c][2]=Z1;
		}
	}  		
}

Je viens de trouver ces explications sur un forum.

La seule solution à ce problème est de transformer les axes de rotations suivants avec les rotations précédentes. Ces transformations requièrent un outil de combinaison de rotations quelconques, ce qui s'avère plus facile avec des quaternions qu'avec des matrices.


On ne peut pas dire que ce sont les quaternions qui à eux seuls permettent d'éviter le gimbal lock, il est tout à fait possible de reproduire ce problème avec des quaternions.


Autrement dit, si on note R[0x,a](objet) la rotation autour de l'axe 0x et d'angle a de l'objet, R[Oy,b] la rotation autour de l'axe Oy et d'angle b et R[Oz,c] la rotation autour de l'axe Oz d'angle c, pour combiner les 3 rotations axiales, on fait :
R(objet)=R[R[R[Ox,a](Oy),b]R[Ox,a](Oz),c](R[R[Ox,a](Oy),b](R[Ox,a](objet)))


On conserve ainsi le repère local associé à l'objet qui change après chaque rotation appliqué à celui-ci, on garde ainsi tous les degrés de liberté.

Comment traduire ca sous forme d'une fonction en C. Je n'y comprend pas grand chose.

Robert

[plegat]

Effectivement d'après ce que je viens de voir sur le net ca ressemble au gimbal lock que je ne connais pas car je suis un amateur.

Bah on ne va pas te l'expliquer, le dernier qui a demandé n'avait toujours pas la réponse au bout de posts! (j'exagère à peine...)
Juste au cas où...

De toute façon, ça ne me semble pas être un gimbal lock, tu tournes par rapport aux axes globaux, ce n'est pas une utilisation des angles d'Euler (d'après ce que je comprends).

Pourrais-tu me poster un bout de code pour que ca marche ?

La réponse va être non, vu que j'utilise les quaternions

Par contre pourrait-on voir comment tu manipules tes dx/dy/dz? Comment sont-ils gérés par rapport au mouvement de la souris?

As-tu testé avec autre chose qu'un cube? (on n'est pas à l'abri d'un artefact visuel...)

Je viens de trouver ces explications sur un forum.
[...]
Comment traduire ca sous forme d'une fonction en C. Je n'y comprend pas grand chose.

En fait ça veut dire qu'au lieu de faire trois rotations, il est préférable d'en faire une... tu calcules ta matrice de rotation globale, et tu l'appliques en une seule fois. Mais vu que tu n'utilises pas de matrices... tu le fais indirectement via tes formules, ça reviendrait à calculer les coordonnées finales en une seule ligne...

[rob24]

Merci pour tes infos.

En fait je fais tourner une table avec deux côtés de couleurs différentes.
Donc je vois bien que ces côtés s'inversent. Ce n'est pas une illusion d'optique.
Ci dessous code. Il est fort possible que j'utilise mal la souris car je me sers uniquement des axes X et Y.

Au sujet de la souris j'ai constaté que ces inversions se produisaient beaucoup plus fréquemment sur des accélérations ... lorsque je la déplace lentement il n'y a presque jamais d'inversion. Curieux !

Comment faire pour passer de 2D en 3D pour la souris et utiliser les déplacements x et y pour générer z de façon à avoir des rotions normales.
Peux-tu me fournir le code correspondant en C ?

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
 
 
	else if (fRotationView)
	{	
DeplacementX=DernierPoint.x-point.x;
		DeplacementY=DernierPoint.y-point.y;
 
		DernierPoint.x=point.x;DernierPoint.y=point.y;
 
                         yy+=DeplacementX/200;
		xx-=DeplacementY/200;
		zz=0;
 
		FaitTourner(xx,yy,zz);
		Zoome();
 
		InvalidateRect(&RectWin,false);	
 
	}

[plegat]

Au sujet de la souris j'ai constaté que ces inversions se produisaient beaucoup plus fréquemment sur des accélérations ... lorsque je la déplace lentement il n'y a presque jamais d'inversion. Curieux !

Il n'y a pas de "limiteur" sur tes angles, il se passe quoi quand on dépasse les 360°? D'ici que tu fasse un dépassement de capacité, il n'y a qu'un pas... à vérifier donc...

Peux-tu me fournir le code correspondant en C ?

Non.
Je peux te fournir un code Java avec des quaternions à la limite, et encore...

Si tu pouvais joindre des screenshots du problème, histoire qu'on se fasse une idée visuelle...

[rob24]

Merci pour ta réponse.

3 jpeg joins.

Dans un premier temps vais essayer de modifier la gestion de ma souris et je dirai si ça a corrigé le pb ou pas.

[plegat]

Houla!!!! Ca ne va pas être facile de voir une inversion éventuelle avec une vue fil de fer... tu peux faire la même chose avec une vue solide ou pas avec ton prog?

[rob24]

Non je ne colorie pas les surfaces.

[plegat]

Bon, bah ça ne va pas être facile alors...

Pour moi il n'y a pas d'inversion... ce qui se justifie quand tu dis que quand tu déplaces lentement la souris, tu n'en as pas. Tu as juste l'impression que ça s'inverse sur les déplacements rapide parce que ton objet tourne d'un "grand" angle d'un seul coup, ce qui perturbe le regard... (en tous cas, je ne vois pas d'inversion "flagrante" entre ta première image et la seconde). On perd facilement la profondeur 3D avec une vue en fil de fer...

Ce que tu peux éventuellement tester, c'est modifier tes ratios de déplacement (le /200 que tu as dans ton code). Dans mon moteur graphique, je les ai indexés sur les dimensions de la fenêtre, de manière à avoir un tour pour une course complète de la souris.

Par contre limite tes valeurs... met quelque chose pour boucler sur 360° (ou sur 2*PI).

[rob24]

Ok je vais suivre tes conseils .

[plegat]

Juste par curiosité, c'est-y quoi donc que cette chose comme logiciel?

[rob24]

C'est un logiciel que je développe (en amateur) et qui permet de découper des volumes dans de la mousse polystyrène, EPP... avec un fil chaud et qui comporte un simulateur utilisé avant la découpe pour s'assurer que tout est OK.
Il sert surtout à découper des parties d'avion (fuselage ailes)mais n'est pas limité à cela.

Si tu veux avoir des renseignements complémentaires tu peux aller sur mon blog. Tu pourras même y charger le logiciel, l'installer et faire tourner le simulateur pour voir le problème de pilotage souris et d'inversion dont je te parle.
http://www.aeropassion.net/aero2009/

[plegat]

Roooh, une table à fil chaud... ça me rappelle des choses tout ça (sauf que je le faisais en manuel!)

Dommage pour les tests du logiciel, mais je tourne avec linux, et ça ne veut pas passer avec Wine... à moi que les sources ne soient à disposition, auquel cas on peut tester une compilation...

[rob24]

Non les sources ne sont pas disponibles (trop bordéliques ...).
Il doit bien y avoir un Windows XP pas trop loin ?

J'ai essayé de modifier la gestion de souris avec ce bout de code.
Ca tourne (très vite, trop vite...) même si je fais faire à la souris un cercle de 1cm de diamètre.
Mais les objets n'ont pas l'air déformés.
Donc ça parait bon mais il faut que je ralentisse les rotations.

Vois-tu ce qui ne va pas ?

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
	else if (fRotationView )  //Deplacement pour rotation
	{     
	//Declarations Globales
	    /*	
		typedef struct Vector
		{
			double x;
			double y;
			double z;
		}vecteur;
 
		vecteur vAxe,vAxePrec;
		vecteur vNewNorm,vPrecNorm;
		*/
 
//Pour avoir un cercle 
double x= ((double)pt.x/(RectWin.Width()/2)); 
double y= ((double)pt.y/(RectWin.Width()/2)); 
 
x=x-1;
y=1-y;
double z2=sqrt(1-x*x-y*y);
double z = z2>0 ? sqrt(z2) : 0;
 
//Nouveau vecteur
vecteur vNew;
vNew.x=x; vNew.y=y; vNew.z=z;
 
//normaliser le nouveau vecteur
double lg= sqrt( (vNew.x*vNew.x) + (vNew.y*vNew.y) + (vNew.z*vNew.z));
vNewNorm.x=vNew.x/lg; vNewNorm.y=vNew.y/lg; vNewNorm.z=vNew.z/lg;
 
// Determiner le vecteur axe de rotation perpendiculaire au plan-> vAxe
vAxe.x=( vNewNorm.y*vPrecNorm.z)-(vNewNorm.z*vPrecNorm.y);
vAxe.y=( vNewNorm.z*vPrecNorm.x)-(vNewNorm.x*vPrecNorm.z);
vAxe.z=( vNewNorm.x*vPrecNorm.y)-(vNewNorm.y*vPrecNorm.x);
 
//determiner les trois angles par rapport au vecteur Axe de rotation précédent
double alphaz,betay,tetax;
/*
// Solution 1
alphaz=acos(vAxe.x*vPrecNorm.x + vAxe.y*vPrecNorm.y);
betay =acos(vAxe.x*vPrecNorm.x + vAxe.z*vPrecNorm.z);
tetax =acos(vAxe.z*vPrecNorm.z + vAxe.y*vPrecNorm.y);
 
zz+=pow(alphaz,-1);
yy+=pow(betay,-1);
xx+=pow(tetax,-1);
*/
 // Solution2
alphaz= atan2(vAxe.y,vAxe.x);
betay=  atan2(vAxe.x,vAxe.z);
tetax=  atan2(vAxe.y,vAxe.z);
 
//Modifier position
zz+=alphaz;if (xx>2*PI) xx=0;if (xx<0) xx=2*PI; 
yy+=betay; if (yy>2*PI) yy=0; if (yy<0) yy=2*PI; 
xx+=tetax; if (zz>2*PI) yy=0; if (zz<0) yy=2*PI; 
 
FaitTourner(xx,yy,zz);
Zoome();
InvalidateRect(&RectWin,false);	//nécessaire
 
 
// sauvegarder vecteurs pour déplacement suivant
PrecNorm.x=vNewNorm.x;
vPrecNorm.y=vNewNorm.y;
vPrecNorm.z=vNewNorm.z;
 
vAxePrec.x=vAxe.x;
vAxePrec.y=vAxe.y;
vAxePrec.z=vAxe.z;
 
 
}

[plegat]

Non les sources ne sont pas disponibles (trop bordéliques ...).
Il doit bien y avoir un Windows XP pas trop loin ?

J'ai mis l'installateur de côté pour le jour où j'allumerai le portable... parce qu'au boulot ça ne va pas le faire!

Ca tourne (très vite, trop vite...) dans tous les sens et ca me déforme les objets. (voir jpg)

Je ne comprends pas trop le code, donc je ne peux pas en dire plus... mais c'est vrai qu'il y a un fil chaud qui se balade là!

Code :

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

double dy=RectWin.Width()/2;

J'aurais mis un RectWin.Height()/2.0
Fait attention avec tes divisions, là il y a un risque de division entière (en fonction du type du numérateur et du langage). C'est pour cela qu'en général je précise toujours 2.0 au lieu de 2 quand je fais des divisions de ce genre dans mon code.

Code :

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

1
2
3
4
 
       zz+=alphaz;if (xx>2*PI) xx=0;if (xx<0) xx=2*PI; 
       yy+=betay; if (yy>2*PI) yy=0; if (yy<0) yy=2*PI; 
       xx+=tetax; if (zz>2*PI) yy=0; if (zz<0) yy=2*PI;

Là, pour la compréhension générale, il vaut mieux éviter de modifier zz... et de borner xx juste après (et inversement sur la ligne en xx+). Regroupe les zz entre eux, et les xx entre eux (c'est pour dans six mois quand tu reprendras ce bout de code!)

Par contre modifie la ligne en xx+... tu fais ton bornage sur yy au lieu de zz
Et plutôt que faire:

Code :

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

if (xx>2*PI) xx=0

qui risque de créer des sauts, fais plutôt:

Code :

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

if (xx>2*PI) xx=xx-2*PI

ou même mieux, utilise un modulo

Un truc que je te conseille de faire pour présenter tes problèmes, c'est de faire une vidéo... ça sera plus parlant que des screenshots (Camstudio pour la prise, et viméo pour la diffusion par exemple)

[rob24]

Comme ça marchait mal j'ai modifié mon code en suivant au plus près la doc ci jointe et en faisant intervenir un quaternion dont j'ai trouvé une classe sur le net.
En fin de code le quaternion me fournit les angles d'Euler que je transmet à ma fonction de rotation :
faitTourner(float xx,float yy, float zz);

La réaction aux mouvements de la souris est maintenant fluide et apparemment normale,.

Par contre j'ai des déformations de mes objets dans certaines positions.

Celà est peut-être dù à qq fonctions présentes dans la doc tout a fait a la fin que je n'ai pas implémentées car je ne sais pas ce qu'elles font et je n'ai pas trouvé de code correspondant sur le net pour essayer.

J'ai fait une petite vidéo mais je n'ai pas réussi encore à m'inscrire à VIMEO.
Il sont en maintenance ou ils ont un bug ...
Dès que ca marche je te joins la référence.

Peux-tu jeter un coup d'oeil sur ce code et me dire ce que tu en penses ?
J'espère que je n'abuse pas...

Encore merci.
Robert

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
else if (fRotationView )  //Deplacement pour rotation
	{     
	//Declarations Globales
	    /*	
		typedef struct Vector
		{
			double x;
			double y;
			double z;
		}vecteur;
 
 
		vecteur vNew;                //Nouvelle position de la souris 
		vecteur vNewNorm,vPrecNorm;  //position souris normalisés
		vecteur vCross, vCrossPrec;  //Crossproduct
 
		*/
 
		/*
		int faitModuloDouble(double nb1 ,double nb2)
		{
			int r=(int)(nb1/nb2) ;
			return r;	
		}*/
 
 
        CPoint pt;
    	GetCursorPos(&pt);
 
        //Inscrire la sphere  dans l'écran
        float x= (pt.x/(RectWin.Height()/2.0)); 
        float y= (pt.y/(RectWin.Height()/2.0)); 
	x=x-1.0;
	y=1.0-y;
	float z2=sqrt(1-x*x-y*y);
	float z = z2>0 ? sqrt(z2) : 0;
 
       //Nouveau vecteur de position de la souris
	vNew.x=x; vNew.y=y; vNew.z=z;
 
//normaliser le nouveau vecteur de position
float lg= sqrt( (vNew.x*vNew.x) + (vNew.y*vNew.y) + (vNew.z*vNew.z));
vNewNorm.x=vNew.x/lg; vNewNorm.y=vNew.y/lg; vNewNorm.z=vNew.z/lg;
 
//Crossproduct des deux vecteurs de position actuelle et précédente de la souris ( vNewNorm et vPrecNorm)
vCross.x = (vNewNorm.y * vPrecNorm.z) - (vNewNorm.z * vPrecNorm.y);
vCross.y = (vNewNorm.z * vPrecNorm.x) - (vNewNorm.x * vPrecNorm.z);
vCross.z = (vNewNorm.x * vPrecNorm.y) - (vNewNorm.y * vPrecNorm.x);
 
//calcul de angleBetween vCross et vCrossPrec teta
float tp1,tp2;
tp1=vCross.x*vCrossPrec.x + vCross.y*vCrossPrec.y + vCross.z*vCrossPrec.z;
tp2=sqrt(pow(vCross.x,2)+pow(vCross.y,2)+pow(vCross.z,2)) +
sqrt(pow(vCrossPrec.x,2)+pow(vCrossPrec.y,2)+pow(vCrossPrec.z,2));
float teta=pow(acos(tp1/tp2),-1);
 
///////////////////////////////////////////////////////////////////////////////
/*Quaternion class
 * By Will Perone (billperone@yahoo.com)
 * Original: 12-09-2003  
 * Revised:  27-09-2003
 *           22-11-2003
 *           10-12-2003
 *           15-01-2004
 *           16-04-2004
 *   
 * Dependancies: My 4x4 matrix class*/
 
 
 
//transposer vCross dans vQ
    vector3f vQ;
		 vQ.x=vCross.x;
		 vQ.y=vCross.y;
		 vQ.z=vCross.z;
 
         quaternion delta(-teta,vQ);
         vector3f AnglesRot=delta.euler_angles();
///////////////////////////////////////////////////////////////////////////////
        Il manque peut-être qq chose ici
//////////////////////////////////////////////////////////////////////////////  
 
//Incrémenter la dernière position
xx+=AnglesRot.x;  if (xx>2*PI) xx=0;if (xx<0) xx=xx-2*PI; 
yy+=AnglesRot.y;  if (yy>2*PI) yy=0;if (yy<0) yy=yy-2*PI; 
zz+=AnglesRot.z;  if (zz>2*PI) zz=0;if (zz<0) zz=zz-2*PI; 
 
//Calculer les points de la nouvelle position
FaitTourner(xx,yy,zz);
Zoome();
 
//Redessiner
InvalidateRect(&RectWin,false);	
 
// sauvegarder les vecteurs pour taiter le déplacement suivant
 
//vecteurs de position normalisés
vPrecNorm.x=vNewNorm.x;
vPrecNorm.y=vNewNorm.y;
vPrecNorm.z=vNewNorm.z;
 
//CrossProduct
vCrossPrec.x=vCross.x;
vCrossPrec.y=vCross.y;
vCrossPrec.z=vCross.z;    
 
	}

[plegat]

Code :

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

1
2
3
 
        float x= (pt.x/(RectWin.Height()/2.0)); 
        float y= (pt.y/(RectWin.Height()/2.0));

Ah bah non, fallait pas toucher au x, il était bien avec le RectWin.Width!

[rob24]

Dans la doc on peut trouver ça

the Viewport3D is oblong the inscribed trackball will actually be an ellipsoid

This effect isn’t usually noticeable, but if the aspect ratio is extreme this will cause the rate of rotation to be significantly faster when moving along the shorter axes. To correct for this you can apply a uniform scale when mapping the 2D point to the sphere instead of (width, height). For example, min(width, height) would work. Whatever you choose, remember to account for this when translating to the origin.

Donc j'ai pris la valeur min (Rectwin.Height()) pour avoir une rotation en forme de cercle et non d'ellipse. Ca gêne pour le rest du code ?

[plegat]

Dans la doc on peut trouver ça

Donc j'ai pris la valeur min (Rectwin.Height()) pour avoir une rotation en forme de cercle et non d'ellipse. Ca gêne pour le rest du code ?

Ah ok, au temps pour moi...
Ca ne doit pas gêner, surtout si c'est conseillé dans la doc.

Pour les déformations, je ne sais pas... à partir du moment où tu calcules tes angles de rotation, ça devrait tourner sans déformation ensuite...