Angle intérieur entre deux lignes

J'ai deux lignes: Ligne1 et Ligne2. Chaque ligne est définie par deux points (P1L1(x1, y1), P2L1(x2, y2) et P1L1(x1, y1), P2L3(x2, y3)). Je veux savoir à l'intérieur de l'angle défini par ces deux lignes.

Pour le faire, j'ai calculer l'angle de chaque ligne avec l'axe des abscisses:

double theta1 = atan(m1) * (180.0 / PI);
double theta2 = atan(m2) * (180.0 / PI);

Après de connaître l'angle-je calculer les suivantes:

double angle = abs(theta2 - theta1);

Le problème ou de doute que j'ai, c'est: j'ai parfois l'angle correct mais parfois, je reçois le complémentaire de l'angle (pour moi extérieur). Comment puis-je savoir quand soustraire 180º à savoir l'angle interne? Il n'y a aucun algorithme de mieux à faire? Parce que j'ai essayé quelques méthodes: produit scalaire,
formule suivante:

result = (m1 - m2) / (1.0 + (m1 * m2));

Mais toujours, j'ai le même problème; je n'ai jamais su quand j'ai de l'angle externe ou de l'angle interne!

source d'informationauteur osanchezmon

angle c++lines math trigonometry

3
```
if (result > 180)
{
     result = 360 - result;
}
```
De cette façon, il sera toujours l'angle interne. Il suffit de l'ajouter après vous obtenez le résultat.

Si vous voulez entre l'angle de 0 à 360 degrés, puis utilisez le code suivant; Son entièrement testé et fonctionnel:

static inline CGFloat angleBetweenLinesInRadians(CGPoint line1Start, CGPoint line1End, CGPoint line2Start, CGPoint line2End) {
double angle1 = atan2(line1Start.y-line1End.y, line1Start.x-line1End.x);
double angle2 = atan2(line2Start.y-line2End.y, line2Start.x-line2End.x);
double result = (angle2-angle1) * 180 / 3.14;
if (result<0) {
    result+=360;
}
return result;

}

Remarque: Rotation sera aiguilles d'une montre;

Intérieure de l'angle entre 2 vecteurs (v1, v2) = arc cos ( produit scalaire(v1,v2) /(module(v1) * module(v2)) ).

Où le produit scalaire(v1,v2) = xv1*xv2 + yv1*yv2

module(v) = sqrt(pow(xv,2) + pow(yv,2))

Donc, la réponse à votre question est mise en œuvre sur l'exemple suivant:

#define PI   3.14159258

int main()
{
    double x1,y1,x2,y2,y3;
    double m1, m2;
    double mod1, mod2, innerp, angle;

    cout << "x1 :";
    cin >> x1;
    cout << "y1 :";
    cin >> y1;
    cout << "x2 :";
    cin >> x2;
    cout << "y2 :";
    cin >> y2;
    cout << "y3 :";
    cin >> y3;

    m1 = atan((y2-y1)/(x2-x1)) * 180 / PI;
    m2 = atan((y3-y1)/(x2-x1)) * 180 / PI;

    mod1   = sqrt(pow(y2-y1,2)+pow(x2-x1,2));
    mod2   = sqrt(pow(y3-y1,2)+pow(x2-x1,2));
    innerp = (x2-x1)*(x2-x1) + (y2-y1)*(y3-y1);
    angle  = acos(innerp / (mod1 * mod2)) * 180 / PI;

    cout << "m1 : " << m1 << endl;
    cout << "m2 : " << m2 << endl;
    cout << "angle : " << angle << endl;
}

1

Le point de l'ensemble est beaucoup plus facile que les réponses données:

Lorsque vous utilisez atan(pente), vous perdez (littéralement) un bit d'information, qui est il y a exactement deux angles (thêta) et (theta+PI) dans l'intervalle (0..2*PI), ce qui donne la même valeur pour la fonction tan().

Suffit d'utiliser atan2(deltax, deltay) et vous obtenez l'angle droit. Par exemple
```
atan2(1,1) == PI/4
atan2(-1,-1) == 5*PI/4
```
Puis de soustraire, de prendre la valeur absolue, et si elle est supérieure à PI soustraire de 2*PI.
1

Si vous utilisez abolute valeur que vous obtiendrez toujours de l'angle aigu. C'est tangente theta = abs valeur de m1-m2 (1 +m1 * m2). Si vous prenez la tangente inverse votre réponse sera en radians ou en degrés cependant la calculatrice est réglé. Désolé, ce n'est pas de la programmation lingo, je suis un professeur de mathématiques, pas un programmeur...
0

L'obtention de l'angle externe vs l'angle interne est entièrement déterminé par l'ordre de votre soustractions (pensez-y). Vous devez soustraire le plus petit thêta de plus, afin de toujours obtenir de manière fiable de l'angle interne. Vous aussi vous voudrez probablement utiliser la atan2 fonction, le type de données que vous attendez.
0

J'espère que je comprends de vouloir l'angle aigu plutôt que de l'angle obtus de l'intersection de deux lignes. Suis-je la corriger?

Angles aigus et obtus d'une intersection de 180 deg compléter les unes les autres. c'est à dire
```
 acute + obtuse = PI.
```
http://www.mathworks.com/access/helpdesk/help/techdoc/ref/atan.html
expositions qu'une atan est asymptotique à +/- pi/2.

Par conséquent, le max de la différence entre deux résultats d'atan est pi ou 180 degrés, si vous utilisez le +/- ou de notation positive 0 to pi la notation d'un gradient.

Considérer le pseudo-code suivant:
```
acuteAngle(m1, m2){
  a = atan(m1) - atan(m2);

  //if obtuse get the complementary acute angle:
  if (a>PI/2) 
    a = PI - a;
  return a;
} 
```
La fonction acuteAngle illustre ce que vous devez faire, mathématiquement.

Toutefois, il ne peut pas être utilisée pour les valeurs d'angles dans le voisinage de PI/2, car les comparaisons binaires des angles avec des résultats dans ce quartier est permis de se demander si obtus ou aigu angle est représenté.

Par conséquent, nous devons comparer les coordonnées des points des deux lignes.
Nous constatons que la 3e ligne formée à partir de [(x2,y2)(x3,y3)] est plus court, égal ou plus long que l'hypothétique hypoténuse.

En vertu du théorème de Pythagore,
L'hypoténuse est formé si l'angle est exactement PI/2 ou 90°. Nous allons appeler son hypothétique de l'hypoténuse ligne L3Hypo.

Par géométriques de visualisation dans votre esprit,
- Si la 3ème ligne est plus longue que
  L3Hypo, l'angle est obtus.
- Si courte, plus l'angle est aigu.
- Sinon, parfait 90.
Par conséquent,
```
L1.lengthSquared = sq(x2-x1) + sq(y2-y1)
L2.lengthSquared = sq(x3-x1) + sq(y3-y1)
L3Hypo.lengthSquared = L1.lengthSquared + L2.lengthSquared
L3.lengthSquared = sq(x3-x2) + sq(y3-y2)
```
Par conséquent, le pseudo-code,
```
struct Point{
  double x, y;
}

//no need to struct, for clarity only
struct Line{
  double lengthSquared;
}

#define sq(n) (n*n)
int isObtuse(Point P1, P2, P3){
  Line L1, L2, L3, L3Hypo;

  L1.lengthSquared = sq(P2.x-P1.x) + sq(P2.y-P1.y);
  L2.lengthSquared = sq(P3.x-P1.x) + sq(P3.y-P1.y);
  L3Hypo.lengthSquared = L1.lengthSquared + L2.lengthSquared;
  L3.lengthSquared = sq(P3.x-P2.x) + sq(P3.y-P2.y);

  if (L3>L3Hypo) return 1; //obtuse
  else if (L3<L3Hypo) return -1; //acute
  else return 0;
}
```
En supposant que vous avez déjà la fonction
getGradient(Point P, Q):
```
double m1m2 = getGradient(P1,P2);
double m1m3 = getGradient(P1,P3);
double a = Abs(atan(m1m2) - atan(m1m3));
if (isObtuse(P1, P2, P3)>0)
  a = PI - a;
```
J'ai peut-être commis quelques erreurs de typo dans le pseudo-code (j'espère pas) mais j'ai fait l'essentiel de la notion. Si oui, quelqu'un pourrait avoir la gentillesse de modifier loin les fautes d'orthographe.

Plus
Cependant, en réfléchissant, je trouve que la lutte pour la précision pivote sur son maillon le plus faible en raison de la directive
```
#define PI 3.14159blah..blah..blah.
```
Donc, on peut très bien enregistrer toutes les difficultés et simplement faire ceci:
```
double m1m2 = getGradient(P1,P2);
double m1m3 = getGradient(P1,P3);
double a = Abs(atan(m1m2) - atan(m1m3));
double b = PI - a;
return min(a, b);//the smaller of the two is the acute
```

Vous devez vous connecter pour publier un commentaire.