Angle entre 3 points?

Premières suggestions concernant votre méthode:

Ce que vous appelez ac est en fait cb. Mais c'est ok, c'est ce qui est vraiment nécessaire.
Ensuite,

float dotabac = (ab.x * ab.y + ac.x * ac.y);

C'est votre première erreur. Le réel produit scalaire de deux vecteurs est:

float dotabac = (ab.x * ac.x + ab.y * ac.y);

Maintenant,

float rslt = acos(dacos);

Ici vous devriez noter qu'en raison de la précision de la perte au cours du calcul, il est théoriquement possible que dacos va devenir plus grand que 1 (ou inférieur à -1). Par conséquent, vous devriez vérifier cela de manière explicite.

En Plus d'une performance remarque: vous appelez un lourd sqrt fonction deux fois pour le calcul de la longueur de deux vecteurs. Ensuite, vous divisez le produit scalaire par ces longueurs.
Au lieu de cela, vous pourriez l'appeler sqrt sur la multiplication des places de la longueur de deux vecteurs.

Et enfin, vous devez noter que votre résultat est précis jusqu'à la sign. Voilà, votre méthode de ne pas distinguer les 20° et -20°, depuis le cosinus de deux sont les mêmes.
Votre méthode donnera le même angle ABC et ABC.

Une bonne méthode pour le calcul de l'angle est "oslvbo" suggère:

float angba = atan2(ab.y, ab.x);
float angbc = atan2(cb.y, cb.x);
float rslt = angba - angbc;
float rs = (rslt * 180) / 3.141592;

(J'ai juste remplacé atan par atan2).

C'est la méthode la plus simple, qui donne toujours le bon résultat. L'inconvénient de cette méthode est que l'on fait appel à une lourde trigonométrie fonction atan2 deux fois.

Je propose la méthode suivante. C'est un peu plus complexe (nécessite une certaine trigonométrie les compétences nécessaires pour comprendre), mais il est supérieur du point de vue des performances.
Il se contente d'appeler une fois par trigonométrie fonction atan2. Et pas de racine carrée calculs.

int CGlEngineFunctions::GetAngleABC( POINTFLOAT a, POINTFLOAT b, POINTFLOAT c )
{
POINTFLOAT ab = { b.x - a.x, b.y - a.y };
POINTFLOAT cb = { b.x - c.x, b.y - c.y };
//dot product  
float dot = (ab.x * cb.x + ab.y * cb.y);
//length square of both vectors
float abSqr = ab.x * ab.x + ab.y * ab.y;
float cbSqr = cb.x * cb.x + cb.y * cb.y;
//square of cosine of the needed angle    
float cosSqr = dot * dot / abSqr / cbSqr;
//this is a known trigonometric equality:
//cos(alpha * 2) = [ cos(alpha) ]^2 * 2 - 1
float cos2 = 2 * cosSqr - 1;
//Here's the only invocation of the heavy function.
//It's a good idea to check explicitly if cos2 is within [-1 .. 1] range
const float pi = 3.141592f;
float alpha2 =
(cos2 <= -1) ? pi :
(cos2 >= 1) ? 0 :
acosf(cos2);
float rslt = alpha2 / 2;
float rs = rslt * 180. / pi;
//Now revolve the ambiguities.
//1. If dot product of two vectors is negative - the angle is definitely
//above 90 degrees. Still we have no information regarding the sign of the angle.
//NOTE: This ambiguity is the consequence of our method: calculating the cosine
//of the double angle. This allows us to get rid of calling sqrt.
if (dot < 0)
rs = 180 - rs;
//2. Determine the sign. For this we'll use the Determinant of two vectors.
float det = (ab.x * cb.y - ab.y * cb.y);
if (det < 0)
rs = -rs;
return (int) floor(rs + 0.5);
}

EDIT:

Récemment, j'ai travaillé sur un sujet connexe. Et puis j'ai réalisé il y a une meilleure façon. C'est en fait plus ou moins la même (en coulisses). Cependant, il est plus simple à mon humble avis.

L'idée est de faire tourner les deux vecteurs de sorte que le premier est aligné à (positif) X-sens. De toute évidence la rotation de deux vecteurs n'affecte pas l'angle entre eux. Otoh, que, après une telle rotation, il suffit de trouver l'angle de la 2ème vecteur par rapport à l'axe des abscisses. Et c'est exactement ce que atan2 est pour.

De Rotation est obtenue par la multiplication d'un vecteur par la matrice suivante:

• un.x, une.y
• -un.y, une.x

Une fois peut voir que le vecteur a multiplié par une matrice en effet se tourne vers l'axe X positif.

Remarque: Strictement parlant, la matrice n'est pas juste en tournant, c'est aussi mise à l'échelle. Mais c'est ok dans notre cas, puisque la seule chose qui compte, c'est le vecteur de direction, et non pas sa longueur.

Rotation du vecteur b devient:

• un.x * b.x + a.y * b.y = un dot b
• -un.y * b.x + a.x * b.y = un croix b

Enfin, la réponse peut être exprimé comme:

int CGlEngineFunctions::GetAngleABC( POINTFLOAT a, POINTFLOAT b, POINTFLOAT c )
{
POINTFLOAT ab = { b.x - a.x, b.y - a.y };
POINTFLOAT cb = { b.x - c.x, b.y - c.y };
float dot = (ab.x * cb.x + ab.y * cb.y); //dot product
float cross = (ab.x * cb.y - ab.y * cb.x); //cross product
float alpha = atan2(cross, dot);
return (int) floor(alpha * 180. / pi + 0.5);
}

Approche avec arccos est dangereux, car on risque d'avoir c'est l'argument égal à, disons, 1.0000001 et jusqu'à la fin avec EDOMAIN erreur. Même atan approche est dangereuse, parce qu'elle implique des divisions, ce qui peut conduire à une division par zéro. Mieux utiliser atan2en passant dx et dy valeurs.

Hors sujet? Mais vous pouvez le faire avec la loi du cosinus:

Trouver la distance entre A et B (appelons le x), et la distance entre B et C (appelons cela y), et la distance entre A et C (appelons z).

Alors vous savez que z^2=x^2+y^2-2*xycos(ANGLE que VOUS VOULEZ)

par conséquent, l'angle est cos^-1((z^2-x^2-y^2)/(2 x y))=ANGLE

Voici un OpenCV manière à obtenir l'angle entre les 3 points A, B, C) avec B comme le sommet:

int getAngleABC( cv::Point2d a, cv::Point2d b, cv::Point2d c )
{
cv::Point2d ab = { b.x - a.x, b.y - a.y };
cv::Point2d cb = { b.x - c.x, b.y - c.y };
float dot = (ab.x * cb.x + ab.y * cb.y); //dot product
float cross = (ab.x * cb.y - ab.y * cb.x); //cross product
float alpha = atan2(cross, dot);
return (int) floor(alpha * 180. / M_PI + 0.5);
}

Basé sur l'excellente solution par @valdo