puntos - ¿Cálculo del ángulo entre dos líneas sin tener que calcular la pendiente?(Java)

calcular angulos con coordenadas

Question

Tengo dos líneas: L1 y L2. Quiero calcular el ángulo entre las dos líneas. L1 tiene puntos: {(x1, y1), (x2, y2)} y L2 tiene puntos: {(x3, y3), (x4, y4)} .

¿Cómo puedo calcular el ángulo formado entre estas dos líneas, sin tener que calcular las pendientes? El problema que tengo actualmente es que a veces tengo líneas horizontales (líneas a lo largo del eje x) y la siguiente fórmula falla (división por cero):

arctan((m1 - m2) / (1 - (m1 * m2)))

donde m1 y m2 son las pendientes de la línea 1 y la línea 2 respectivamente. ¿Hay una fórmula / algoritmo que pueda calcular los ángulos entre las dos líneas sin obtener excepciones de división por cero? Cualquier ayuda sería muy apreciada.

Este es mi fragmento de código:

// Calculates the angle formed between two lines
public static double angleBetween2Lines(Line2D line1, Line2D line2)
{
    double slope1 = line1.getY1() - line1.getY2() / line1.getX1() - line1.getX2();
    double slope2 = line2.getY1() - line2.getY2() / line2.getX1() - line2.getX2();
    double angle = Math.atan((slope1 - slope2) / (1 - (slope1 * slope2)));
    return angle;
}

Gracias.

Answer 1

Comprueba este código de Python:

import math
def angle(x1,y1,x2,y2,x3,y3):

  if (x1==x2==x3 or y1==y2==y3):
    return 180
  else:
    dx1 = x2-x1
    dy1 = y2-y1
    dx2 = x3-x2
    dy2 = y3-y2
    if x1==x2:
      a1=90
    else:
      m1=dy1/dx1
      a1=math.degrees(math.atan(m1))
    if x2==x3:
      a2=90
    else:
      m2=dy2/dx2
      a2=math.degrees(math.atan(m2))
    angle = abs(a2-a1)
    return angle

print angle(0,4,0,0,9,-6)

Answer 2

El producto de puntos es probablemente más útil en este caso. Here puede encontrar un paquete de geometría para Java que proporciona algunos ayudantes útiles. A continuación se muestra su cálculo para determinar el ángulo entre dos puntos tridimensionales. Espero que te haga comenzar:

public static double computeAngle (double[] p0, double[] p1, double[] p2)
{
  double[] v0 = Geometry.createVector (p0, p1);
  double[] v1 = Geometry.createVector (p0, p2);

  double dotProduct = Geometry.computeDotProduct (v0, v1);

  double length1 = Geometry.length (v0);
  double length2 = Geometry.length (v1);

  double denominator = length1 * length2;

  double product = denominator != 0.0 ? dotProduct / denominator : 0.0;

  double angle = Math.acos (product);

  return angle;
}

¡Buena suerte!

Answer 3

La fórmula para obtener el ángulo es tan a = (slope1-slope2)/(1+slope1*slope2)

Tu estas usando:

tan a = (slope1 - slope2) / (1 - slope1 * slope2)

Entonces debería ser:

double angle = Math.atan((slope1 - slope2) / (1 + slope1 * slope2));

Answer 4

La función atan2 alivia el dolor de lidiar con atan .

Se declara como double atan2(double y, double x) y convierte las coordenadas rectangulares (x,y) en el ángulo theta de las coordenadas polares (r,theta)

Así que reescribí tu código como

public static double angleBetween2Lines(Line2D line1, Line2D line2)
{
    double angle1 = Math.atan2(line1.getY1() - line1.getY2(),
                               line1.getX1() - line1.getX2());
    double angle2 = Math.atan2(line2.getY1() - line2.getY2(),
                               line2.getX1() - line2.getX2());
    return angle1-angle2;
}

Answer 5

Primero, ¿estás seguro de que los corchetes están en el orden correcto? Creo (podría estar mal) debería ser esto:

   double slope1 = (line1.getY1() - line1.getY2()) / (line1.getX1() - line1.getX2());
   double slope2 = (line2.getY1() - line2.getY2()) / (line2.getX1() - line2.getX2());

En segundo lugar, hay dos cosas que podrías hacer por el div por cero: podrías atrapar la excepción y manejarla

double angle;
try
{
    angle = Math.atan((slope1 - slope2) / (1 - (slope1 * slope2)));
catch (DivideByZeroException dbze)
{
    //Do something about it!
}

... o podría verificar que sus divisores nunca sean cero antes de intentar la operación.

if ((1 - (slope1 * slope2))==0)
{
    return /*something meaningful to avoid the div by zero*/
}
else 
{
    double angle = Math.atan((slope1 - slope2) / (1 - (slope1 * slope2)));
    return angle;
 }

Answer 6

Tal vez mi enfoque para el sistema de coordenadas de Android sea útil para alguien (use la clase PointF de Android para almacenar puntos)

/**
 * Calculate angle between two lines with two given points
 *
 * @param A1 First point first line
 * @param A2 Second point first line
 * @param B1 First point second line
 * @param B2 Second point second line
 * @return Angle between two lines in degrees
 */

public static float angleBetween2Lines(PointF A1, PointF A2, PointF B1, PointF B2) {
    float angle1 = (float) Math.atan2(A2.y - A1.y, A1.x - A2.x);
    float angle2 = (float) Math.atan2(B2.y - B1.y, B1.x - B2.x);
    float calculatedAngle = (float) Math.toDegrees(angle1 - angle2);
    if (calculatedAngle < 0) calculatedAngle += 360;
    return calculatedAngle;
}

Devuelve un valor positivo en grados para cualquier cuadrante: 0 <= x <360

Puede verificar mi clase de utilidad aquí

Answer 7

dx1 = x2-x1; dy1 = y2-y1; dx2 = x4-x3; dy2 = y4-y3; d = dx1*dx2 + dy1*dy2; // dot product of the 2 vectors l2 = (dx1*dx1+dy1*dy1)*(dx2*dx2+dy2*dy2) // product of the squared lengths angle = acos(d/sqrt(l2));

El producto escalar de 2 vectores es igual al coseno del ángulo de tiempo que la longitud de ambos vectores. Esto calcula el producto escalar, se divide por la longitud de los vectores y usa la función del coseno inverso para recuperar el ángulo.