返回給定兩點的直線方程的方法

Question

我有一個 class Point ，由一個具有 x 和 y 坐標的點組成，我必須編寫一個方法來計算並返回連接Point object 和另一個作為參數傳遞的Point object 的直線方程 ( my_point.get_straight_line(my_point2) 。我知道如何在紙上用 yy ₁ = m(xx ₁ ) 計算它，並且我已經有一個方法my_point.slope(my_point2)來計算m ，但我真的不知道如何計算將等式轉換為 Python。這是整個 class：

class Point:
    def __init__(self,initx,inity):
        self.x = initx
        self.y = inity

    def getx(self):
        return self.x

    def gety(self):
        return self.y

    def negx(self):
        return -(self.x)

    def negy(self):
        return -(self.y)

    def __str__(self):
        return 'x=' + str(self.x) + ', y=' + str(self.y)

    def halfway(self,target):
        midx = (self.x + target.x) / 2
        midy = (self.y + target.y) / 2
        return Point(midx, midy)

    def distance(self,target):
        xdiff = target.x - self.x
        ydiff = target.y - self.y
        dist = math.sqrt(xdiff**2 + ydiff**2)
        return dist

    def reflect_x(self):
        return Point(self.negx(),self.y)

    def reflect_y(self):
        return Point(self.x,self.negy())

    def reflect_x_y(self):
        return Point(self.negx(),self.negy())

    def slope_from_origin(self):
        if self.x == 0:
            return None
        else:
            return self.y / self.x

    def slope(self,target):
        if target.x == self.x:
            return None
        else:
            m = (target.y - self.y) / (target.x - self.x)
            return m

任何幫助表示贊賞。

編輯：我用一個計算c的方程式計算出來，然后將它與self.slope(target)一起返回到一個字符串中。 事實證明這比我想象的要簡單得多。

def get_line_to(self,target):
    c = -(self.slope(target)*self.x - self.y)
    return 'y = ' + str(self.slope(target)) + 'x + ' + str(c)

Answer 1

from numpy import ones,vstack
from numpy.linalg import lstsq
points = [(1,5),(3,4)]
x_coords, y_coords = zip(*points)
A = vstack([x_coords,ones(len(x_coords))]).T
m, c = lstsq(A, y_coords)[0]
print("Line Solution is y = {m}x + {c}".format(m=m,c=c))

但真的你的方法應該沒問題......

Answer 2

我們假設我們有以下幾點：

P0：（x0 = 100，y0 = 240）

P1：（x1 = 400，y1 = 265）

我們可以使用numpy中的polyfit方法計算連接兩點的線y = a * x + b的系數。

import numpy as np
import matplotlib.pyplot as plt

# Define the known points
x = [100, 400]
y = [240, 265]

# Calculate the coefficients. This line answers the initial question. 
coefficients = np.polyfit(x, y, 1)

# Print the findings
print 'a =', coefficients[0]
print 'b =', coefficients[1]

# Let's compute the values of the line...
polynomial = np.poly1d(coefficients)
x_axis = np.linspace(0,500,100)
y_axis = polynomial(x_axis)

# ...and plot the points and the line
plt.plot(x_axis, y_axis)
plt.plot( x[0], y[0], 'go' )
plt.plot( x[1], y[1], 'go' )
plt.grid('on')
plt.show()

a = 0.0833333333333

b = 231.666666667

---

用於安裝numpy： http ： //docs.scipy.org/doc/numpy/user/install.html

Answer 3

我認為你正在制作相當高級的代碼，但是你讓它變得復雜。 這是一個可以做到這一點的函數：

from decimal import Decimal


def lin_equ(l1, l2):
    """Line encoded as l=(x,y)."""
    m = Decimal((l2[1] - l1[1])) / Decimal(l2[0] - l1[0])
    c = (l2[1] - (m * l2[0]))
    return m, c

# Example Usage:
lin_equ((-40, 30,), (20, 45))

# Result: (Decimal('0.25'), Decimal('40.00'))

Answer 4

我把它清理了一下; 看看你的想法。

def slope(dx, dy):
    return (dy / dx) if dx else None

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return '({}, {})'.format(self.x, self.y)

    def __repr__(self):
        return 'Point({}, {})'.format(self.x, self.y)

    def halfway(self, target):
        midx = (self.x + target.x) / 2
        midy = (self.y + target.y) / 2
        return Point(midx, midy)

    def distance(self, target):
        dx = target.x - self.x
        dy = target.y - self.y
        return (dx*dx + dy*dy) ** 0.5

    def reflect_x(self):
        return Point(-self.x,self.y)

    def reflect_y(self):
        return Point(self.x,-self.y)

    def reflect_x_y(self):
        return Point(-self.x, -self.y)

    def slope_from_origin(self):
        return slope(self.x, self.y)

    def slope(self, target):
        return slope(target.x - self.x, target.y - self.y)

    def y_int(self, target):       # <= here's the magic
        return self.y - self.slope(target)*self.x

    def line_equation(self, target):
        slope = self.slope(target)

        y_int = self.y_int(target)
        if y_int < 0:
            y_int = -y_int
            sign = '-'
        else:
            sign = '+'

        return 'y = {}x {} {}'.format(slope, sign, y_int)

    def line_function(self, target):
        slope = self.slope(target)
        y_int = self.y_int(target)
        def fn(x):
            return slope*x + y_int
        return fn

以下是一些使用示例：

a = Point(2., 2.)
b = Point(4., 3.)

print(a)                   # => (2.0, 2.0)
print(repr(b))             # => Point(4.0, 3.0)
print(a.halfway(b))        # => (3.0, 2.5)

print(a.slope(b))          # => 0.5
print(a.y_int(b))          # => 1.0
print(a.line_equation(b))  # => y = 0.5x + 1.0

line = a.line_function(b)
print(line(x=6.))          # => 4.0

Answer 5

class Line(object):

    def __init__(self,coor1,coor2):
        self.coor1 = coor1
        self.coor2 = coor2


    def distance(self):
        x1,y1 = self.coor1
        x2,y2 = self.coor2
        return ((x2-x1)**2+(y2-y1)**2)**0.5    

    def slope(self):
        x1,x2 = self.coor1
        y1,y2 = self.coor2
        return (float(y2-y1))/(x2-x1)

Answer 6

l=[1,1,2,2]
#l=[x1,y1,x2,y2]
y0=l[3]-l[1]
x0=l[0]-l[2]
c = l[1]*l[2]-l[0]*l[3]
if(x0>0):
    print(y0,"x","+",x0,"y=",c)
else:
    print(y0,"x",x0,"y=",c)