Векторная операция с Python

Question

Я хотел бы рассчитать c1 в P1Q1 и c2 в P2Q3.

На данный момент у меня есть этот код

def geometric_definition_fuzzy_standard_w(Q1, P1, Q2, P2, Q3):
    O_ = (P1[0] + P2[0]) / 2, (P1[1] + P2[1]) / 2
    OQ2 = Q2[0] - O_[0], Q2[1] - O_[1]
    OP1 = P1[0] - O_[0], P1[1] - O_[1]
    OP2 = P2[0] - O_[0], P2[1] - O_[1]
    P2Q2 = OQ2[0] - OP2[0], OQ2[1] - OP2[1]
    P1Q2 = OQ2[0] + OP2[0], OQ2[1] + OP2[1]
    P1Q1 = OP1[0] + P2Q2[0], OP1[1] + P2Q2[1] # HOW CAN I GET c1???
    P2Q3 = OP2[0] + P1Q2[0], OP2[1] + P1Q2[1] # HOW CAN I GET c2 ???
    longitude_P1Q1 = math.sqrt(P1Q1[0] ** 2 + P1Q1[1] ** 2)
    longitude_P2Q2 = math.sqrt(P2Q2[0] ** 2 + P2Q2[1] ** 2)
    input(longitude_P1Q1)
    input(longitude_P2Q2)

ometric_definition_fuzzy_standard_w ((1, 30), (2, 5 ), (3, 20), (4, 5), (5, 30))

И я вызываю такую ​​функцию

geometric_definition_fuzzy_standard_w((1, 30), (2, 5), (3, 20), (4, 5), (5, 30)) 

Мой вывод

15.132745950421556
15.033296378372908

Answer 1

Не думайте о решении с точки зрения языка программирования

Идея состоит в том, что точка Q1 смещена в координате X на коэффициент расстояния от O до P1, а затем смещена дополнительно на некоторое скаляр c1 в координате XY с множителем вектора, определенного как P2Q2.

Это возможно благодаря тому, что форма W имеет параллельные линии.

Чтобы рассчитать коэффициенты, вам нужно индивидуально рассчитать формулы расстояния и rat ios между каждой парой координат x и y от Q1 до Q2 и от P1 до P2, и аналогично в обратном направлении

Другими словами, какое кратное смещение P2Q2 в координате X равно тому же вектору, что и P1Q1?

Обратите внимание, что существуют неявные точки, скажем, W1 и W2, которые существуют на "y = 0 "и непосредственно под крайними точками Q

Answer 2

Математическая идея, лежащая в основе уравнений для c1 и c2, заключается в демонстрации связи между p1q1 и p2q2 (аналогично p2q3 и p1q2). Обратите внимание, что в отношении стандартной формы W не указано, что p1q1 параллелен p2q2, но что p1q1 является результатом перевода op1 и пропорционален по форме p2q2 (то есть c1). Может быть, изображение помогает понять эту часть. То же самое относится к c2.

Также обратите внимание, что из соотношения следует, что c1 и c2 являются скалярами; Это означает, что пропорциональность должна быть одинаковой в обоих компонентах. Вы не можете разделить векторы, но вы можете разделить их компоненты. Это позволяет вам вычислять c1 и c2 для каждого компонента (таким образом, имея возможность решать каждое уравнение).

Далее я предоставляю код для вычисления c1 и c2 путем вычисления значения от каждого компонента и тестирования, что это то же самое. Для ясности я включил много отладочных сообщений и график для точек ввода. Вы можете отключить их, просто выполнив python -O geometric.py.

Код:

#!/usr/bin/python                                                                                                                                                                                                                           

# -*- coding: utf-8 -*-

# For better print formatting
from __future__ import print_function


# Helper methods
def calculate_vector(p1, p2):
    return p2[0] - p1[0], p2[1] - p1[1]


def add_vectors(v1, v2):
    return v1[0] + v2[0], v1[1] + v2[1]


def draw_points(points):
    import matplotlib.pyplot as plt

    # Draw points
    x_values = [p[0] for p in points]
    y_values = [p[1] for p in points]
    plt.scatter(x_values, y_values)

    # Set chart properties
    plt.title("Geometry")
    plt.xlabel("X")
    plt.ylabel("Y")

    # Show chart
    plt.show()


# Main method
def geometric_definition_fuzzy_standard_w(q1, p1, q2, p2, q3):
    # Calculate O
    if __debug__:
        print ("Calculating O...")
    o = (p1[0] + p2[0])/2, (p1[1] + p2[1])/2
    if __debug__:
        print ("O: " + str(o))

    # Calculate vectors
    if __debug__:
        print ("Calculating vectors...")
    p1q2 = calculate_vector(p1, q2)
    oq2 = calculate_vector(o, q2)
    op2 = calculate_vector(o, p2)

    p1q1 = calculate_vector(p1, q1)
    op1 = calculate_vector(o, p1)
    p2q2 = calculate_vector(p2, q2)

    p2q3 = calculate_vector(p2, q3)
    p1q2 = calculate_vector(p1, q2)

    if __debug__:
        print("POINTS:")
        print ("Q1: " + str(q1))
        print ("P1: " + str(p1))
        print ("Q2: " + str(q2))
        print ("P2: " + str(p2))
        print ("Q3: " + str(q3))
        print ("0:  " + str(o))
        print()
        print("P1Q2 = OQ2 + OP2")
        print ("P1Q2: " + str(p1q2))
        print ("OQ2:  " + str(oq2))
        print ("OP2:  " + str(op2))
        print()
        print("P1Q1 = OP1 + c1*P2Q2")
        print ("P1Q1: " + str(p1q1))
        print ("OP1:  " + str(op1))
        print ("P2Q2: " + str(p2q2))
        print()
        print("P2Q3 = OP2 + c2*P1Q2")
        print ("P2Q3: " + str(p2q3))
        print ("OP2:  " + str(op2))
        print ("P1Q2: " + str(p1q2))
        print ()

    # Assert that p1q2 = oq2 + op2
    if __debug__:
        print("Checking p1q2 = oq2 + op2...")
    p1q2_calculated = add_vectors(oq2, op2)
    if p1q2_calculated != p1q2:
        print ("ERROR: Assert p1q2 = oq2 + op2 invalid")
    else:
        print ("p1q2 = oq2 + op2 OK")

    # Calculate c1
    if __debug__:
        print ("Calculating c1...")
    c1_0 = (p1q1[0] - op1[0])/p2q2[0]
    c1_1 = (p1q1[1] - op1[1])/p2q2[1]
    if c1_0 != c1_1:
        print ("ERROR: C1 is different for each component (" + str(c1_0) + " != " + str(c1_1) + ")")
    else:
        print ("c1 = " + str(c1_0))

    # Calculate c2
    if __debug__:
        print ("Calculating c2...")
    c2_0 = (p2q3[0] - op2[0])/p1q2[0]
    c2_1 = (p2q3[1] - op2[1])/p1q2[1]
    if c2_0 != c2_1:
        print ("ERROR: C2 is different for each component (" + str(c2_0) + " != " + str(c2_1) + ")")
    else:
        print ("c2 = " + str(c2_0))


    # Draw points
    if __debug__:
        draw_points([q1, p1, q2, p2, q3, o])

    # Return c1 and c2
    return c1_0, c2_0


# Entry point
if __name__ == "__main__":
    P1 = (15, 0)
    P2 = (25, 0)
    Q1 = (0, 10)
    Q2 = (20, 5)
    Q3 =(40, 10)
    C1, C2 = geometric_definition_fuzzy_standard_w(Q1, P1, Q2, P2, Q3)

    #geometric_definition_fuzzy_standard_w((1, 30), (2, 5), (3, 20), (4, 5), (5, 30))

Отладочный вывод:

Calculating O...
O: (20, 0)
Calculating vectors...
POINTS:
Q1: (0, 10)
P1: (15, 0)
Q2: (20, 5)
P2: (25, 0)
Q3: (40, 10)
0:  (20, 0)

P1Q2 = OQ2 + OP2
P1Q2: (5, 5)
OQ2:  (0, 5)
OP2:  (5, 0)

P1Q1 = OP1 + c1*P2Q2
P1Q1: (-15, 10)
OP1:  (-5, 0)
P2Q2: (-5, 5)

P2Q3 = OP2 + c2*P1Q2
P2Q3: (15, 10)
OP2:  (5, 0)
P1Q2: (5, 5)

Checking p1q2 = oq2 + op2...
p1q2 = oq2 + op2 OK
Calculating c1...
c1 = 2
Calculating c2...
c2 = 2

Производительность:

p1q2 = oq2 + op2 OK
c1 = 2
c2 = 2

Answer 3

Поскольку речь идет о стандартной форме W , вы знаете, что P1Q1 параллелен P2Q2.

Так что c1 - это просто отношение длин P1Q1 и P2Q2.

IOW: сколько вам нужно масштабировать P2Q2, чтобы вы были P1Q1 длиной.