imprimir - ¿Cómo calculo el punto de intersección de dos líneas en Python?

tipos de variables en python

Question

Tengo dos líneas que se cruzan en un punto. Conozco los puntos finales de las dos líneas. ¿Cómo calculo el punto de intersección en Python?

# Given these endpoints
#line 1
A = [X, Y]
B = [X, Y]

#line 2
C = [X, Y]
D = [X, Y]

# Compute this:
point_of_intersection = [X, Y]

Answer 1

A diferencia de otras sugerencias, esto es breve y no utiliza bibliotecas externas como numpy . (No es malo usar otras bibliotecas ... no es necesario, especialmente para un problema tan simple).

def line_intersection(line1, line2):
    xdiff = (line1[0][0] - line1[1][0], line2[0][0] - line2[1][0])
    ydiff = (line1[0][1] - line1[1][1], line2[0][1] - line2[1][1]) #Typo was here

    def det(a, b):
        return a[0] * b[1] - a[1] * b[0]

    div = det(xdiff, ydiff)
    if div == 0:
       raise Exception(''lines do not intersect'')

    d = (det(*line1), det(*line2))
    x = det(d, xdiff) / div
    y = det(d, ydiff) / div
    return x, y

print line_intersection((A, B), (C, D))

Y para tu información, usaría tuplas en lugar de listas para tus puntos. P.ej

A = (X, Y)

Answer 2

No encontré una explicación intuitiva en la web, así que ahora que la resolví, aquí está mi solución. Esto es para líneas infinitas (lo que necesitaba), no segmentos.

Algunos términos que quizás recuerdes:

Una línea se define como y = mx + b O y = pendiente * x + intercepción y

Pendiente = aumento sobre carrera = dy / dx = altura / distancia

La intersección con Y es donde la línea cruza el eje Y, donde X = 0

Dadas esas definiciones, aquí hay algunas funciones:

def slope(P1, P2):
    # dy/dx
    # (y2 - y1) / (x2 - x1)
    return(P2[1] - P1[1]) / (P2[0] - P1[0])

def y_intercept(P1, slope):
    # y = mx + b
    # b = y - mx
    # b = P1[1] - slope * P1[0]
    return P1[1] - slope * P1[0]

def line_intersect(m1, b1, m2, b2):
    if m1 == m2:
        print ("These lines are parallel!!!")
        return None
    # y = mx + b
    # Set both lines equal to find the intersection point in the x direction
    # m1 * x + b1 = m2 * x + b2
    # m1 * x - m2 * x = b2 - b1
    # x * (m1 - m2) = b2 - b1
    # x = (b2 - b1) / (m1 - m2)
    x = (b2 - b1) / (m1 - m2)
    # Now solve for y -- use either line, because they are equal here
    # y = mx + b
    y = m1 * x + b1
    return x,y

Aquí hay una prueba simple entre dos líneas (infinitas):

A1 = [1,1]
A2 = [3,3]
B1 = [1,3]
B2 = [3,1]
slope_A = slope(A1, A2)
slope_B = slope(B1, B2)
y_int_A = y_intercept(A1, slope_A)
y_int_B = y_intercept(B1, slope_B)
print(line_intersect(slope_A, y_int_A, slope_B, y_int_B))

Salida:

(2.0, 2.0)

Answer 3

No puedo estar a un lado,

Así que tenemos sistema lineal:

A ₁ * x + B ₁ * y = C ₁
A ₂ * x + B ₂ * y = C ₂

hagámoslo con la regla de Cramer, para encontrar una solución en los determinantes:

x = D _x / D
y = D _y / D

donde D es el principal determinante del sistema:

A ₁ B ₁
A ₂ B ₂

y D _x y D _y se pueden encontrar a partir de matricies:

C ₁ B ₁
C ₂ B ₂

y

A ₁ C ₁
A ₂ C ₂

(fíjese que la columna C sustituye las columnas coef. de x e y )

Así que ahora el python, para mayor claridad para nosotros, para no desordenar las cosas, hagamos mapeo entre math y python. Usaremos la matriz L para almacenar nuestros coefs A , B , C de las ecuaciones de línea y en lugar de la bonita x , y tendremos [0] , [1] , pero de todos modos. Por lo tanto, lo que escribí anteriormente tendrá la siguiente forma en el código:

para D

L1 [0] L1 [1]
L2 [0] L2 [1]

para D _x

L1 [2] L1 [1]
L2 [2] L2 [1]

para D _y

L1 [0] L1 [2]
L2 [0] L2 [2]

Ahora vaya para la codificación:

line : produce los coefs A , B , C de la ecuación de línea por dos puntos proporcionados,
intersection : encuentra el punto de intersección (si existe) de dos líneas proporcionadas por los coefs.

from __future__ import division 

def line(p1, p2):
    A = (p1[1] - p2[1])
    B = (p2[0] - p1[0])
    C = (p1[0]*p2[1] - p2[0]*p1[1])
    return A, B, -C

def intersection(L1, L2):
    D  = L1[0] * L2[1] - L1[1] * L2[0]
    Dx = L1[2] * L2[1] - L1[1] * L2[2]
    Dy = L1[0] * L2[2] - L1[2] * L2[0]
    if D != 0:
        x = Dx / D
        y = Dy / D
        return x,y
    else:
        return False

Ejemplo de uso:

L1 = line([0,1], [2,3])
L2 = line([2,3], [0,4])

R = intersection(L1, L2)
if R:
    print "Intersection detected:", R
else:
    print "No single intersection point detected"

Answer 4

Usando la fórmula de: https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection

 def findIntersection(x1,y1,x2,y2,x3,y3,x4,y4):
        px= ( (x1*y2-y1*x2)*(x3-x4)-(x1-x2)*(x3*y4-y3*x4) ) / ( (x1-x2)*(y3-y4)-(y1-y2)*(x3-x4) ) 
        py= ( (x1*y2-y1*x2)*(y3-y4)-(y1-y2)*(x3*y4-y3*x4) ) / ( (x1-x2)*(y3-y4)-(y1-y2)*(x3-x4) )
        return [px, py]