Comment puis-je calculer le point d'intersection de deux lignes en Python?

j'ai deux lignes qui se coupent en un point. Je connais les effets des deux lignes. Comment calculer le point d'intersection 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]
30
demandé sur Jeffrey Bosboom 2013-12-19 13:29:24

4 réponses

contrairement à d'autres suggestions, celle-ci est courte et n'utilise pas de bibliothèques externes comme numpy. (Non pas que l'utilisation d'autres bibliothèques est mauvais...c'est bon pas besoin de le faire, surtout pour un problème 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))

et pour info, j'utiliserais des tuples au lieu de listes pour vos points. E. g.

A = (X, Y)
28
répondu Paul Draper 2014-09-12 21:45:16

vous ne Pouvez pas rester à l'écart,

nous avons donc un système linéaire:

1 * x + B1 * y = C1

2 * x + B2 * y = C2

nous allons le faire avec de la règle de Cramer, de sorte que la solution peut être trouvée dans déterminants:

x = D x / D

y = Do / D

où D est le principal déterminant du système:

1 B1

2 B2

et D x et Do peut être trouvé à partir de matricies:

C1 B1

C2 B2

et

1 C1

2 C2

(avis, comme C la colonne remplace donc la coef. les colonnes de x et o)

alors maintenant le python, pour la clarté pour nous, pour ne pas gâcher les choses, faisons un mapping entre les maths et python. Que nous grognonnassions tableau L pour le stockage de nos coefs , B, C de la ligne d'équations et intestead de jolies x,y nous aurons [0],[1], mais de toute façon. Ainsi, ce que j'ai écrit ci-dessus aura la forme suivante plus loin dans le code:

D

L1[0] L1[1]

L2[0] L2[1]

D x

L1[2] L1[1]

L2[2] L2[1]

Do

L1[0] L1[2]

L2[0] L2[2]

maintenant, passez au codage:

line - produit des coefs , B, C de l'équation de droite par deux points,

intersection - recherche des points d'intersection (le cas échéant) de deux lignes fournies par 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

exemple d'Utilisation:

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"
43
répondu rook 2013-12-19 10:46:47

Je n'ai pas trouvé d'explication intuitive sur le web, alors maintenant que j'ai compris, voici ma solution. C'est pour les lignes infinies (ce dont j'avais besoin), pas pour les segments.

Quelques conditions que vous vous souvenez peut-être:

une ligne est définie comme y = mx + b ou y = Pente * x + y-intercept

Pente = montée sur course = dy / dx = hauteur / distance

l'ordonnée à l'origine est l'endroit où la ligne croise l'axe des Y, où X = 0

donnée ces définitions, voici quelques fonctions:

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

voici un test simple entre deux lignes (infinies):

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))

Sortie:

(2.0, 2.0)
1
répondu Kiki Jewell 2017-09-18 21:50:17

en utilisant la formule 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]
1
répondu Gabriel Eng 2018-07-01 23:31:52