c++ - triangulo - Ángulo interno entre dos líneas

como hallar los angulos internos de un triangulo isosceles

Question

Tengo dos líneas: Line1 y Line2. Cada línea está definida por dos puntos (P1L1(x1, y1), P2L1(x2, y2) y P1L1(x1, y1), P2L3(x2, y3)) . Quiero saber el ángulo interno definido por estas dos líneas.

Para hacerlo calculo el ángulo de cada línea con la abscisa:

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

Después de conocer el ángulo, calculo lo siguiente:

double angle = abs(theta2 - theta1);

El problema o duda que tengo es: a veces obtengo el ángulo correcto, pero a veces obtengo el ángulo complementario (para mí externo). ¿Cómo puedo saber cuándo restar 180º para conocer el ángulo interno? Hay algún algoritmo mejor para hacer eso? Porque probé algunos métodos: producto de punto, siguiente fórmula:

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

Pero siempre tengo el mismo problema; ¡Nunca supe cuándo tengo el ángulo exterior o el ángulo interno!

Answer 1

Obtener el ángulo externo frente al ángulo interno está determinado por completo por el orden de tus restas (piénsalo). Debe restar el theta más pequeño del más grande para poder obtener de manera confiable el ángulo interno. También es probable que desee utilizar la función atan2 debido al tipo de datos que está esperando.

Answer 2

if (result > 180)
{
     result = 360 - result;
}

De esa manera siempre será el ángulo interno. Solo agrégalo después de obtener el resultado.

Answer 3

Ángulo interno entre 2 vectores (v1, v2) = arco cos (producto interno (v1, v2) / (módulo (v1) * módulo (v2))).

Donde producto interno (v1, v2) = xv1 * xv2 + yv1 * yv2

módulo (v) = sqrt (pow (xv, 2) + pow (yv, 2))

Entonces, la respuesta de su pregunta se implementa en el siguiente ejemplo:

#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;
}

Answer 4

Espero que entienda su pregunta correctamente como queriendo el ángulo agudo en lugar del ángulo obtuso de la intersección de dos líneas. ¿Estoy en lo correcto?

Los ángulos agudos y obtusos de una intersección son complementos de 180 grados entre sí. es decir

 acute + obtuse = PI.

http://www.mathworks.com/access/helpdesk/help/techdoc/ref/atan.html muestra que un atan es asintótico en +/- pi / 2.

Por lo tanto, la diferencia máxima entre dos resultados de atan es pi o 180 grados, ya sea que use la notación +/- o la notación positiva de 0 to pi de un degradado.

Considera el siguiente pseudocódigo:

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 función acuteAngle ilustra lo que debe hacer, matemáticamente.

Sin embargo, no se puede usar para valores de ángulos en la vecindad de PI / 2 porque las comparaciones binarias de ángulos con resultados en esa vecindad son cuestionables ya sea que se represente un ángulo obtuso o agudo.

Por lo tanto, tenemos que comparar las coordenadas de los puntos de las dos líneas. Descubrimos si la tercera línea formada de [(x2,y2)(x3,y3)] es más corta, igual o más larga que la hipotenusa hipotética.

En virtud del teorema de Pitágoras, se forma una hipotenusa si el ángulo es exactamente PI / 2 o 90 grados. Llamemos a su hipotética hipotenusa línea L3Hypo.

Por visualización geométrica en tu mente,

• Si la tercera línea es más larga que L3Hypo, el ángulo es obtuso.
• Si es más corto, el ángulo es agudo.
• De lo contrario, perfecto 90.

Por lo tanto,

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)

Por lo tanto, el siguiente pseudo-código,

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;
}

Suponiendo que ya tienes la función getGradient (Punto 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;

Pude haber cometido algunos errores tipográficos en el pseudocódigo (ojalá que no) pero demostré la esencia del concepto. Si es así, alguien podría ser tan amable de editar los errores tipográficos.

Además , después de reflexionar sobre ello, encuentro que la lucha por la precisión pivota en su eslabón más débil debido a la directiva

#define PI 3.14159blah..blah..blah.

Por lo tanto, bien podríamos guardar todos los problemas y simplemente hacer esto:

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

Answer 5

Creo que lo que estás buscando es el producto interno (es posible que también desees mirar la entrada del producto escalar) de los dos ángulos. En tu caso, eso viene dado por:

float dx21 = x2-x1;
float dx31 = x3-x1;
float dy21 = y2-y1;
float dy31 = y3-y1;
float m12 = sqrt( dx21*dx21 + dy21*dy21 );
float m13 = sqrt( dx31*dx31 + dy31*dy31 );
float theta = acos( (dx21*dx31 + dy21*dy31) / (m12 * m13) );

La respuesta está en radianes.

EDITAR: Aquí hay una implementación completa. Sustituye los valores problemáticos en p1, p2 y p3 y cuéntame qué obtienes. El punto p1 es el vértice donde se cruzan las dos líneas, de acuerdo con su definición de las dos líneas.

#include <math.h>
#include <iostream>

template <typename T> class Vector2D
{
private:
    T x;
    T y;

public:
    explicit Vector2D(const T& x=0, const T& y=0) : x(x), y(y) {}
    Vector2D(const Vector2D<T>& src) : x(src.x), y(src.y) {}
    virtual ~Vector2D() {}

    // Accessors
    inline T X() const { return x; }
    inline T Y() const { return y; }
    inline T X(const T& x) { this->x = x; }
    inline T Y(const T& y) { this->y = y; }

    // Vector arithmetic
    inline Vector2D<T> operator-() const
        { return Vector2D<T>(-x, -y); }

    inline Vector2D<T> operator+() const
        { return Vector2D<T>(+x, +y); }

    inline Vector2D<T> operator+(const Vector2D<T>& v) const
        { return Vector2D<T>(x+v.x, y+v.y); }

    inline Vector2D<T> operator-(const Vector2D<T>& v) const
        { return Vector2D<T>(x-v.x, y-v.y); }

    inline Vector2D<T> operator*(const T& s) const
        { return Vector2D<T>(x*s, y*s); }

    // Dot product
    inline T operator*(const Vector2D<T>& v) const
        { return x*v.x + y*v.y; }

    // l-2 norm
    inline T norm() const { return sqrt(x*x + y*y); }

    // inner angle (radians)
    static T angle(const Vector2D<T>& v1, const Vector2D<T>& v2)
    {
        return acos( (v1 * v2) / (v1.norm() * v2.norm()) );
    }
};

int main()
{
    Vector2D<double> p1(215, 294);
    Vector2D<double> p2(174, 228);
    Vector2D<double> p3(303, 294);

    double rad = Vector2D<double>::angle(p2-p1, p3-p1);
    double deg = rad * 180.0 / M_PI;

    std::cout << "rad = " << rad << "/tdeg = " << deg << std::endl;

    p1 = Vector2D<double>(153, 457);
    p2 = Vector2D<double>(19, 457);
    p3 = Vector2D<double>(15, 470);

    rad = Vector2D<double>::angle(p2-p1, p3-p1);
    deg = rad * 180.0 / M_PI;

    std::cout << "rad = " << rad << "/tdeg = " << deg << std::endl;

    return 0;
}

El código anterior produce:

rad = 2.12667   deg = 121.849
rad = 0.0939257 deg = 5.38155

Answer 6

El punto es mucho más fácil que las respuestas dadas:

Cuando usas atan (pendiente) pierdes (literalmente) un bit de información, es decir, hay exactamente dos ángulos (theta) y (theta + PI) en el rango (0..2 * PI), que dan el mismo valor para la función tan ().

Simplemente use atan2 (deltax, deltay) y obtendrá el ángulo correcto. Por ejemplo

atan2(1,1) == PI/4
atan2(-1,-1) == 5*PI/4

Luego reste, tome valor absoluto, y si es mayor que PI reste de 2 * PI.

Answer 7

Si usa un valor absoluto, siempre obtendrá el ángulo agudo. Esa es la tangente theta = abs valor de m1-m2 más (1 + m1 * m2). Si toma la tangente inversa, su respuesta será en radianes o grados, sin embargo, la calculadora está configurada. Lo siento, esta no es la jerga de la programación, soy un profesor de matemáticas, no un programador ...

Answer 8

Si desea entre ángulos de 0 grados a 360 grados, utilice el siguiente código; Es completamente probado y funcional:

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;

}

Nota: la rotación será en el sentido de las agujas del reloj;