Discussion :

[NeraOne]

Salut à tous

Je suis entrain d'écrire une petite fonction qui doit être capable, à partir d'une rue (objet PolyLigne : plusieurs segments coller les uns aux autres), de créer une projection de cette rue 30 mètre plus loin à droite ou à gauche.
Pour cela je calcule l'angle entre deux segments de la rue (pour savoir si je joins les points entre eux ou si je créer une intersection, je vous explique pas trop mais c'est pas pour le fun !). Seulement, suivant que je suis à droite ou à gauche des segments, l'angle n'est pas le même mais la somme des deux est 2PI. Dans ma fonction, je sais si je suis à droite ou a gauche mais il me faudrait reporter cette information pour le calcul de l'angle, en fait il faudrait que je détecte si l'angle est à gauche ou a droite (par rapport aux segments que je traite). Je vous ai joint une petite image pour mieux vous représenter le problème !

Le calcul de l'angle entre 3 points (donc 2 segments), pour le moment se fait comme cela (c'est du C# mais très simple a comprendre) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static Double Angle(Point p1, Point p2, Point p3)
{
	Double alpha = Math.Atan2(p1.Y - p2.Y, p1.X - p2.X);
	Double beta = Math.Atan2(p3.Y - p2.Y, p3.X - p2.X);
           Double angle = (beta - alpha);
 
	//Correction de l'angle pour le resituer entre 0 et 2PI
	while (angle < 0.0 || angle > 2 * Math.PI)
	{
		if (angle < 0.0) angle += 2 * Math.PI;
		else if (angle > 2 * Math.PI) angle -= 2 * Math.PI;
	}
	return angle;
}

Si quelqu'un connait une formule qui me permettrait de corriger ce calcul et donc pour calculer l'angle à droite ou à gauche de la rue, ca me dépannerait beaucoup !
Merci de votre lecture et de vos réponses !
@ très bientôt
Antoine

[souviron34]

j'avoue que je ne comprend pas ton pbe :

ton angle ne peut être déduit tel quel :

Le seul angle que tu peux déterminer par là est l'angle entre les 2 segments, et donc effectivement le plus petit est alpha, l'autre 2PI-alpha.

Je ne comprends pas ton pbe angle gauche/angle droit puisque tes flèches vont dans le même sens...

D'autre part, le calcul de l'angle entre 3 points est plus direct que ça :

(en C, ici en degrés) :

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
 
double AngleOfView ( double ViewPt_X, double ViewPt_Y, 
	             double Pt1_X, double Pt1_Y, 
                     double Pt2_X, double Pt2_Y )
{
 double a1, b1, a2, b2, a, b, t, cosinus ;
 
 a1 = Pt1_X - ViewPt_X ;
 a2 = Pt1_Y - ViewPt_Y ;
 
 b1 = Pt2_X - ViewPt_X ;
 b2 = Pt2_Y - ViewPt_Y ;
 
 a = sqrt ( (a1*a1) + (a2*a2) );
 b = sqrt ( (b1*b1) + (b2*b2) );
 
 if ( (a == 0.0) || (b == 0.0) )
    return (0.0) ;
 
 cosinus = (a1*b1+a2*b2) / (a*b) ;
 
 t = acos ( cosinus );
 
 t = t * 180.0 / PI ;
 
  return (t);
}

Par contre cette formule te donne toujours l'angle <= PI (enfin 180).

Si par contre tu veux savoir si tu tournes à gauche ou à droite en suivant le chemin A -> B -> C , ce n'est pas l'angle qu'il faut prendre, mais le signe.

Et dans ce cas-là, c'est le calcul de savoir si c'est horaire ou anti-horaire.

Un exemple (counter-clockwise) en C d'après Sedgewick :

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
 
 
/*
 *  C o u n t e r C l o c k W i s e
 *
 * Based on the routine in Sedgewick p. 350
 *
 */
#define ACCURACY_DOUBLE  1.e-06
 
int CounterClockWise ( double Pt0_X, double Pt0_Y, 
		       double Pt1_X, double Pt1_Y, 
	               double Pt2_X, double Pt2_Y )
{
 double dx1, dx2, dy1, dy2 ;
 
 dx1 = Pt1_X - Pt0_X ;
 dy1 = Pt1_Y - Pt0_Y ;
 dx2 = Pt2_X - Pt0_X ;
 dy2 = Pt2_Y - Pt0_Y ;
 if ( fabs(dx1) < ACCURACY_DOUBLE )
    dx1 = 0.0 ;
 if ( fabs(dx2) < ACCURACY_DOUBLE )
    dx2 = 0.0 ;
 if ( fabs(dy1) < ACCURACY_DOUBLE )
    dy1 = 0.0 ;
 if ( fabs(dy2) < ACCURACY_DOUBLE )
    dy2 = 0.0 ;
 
 if ( (dx1*dy2) > (dy1*dx2) )
     return (+1);
 
 if ( (dx1*dy2) < (dy1*dx2) )
     return (-1);
 
 if ( ((dx1*dx2) < 0.0) || ((dy1*dy2) < 0.0) )
     return (-1);
 
 if ( (dx1*dx1+dy1*dy1) < (dx2*dx2+dy2*dy2) )
     return (+1);
 
 return (0) ;
}

[NeraOne]

Imagine toi en situation réelle tu te place sur le point B dans le schéma dans le sens du parcours (vers C), tu as un angle à ta gauche (le bleu) et un à ta droite, le vert ! Peu importe le signe de l'angle pourvu que je sache si je calcul celui de droite ou celui de gauche...
Mais bon, ne te prend pas la tête, j'ai été obligé de faire autrement et je n'ai donc plus besoin de calculer les angles, j'ai juste besoin de savoir si les projection s'intersectent ou pas et ça je sais le faire !

Merci de ta réponse et merci pour tes bout de code qui vont me servir !!!

@+ et encore merci !

Antoine

[souviron34]

Imagine toi en situation réelle tu te place sur le point B dans le schéma dans le sens du parcours (vers C), tu as un angle à ta gauche (le bleu) et un à ta droite, le vert ! Peu importe le signe de l'angle pourvu que je sache si je calcul celui de droite ou celui de gauche...
Mais bon, ne te prend pas la tête, j'ai été obligé de faire autrement et je n'ai donc plus besoin de calculer les angles, j'ai juste besoin de savoir si les projection s'intersectent ou pas et ça je sais le faire !

Merci de ta réponse et merci pour tes bout de code qui vont me servir !!!

@+ et encore merci !

Antoine

De rien, mais je ne me prend pas la tête je ne comprend pas ce que tu dis

Et je crois que c'est parce que tu n'exprimes pas clairement ce que tu veux :

Si je suis au point B dans le sens du parcours, je n'ai pas un angle à gauche et un angle à droite. J'ai un angle si je fais face au "creux" du virage, et un autre si je suis "dos" au virage (dos au "plus petit angle").

Mais si je suis dans l'abstrait, alors c'est la formule "counter clockwise" : si je suis dans le sens des aiguilles d'une montre (counterclockwise = -1) alors je tourne à droite. Si je suis en sens contraire (counterclockwise = 1) alors je tourne à gauche...

(c'est ce que veut dire counterclockwise : sens contraire des aiguilles d'une montre, littéralement....)

[NeraOne]

OkOk, je comprends ce que tu dis ! J'avais pas fait le rapprochement avec le sens des aiguilles d'une montre ! En effet si je tourne dans le sens des aiguilles, je vais à droite, dans le contraire, je vais à gauche !
C'est plus clair dans ma tête alors ! merci
Mais bon il n'empêche que je ne peux plus faire comme cela dans ma fonction pour d'autres raisons...
Merci, tu m'auras bien éclairé aujourd'hui !
@+
Antoine