La plus petite différence entre 2 angles

Étant donné 2 angles dans la plage -PI -> PI autour d'une coordonnée, quelle est la valeur du plus petit des 2 angles entre eux?

Tenant compte du fait que la différence entre PI et -PI n'est pas de 2 PI mais de zéro.

Exemple:

Imaginez un cercle, avec 2 lignes sortant du centre, il y a 2 angles entre ces lignes, l'angle qu'elles forment à l'intérieur, c'est-à-dire le plus petit angle , et l'angle qu'elles forment à l'extérieur, c'est-à-dire le plus grand angle. Les deux angles lorsqu'ils sont additionnés forment un cercle complet. Étant donné que chaque angle peut tenir dans une certaine plage, quelle est la valeur des angles les plus petits, en tenant compte du survol

Cela donne un angle signé pour tous les angles:

a = targetA - sourceA
a = (a + 180) % 360 - 180

Attention dans de nombreux langages, l' moduloopération renvoie une valeur avec le même signe que le dividende (comme C, C ++, C #, JavaScript, liste complète ici ). Cela nécessite une modfonction personnalisée comme celle-ci:

mod = (a, n) -> a - floor(a/n) * n

Ou alors:

mod = (a, n) -> (a % n + n) % n

Si les angles sont compris entre [-180, 180], cela fonctionne également:

a = targetA - sourceA
a += (a>180) ? -360 : (a<-180) ? 360 : 0

De manière plus verbeuse:

a = targetA - sourceA
a -= 360 if a > 180
a += 360 if a < -180

x est l'angle cible. y est la source ou l'angle de départ:

atan2(sin(x-y), cos(x-y))

Il renvoie l'angle delta signé. Notez que selon votre API, l'ordre des paramètres de la fonction atan2 () peut être différent.

Si vos deux angles sont x et y, l'un des angles entre eux est abs (x - y). L'autre angle est (2 * PI) - abs (x - y). Ainsi, la valeur du plus petit des 2 angles est:

min((2 * PI) - abs(x - y), abs(x - y))

Cela vous donne la valeur absolue de l'angle et suppose que les entrées sont normalisées (c'est-à-dire: dans la plage [0, 2π)).

Si vous souhaitez conserver le signe (c'est-à-dire la direction) de l'angle et accepter également des angles en dehors de la plage, [0, 2π)vous pouvez généraliser ce qui précède. Voici le code Python pour la version généralisée:

PI = math.pi
TAU = 2*PI
def smallestSignedAngleBetween(x, y):
    a = (x - y) % TAU
    b = (y - x) % TAU
    return -a if a < b else b

Notez que l' %opérateur ne se comporte pas de la même manière dans toutes les langues, en particulier lorsque des valeurs négatives sont impliquées, donc en cas de portage, des ajustements de signe peuvent être nécessaires.

Je relève le défi de fournir la réponse signée:

def f(x,y):
  import math
  return min(y-x, y-x+2*math.pi, y-x-2*math.pi, key=abs)

Pour les utilisateurs d'UnityEngine, le moyen le plus simple consiste simplement à utiliser Mathf.DeltaAngle .

Solution arithmétique (par opposition à algorithmique):

angle = Pi - abs(abs(a1 - a2) - Pi);

Un code efficace en C ++ qui fonctionne pour n'importe quel angle et dans les deux: radians et degrés est:

inline double getAbsoluteDiff2Angles(const double x, const double y, const double c)
{
    // c can be PI (for radians) or 180.0 (for degrees);
    return c - fabs(fmod(fabs(x - y), 2*c) - c);
}

Il n'est pas nécessaire de calculer des fonctions trigonométriques. Le code simple en langage C est:

#include <math.h>
#define PIV2 M_PI+M_PI
#define C360 360.0000000000000000000
double difangrad(double x, double y)
{
double arg;

arg = fmod(y-x, PIV2);
if (arg < 0 )  arg  = arg + PIV2;
if (arg > M_PI) arg  = arg - PIV2;

return (-arg);
}
double difangdeg(double x, double y)
{
double arg;
arg = fmod(y-x, C360);
if (arg < 0 )  arg  = arg + C360;
if (arg > 180) arg  = arg - C360;
return (-arg);
}

soit dif = a - b, en radians

dif = difangrad(a,b);

soit dif = a - b, en degrés

dif = difangdeg(a,b);

difangdeg(180.000000 , -180.000000) = 0.000000
difangdeg(-180.000000 , 180.000000) = -0.000000
difangdeg(359.000000 , 1.000000) = -2.000000
difangdeg(1.000000 , 359.000000) = 2.000000

Pas de péché, pas de cos, pas de bronzage, .... seulement la géométrie !!!!