Discussion :

[Péhelji]

Moi j'aurais fait un truc dans le genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
  // Angles de 0 à 360
  angle := (Position * Pi) / 180;
  // Positionner au centre de ta fiche
  CenterX := Form2.Width / 2;
  CenterY := Form2.Height / 2;
 
  // on calcul la distance qui separe ton point du centre 
  d1 := sqrt( sqr(CenterX-cbBlack.Left) + sqr(CenterY-cbBlack.Top));
  cbBlack.Left := Round(d1 * cos(angle) + CenterX);
  cbBlack.Top  := Round(d1 * sin(angle) + CenterY);

Bonsoir anapurna,

Eh bien, ton truc est le premier à faire tourner le bouton noir autour du centre de la fiche !

Mais le truc a besoin d'être amélioré :
1) à l'angle 0 (position de départ), le bouton ne démarre pas à sa position initiale mais va se placer à l'extrême droite au niveau du point (0,0).
2) en affectant un code similaire aux trois autres boutons, ceux-ci se positionnent sur la même trajectoire, proportionnellement à leur distance du point (0,0).

Le but final est de faire tourner les quatre composants en même temps à partir de leurs positions initiales.

[wiwaxia]

Le calcul ((angle * Pi) / 180)
ne pourrait-il pas être fait une seule fois au lieu de quatre, en introduisant quelques termes supplémentaires ?

Le programme y gagnerait en lisibilité (voir le message précédent).

[Péhelji]

Bonsoir galerien69,

je crois que tu las mal pris cetait pas le but

Pardonne-moi, mais les maths et la chimie furent un peu mes camps de concentration à moi. Ils m'ont laissés tellement de mauvais souvenirs que quarante ans après, rien qu'à l'idée de devoir m'y replonger, çà me met un peu à cran semble-t-il. Il va falloir que j'abuse des smileys pour adoucir le ton de mon propos !

Edit, soit dit en passant ton round est fumeux tu vas cumuler les erreurs darrondi a chaque rotation...

Je viens de le vérifier en testant le code d'anapurna. Mais le problème, c'est qu'il faut affecter des valeurs entières aux composants pour les positionner sur la fiche.

[Péhelji]

Bonsoir wiwaxia,

Le calcul ((angle * Pi) / 180)
ne pourrait-il pas être fait une seule fois au lieu de quatre, en introduisant quelques termes supplémentaires ?
Le programme y gagnerait en lisibilité (voir le message précédent).

En réalité, je n'ai pas reproduit le calcul de l'angle, mais seulement les lignes suivantes avec de nouvelles valeurs d2, d3, d4 pour les composants cbRed, cbYellow et cbBlue :

Code :

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

1
2
3
4
 
  d1 := sqrt( sqr(CenterX-cbBlack.Left) + sqr(CenterY-cbBlack.Top));
  cbBlack.Left := Round(d1 * cos(angle) + CenterX);
  cbBlack.Top  := Round(d1 * sin(angle) + CenterY);

A propos de code, merci pour celui que tu m'as proposé mais que je n'ai pas encore eu le temps de tester !

[Péhelji]

Merci wiwaxia pour ton code qui fait bien tourner les quatre composants autour de la fiche !

Voici son adaptation sous Lazarus :

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
 
procedure TFiche.TrackBar_AngleChange(Sender: TObject);
const
  Np = 4;
  Pis180 = Pi / 180;
type
  Tab = array[1..Np] of single;
var
  u, v, x, y: Tab;
  Ar, Ca, Sa: single;
  Dx, Dy, Xc, Yc: single;
  i: byte;
begin
  // Centre de la fiche en (219,190)
  Xc := Fiche.Width / 2;
  Yc := Fiche.Height / 2;
 
  // Initialisation des positions de départ (x, y)
  x[1] := cbBlack.Left; x[2] := cbRed.Left; x[3] := cbYellow.Left; x[4] := cbBlue.Left;
  y[1] := cbBlack.Top;  y[2] := cbRed.Top;  y[3] := cbYellow.Top;  y[4] := cbBlue.Top;
 
  // Passage des degrés aux radians
  Ar := TrackBar_Angle.Position * Pis180;
 
  // Calcul des fonctions trigonométriques
  Ca:= cos(Ar);
  Sa:= sin(Ar);
 
  // On calcul la distance qui separe ton point du centre
  for i := 1 to Np do
      begin
        Dx:= x[i] - Xc;
        Dy:= y[i] - Yc;
        u[i]:= Xc + (Dx * Ca) - (Dy * Sa);
        v[i]:= Yc + (Dx * Sa) + (Dy * Ca);
      end;
 
  // Affecter les nouvelles valeurs
  cbBlack.Left  := Round(u[1]); cbRed.Left  := Round(u[2]);
  cbBlack.Top   := Round(v[1]); cbRed.Top   := Round(v[2]);
 
  cbYellow.Left := Round(u[3]); cbBlue.Left := Round(u[4]);
  cbYellow.Top  := Round(v[3]); cbBlue.Top  := Round(v[4]);
end;

Toutefois les angles se doivent d'être calculés en radians pour que l'algorithme fonctionne.
Pour atteindre le même résultat avec des degrés, où faudrait-il placer le facteur de conversion Pis180 ?

[wiwaxia]

... Voici son adaptation sous Lazarus :

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
procedure TFiche.TrackBar_AngleChange(Sender: TObject);
const
  Np = 4;
  Pis180 = Pi / 180;
type
  Tab = array[1..Np] of single;
var
  u, v, x, y: Tab;
  Ar, Ca, Sa: single;
  Dx, Dy, Xc, Yc: single;
  i: byte;
begin
  // Centre de la fiche en (219,190)
  Xc := Fiche.Width / 2;
  Yc := Fiche.Height / 2;

  // Initialisation des positions de départ (x, y)
  x[1] := cbBlack.Left; x[2] := cbRed.Left; x[3] := cbYellow.Left; x[4] := cbBlue.Left;
  y[1] := cbBlack.Top;  y[2] := cbRed.Top;  y[3] := cbYellow.Top;  y[4] := cbBlue.Top;

  // Passage des degrés aux radians
  Ar := TrackBar_Angle.Position * Pis180;

  // Calcul des fonctions trigonométriques
  Ca:= cos(Ar);
  Sa:= sin(Ar);

  // On calcul la distance qui separe ton point du centre
  for i := 1 to Np do
      begin
        Dx:= x[i] - Xc;
        Dy:= y[i] - Yc;
        u[i]:= Xc + (Dx * Ca) - (Dy * Sa);
        v[i]:= Yc + (Dx * Sa) + (Dy * Ca);
      end;

 ... / ...

Toutefois les angles se doivent d'être calculés en radians pour que l'algorithme fonctionne.
Pour atteindre le même résultat avec des degrés, où faudrait-il placer le facteur de conversion Pis180 ?

Je ne comprends pas ta question: l'instruction de conversion

Code :

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

Ar := TrackBar_Angle.Position * Pis180;

est correctement placée, à la ligne (22), avant l'appel des fonctions trigonométriques (lignes 25 et 26) qui n'utilisent à ma connaissance que des angles exprimés en radians.
Peut-être existe-t-il sous Lazarus des variantes admettant en argument des angles en degré ? Je ne pense pas cependant que l'exécution soit plus rapide.

# Une remarque, par ailleurs:

Il existe une fonction de conversion des angles:
function RadToDeg(Radians: Extended): Extended; { Degrees := Radians * 180 / PI }
ainsi qu'une procédure d'obtention simultanée du sinus et du cosinus:
procedure SinCos(Theta: Extended; var Sin, Cos: Extended);
cette dernière permettant un calcul deux fois plus rapide des deux termes.

Ce qui est écrit aux lignes 22 ~ 26 pourrait ainsi être remplacé (sauf erreur) par:

Code :

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

1
2
Ar := RadToDeg(TrackBar_Angle.Position);
SinCos(Ar, Sa, Ca);

ou d'une façon encore plus brève (quoique je m'abstienne généralement de l'emboîtement des fonctions):

Code :

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

SinCos(RadToDeg(TrackBar_Angle.Position), Sa, Ca);

# Tu n'es heureusement pas du tout aussi nul que ta déclaration initiale l'avait laissé croire

Est-il besoin de vous préciser que j'ai toujours été nul en maths et que la trigonométrie et moi çà fait deux ?

et qui décourageait franchement toute tentative de réponse.

[Péhelji]

Bonjour wiwaxia,

Je ne comprends pas ta question

Manifestement parce que je l'ai mal posé !
Alors je vais présenter la chose sous un angle () qui m'est plus familier.

L'objectif est :
1) de pouvoir faire pivoter des contrôles (ici au nombre de 4) autour d'un centre défini (ici celui de la fiche).
2) en utilisant le curseur définissant un angle compris entre 0 et 360°, comme dans bien des applications.

Le code que tu m'as fourni rempli parfaitement la première condition. Mais le déplacement du curseur amène les contrôles à faire plusieurs tours de cadran parce les angles sont exprimés en radians.
Ce que je souhaite, c'est amener les contrôles à ne faire au maximum qu'un seul tour puisque 360° = un seul cercle.

Tu n'es heureusement pas du tout aussi nul que ta déclaration initiale l'avait laissé croire
et qui décourageait franchement toute tentative de réponse.

Ben si un p'tit peu quand même car autrement la question aurait été mieux posée !

[wiwaxia]

... Mais le déplacement du curseur amène les contrôles à faire plusieurs tours de cadran parce les angles sont exprimés en radians.
Ce que je souhaite, c'est amener les contrôles à ne faire au maximum qu'un seul tour puisque 360° = un seul cercle ...

Je ne vois pas bien ce qui se passe, mais l'unité n'y est probablement pour rien: les fonctions Sin(.) et Cos(.) admettent pour période (2*Pi) rad, soit 1 tour, 360° ou 400 gr .

J'ai l'impression que le problème concerne ce que tu veux faire de l'algorithme précédent: quelles sont les valeurs successives de l'angle de rotation ? En quoi consistent les contrôles, et le projet d'ensemble ?

Ce serait peut-être plus clair ...

# Si d'éventuelles valeurs successives de l'angle s'obtiennent par incrémentation, par une relation de récurrence du type:
A_{k + 1} = A_k + DeltaA_k
il suffit d'y ajouter les instructions:

Code :

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

1
2
3
4
 
WHILE (A[k+1]>D_Pi) DO BEGIN
                         A_:= A[k + 1] - D_Pi; A[k + 1]:= A_          // D_Pi = DoublePi = 2 * Pi;         
                       END;

pour que la nouvelle valeur reste dans l'intervalle souhaité.

PS: Ton curseur se déplace-t-il sur un segment (de 0 à 360°) ou sur un cercle ?

[Péhelji]

En quoi consistent les contrôles, et le projet d'ensemble ?

Dans le cadre d'un projet de cartographie, les contrôles figurent des objets que je veux pouvoir faire pivoter en même temps qu'une carte sous-jacente.
Si je choisis de recadrer la carte d'un angle quelconque compris entre 1 et 360° (puisque ce dernier est égal à 0°), je souhaite que les objets placés au-dessus pivotent simultanément selon ce même angle.

Ton curseur se déplace-t-il sur un segment (de 0 à 360°) ou sur un cercle ?

Excuse-moi, mais pour moi 0 à 360°, c'est un cercle. C'est ce choix d'angles que le curseur de ma Trackbar est censé figurer.

[wiwaxia]

... Excuse-moi, mais pour moi 0 à 360°, c'est un cercle. C'est ce choix d'angles que le curseur de ma Trackbar est censé figurer.

Alors il te faut définir la position courante du curseur (coordonnées Xk,Yk) sur son cercle de centre (Gx, Gy) à l'aide d'un angle orienté compris entre et 360 °, et de la position initiale (X0, Y0).

Peut-être disposes-tu d'une fonction AnglePolaire(x, y) donnant directement le résultat dans l'intervalle souhaité ? Il suffirait alors d'injecter dans les deux variables les valeurs correspondantes, par l'instruction:

Code :

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

Ar:= AnglePolaire(Xk - Gx, Yk - Gy);

instruction qui devrait te donner: AnglePolaire(X0 - Gx, Y0 - Gy) = 0 .

Il faut sinon entreprendre un calcul un peu ardu, à l'aide d'un produit scalaire et d'un déterminant - et t'orienter dans cette direction me paraît un peu difficile.
Un sujet analogue a été abordé dans une discussion récente - voir les 4 fonctions proposées

Code :

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

1
2
3
4
5
 
 FUNCTION Det2V(V1, V2: Ve2D): Reel;
 FUNCTION Pscal2V(V1, V2: Ve2D): Reel;
 FUNCTION Norme1(V1: Ve2D): Reel;
 FUNCTION AnglePol(W1, W2: Ve2D): Reel;

[Invité]

Mais le déplacement du curseur amène les contrôles à faire plusieurs tours de cadran parce les angles sont exprimés en radians.

mon ptit doigt me dit que le modèle math est (plutot) correct mais que ton implem est mauvaise.
il me souffle à l'oreille que ta fonction de callback est appelée n fois (pendant que tu slides ton curseur) sauf que tu fais au final n rotations (d'angle en plus différents).

vérifies cb de fois ta fonction est appelée
vérifies quels est l'angle lorsque ta fonction est appelée
et vérifie pour un angle donné à ta fonction quelle est la nouvelle position obtenue?

Il faut sinon entreprendre un calcul un peu ardu

je pense que tu t'égares et appuie à contresens de Péhelji que la trackbar est un slider (un segment) dont lextremité gauche définit 0 et la droite 360.
concernant le calcul que tu proposes ya pas besoin de prodscal et det. atan2 fait l'affaire

[wiwaxia]

J'ai l'impression qu'un malentendu s'est introduit dans les échanges, et je repose la question:

Ton curseur se déplace-t-il sur un segment (gradué de 0 à 360°) ou sur un cercle ?

Le mot 'Trackbar' fait penser à un segment ...

@# galerien69

concernant le calcul que tu proposes ya pas besoin de prodscal et det. atan2 fait l'affaire

La fonction proposée ne répond pas exactement à son attente, parce que située dans l'intervalle ]-Pi ; +Pi].
Mais on peut effectivement définir une fonction AnglePolaire(x, y) en utilisant plus simplement la fonction ArcTan(u) .

[wiwaxia]

La question, c'est: quel est le lien (réalisé ou attendu) entre la position actuelle du curseur sur la glissière - correspondant à un certain angle (a) - et l'orientation du carré observé (C'₁C'₂C'₃C'₄) par rapport à la figure initiale (C₁C₂C₃C₄)

_

Correspond-elle tout simplement au décalage angulaire entre les deux quadrilatères ?

En ce cas il ne devrait pas y avoir de complication hormis le passage de la valeur 359° à la suivante (360°) ...

Ou alors (seconde possibilité) tout déplacement du curseur vers une nouvelle valeur (a') produit une rotation supplémentaire d'angle (a'), ce qui entraîne un dépassement rapide de la limite supérieure (360°).

Tout se résume finalement à l'expression des matrices successives (2×4) constituées des 4 vecteurs (CC₁, CC₂, CC₃, CC₄), et correspondant aux positions consécutiives du curseur.

a) 1^er cas: M_k = Rotation(a_k, M₀)

b) 2^nd cas: M_k = Rotation(a_k, M_{k - 1}) , ce qui conduit à:
M_k = Rotation(a_total, M₀) , avec a_total = a₁ + a₂ + ... + a_k (et qui dépassera inéluctablement 360° au-delà d'un certain nombre d'étapes).

[Péhelji]

Bonjour à vous wiwaxia et galerien69,

Merci de plancher sur mon problème (de math ) ! Quand on dit qu'une image est plus parlante que mille mots !

La question, c'est: quel est le lien (réalisé ou attendu) entre la position actuelle du curseur sur la glissière - correspondant à un certain angle (a) - et l'orientation du carré observé (C'₁C'₂C'₃C'₄) par rapport à la figure initiale (C₁C₂C₃C₄)

La position actuelle du curseur étant de 127°, l'orientation attendue du carré observé (C'1,C'2,C'3,C'4) par rapport à la figure initiale (C1,C2,C3,C4) doit être de 127° dans le sens des aiguilles d'une montre, puisque les positions sur la glissière vont de 0 à 360 de gauche à droite.

mon ptit doigt me dit que le modèle math est (plutot) correct mais que ton implem est mauvaise.
il me souffle à l'oreille que ta fonction de callback est appelée n fois (pendant que tu slides ton curseur) sauf que tu fais au final n rotations (d'angle en plus différents).

La fonction est effectivement appelée à chaque modification de la valeur du curseur.

[wiwaxia]

Alors que se passe-t-il lorsque tu cliques trois fois de suite sur le curseur immobile, la figure se trouvant initialement dans sa position initiale (a₀ = 0) ?

a) L'angle reste constant, et la figure immobile: a₁ = a₂ = a₃ = 127° .
Il intervient alors la relation: M_k = Rotation(a_k, M₀) .

b) L'angle prend successivement les valeurs: a₁ = 127° ; a₂ = 254° ; a₃ = 381° = 21° (modulo 360) .
Ton code met alors en oeuvre la relation de récurrence: M_k = Rotation(a_k, M_{k - 1})
et à chaque fois la figure paraît tourner dans le même sens, d'un peu plus de (1/3) de tour.

#

La position actuelle du curseur étant de 127°, l'orientation attendue du carré observé (C'1,C'2,C'3,C'4) par rapport à la figure initiale (C1,C2,C3,C4) doit être de 127° dans le sens des aiguilles d'une montre, puisque les positions sur la glissière vont de 0 à 360 de gauche à droite.

Il n'y a pas de relation à priori entre le sens de rotation observé et celui des graduations de la glissière, parce que ce dernier est arbitrairement choisi.
D'autre part une rotation d'angle positif devrait s'effectuer dans le sens trigonométrique (c.à.d. antihoraire); mais tu utilises peut-être une procédure prédéfinie, et je n'en connais pas le paramétrage.

[Péhelji]

Bonsoir wiwaxia,

Alors que se passe-t-il lorsque tu cliques trois fois de suite sur le curseur immobile, la figure se trouvant initialement dans sa position initiale (a₀ = 0) ?

Le curseur n'est pas "immobile" : on le déplace et ce qui correspond à un click de souris est un incrément d'une unité (angle suivant = angle actuel + 1). Ainsi, pour reprendre ton illustration (#33), le curseur est placé à la position 127°. En le glissant, il prendra successivement les positions 128°, 129°, 130°............, 360°, les boutons devant pivoter de l'angle correspondant.

D'autre part une rotation d'angle positif devrait s'effectuer dans le sens trigonométrique (c.à.d. antihoraire);

C'est ce que je me suis aperçu en choisissant pour l'image de ma fiche plusieurs angles de rotation dans PhotoStudio 5 :

Mais tu utilises peut-être une procédure prédéfinie, et je n'en connais pas le paramétrage.

Je n'en ai qu'une seule, celle figurant #25, mais qui fait tourner les boutons dans le sens horaire lorsque l'on fait glisser le curseur de 0 à 360° sur la glissière.
Maintenant comment doit-on modifier les lignes 31 à 34 pour obtenir l'effet inverse, rotation en sens antihoraire, en glissant de 360 à 0° ?

[wiwaxia]

Bonjour,

... Le curseur n'est pas "immobile" : on le déplace et ce qui correspond à un click de souris est un incrément d'une unité (angle suivant = angle actuel + 1). Ainsi, pour reprendre ton illustration (#33), le curseur est placé à la position 127°. En le glissant, il prendra successivement les positions 128°, 129°, 130°............, 360°, les boutons devant pivoter de l'angle correspondant.
C'est ce que je me suis aperçu en choisissant pour l'image de ma fiche plusieurs angles de rotation dans PhotoStudio 5 :

Tes explications sont très claires, et tout fonctionne parfaitement.

... Maintenant comment doit-on modifier les lignes 31 à 34 pour obtenir l'effet inverse, rotation en sens antihoraire, en glissant de 360 à 0° ?

Insérer dans ton programme une option de calcul avec un angle négatif de (-1°); seul le sinus change de signe, et le calcul des nouvelles coordonnées devient:

Code :

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

1
2
3
4
5
6
7
8
9
  // On calcule la distance qui sépare ton point du centre
  for i := 1 to Np do
      begin
        Dx:= x[i] - Xc;
        Dy:= y[i] - Yc;
        u[i]:= Xc + (Dx * Ca) + (Dy * Sa);
        v[i]:= Yc - (Dx * Sa) + (Dy * Ca);
      end;

Cela doit conduire à une rotation dans le sens horlogique.

[Péhelji]

Bonsoir wiwaxia,

Cela doit conduire à une rotation dans le sens horlogique.

Tout fonctionne impeccablement et il semble bien que mes deux conditions de départ (#27) soient enfin réunies !
Un grand merci à toi !

soit dit en passant ton round est fumeux tu vas cumuler les erreurs d'arrondi a chaque rotation...

Il ne me reste plus qu'à régler ce problème de "round" qui amène effectivement les composants à s'écarter de temps à autre de leur axe de rotation.

[wiwaxia]

... Il ne me reste plus qu'à régler ce problème de "round" qui amène effectivement les composants à s'écarter de temps à autre de leur axe de rotation.

Toute dérive par cumul d'arrondi devrait disparaître si les calculs relatifs à la rotation portent sur les coordonnées réelles (Xr_k) au format Extended, de précision maximale; les coordonnées entières (Xe_k = Round(Xr_k)) ne doivent apparaître qu'au niveau du tracé de la figure.

Ton algorithme doit présenter la structure suivante:

Code :

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

1
2
3
4
5
6
7
8
 
Configuration actuelle (Xr<sub>k</sub>)   ─ ─ ─ ─ Tracé ─ ─ ─ ─ > Figure(Xe<sub>k</sub>)
     │
     │
     │ Rotation
     │
     v
Nouvelle configuration (Xr<sub>k+1</sub>) ─ ─ ─ ─ Tracé ─ ─ ─ ─ > Figure(Xe<sub>k+1</sub>)

Les fonctions discontinues (Round(.), Trunc(.), etc) ne doivent pas intervenir dans les calculs itératifs, mais seulement au niveau de la dernière étape, lors de la réalisation du dessin.

[Péhelji]

Bonsoir wiwaxia,

Toute dérive par cumul d'arrondi devrait disparaître si les calculs relatifs à la rotation portent sur les coordonnées réelles (Xr_k) au format Extended, de précision maximale; les coordonnées entières (Xe_k = Round(Xr_k)) ne doivent apparaître qu'au niveau du tracé de la figure.

Çà, je l'avais bien compris, mais je me demandais où placer l'initialisation des valeurs x[i], y[i] de manière à ce que le déplacement du curseur sur la glissière (qui relançait l'exécution de l'algorithme) ne modifie pas l'écart entre les composants et leur centre de rotation. En considérant le schéma ci-dessous

Code :

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

1
2
3
4
5
6
7
8
 
Configuration actuelle (Xr<sub>k</sub>)   ─ ─ ─ ─ Tracé ─ ─ ─ ─ > Figure(Xe<sub>k</sub>)
     │
     │
     │ Rotation
     │
     v
Nouvelle configuration (Xr<sub>k+1</sub>) ─ ─ ─ ─ Tracé ─ ─ ─ ─ > Figure(Xe<sub>k+1</sub>)

j'ai réalisé qu'il me fallait définir l'écart composants-centre de rotation à l'extérieur de la procédure, de sorte que les valeurs x[i], y[i] restent inchangés. Et cela a réglé le problème !

Une dernière petite chose : l'algorithme actuel permet à partir des valeurs x[i], y[i] de calculer la nouvelle position u[i], v[i] à partir d'un angle déterminé. Si je souhaite effectuer la rotation non plus à l'aide d'une glissière mais à la souris, comment puis-je récupérer la valeur de l'angle de rotation, sachant que la position u[i], v[i] représentera désormais la position du curseur de la souris, dont la distance du centre de rotation sera aléatoire ?