How to calculate two orthogonal points of a line?

Question

I need two new points, which are on a new orthogonal line through point 1 and in distance of meters s and minus s for the other direction. The new orthogonal line is orthogonal to a line given by two points shown in "coords".

I have tried to reuse results from here and here, but both example are somehow different. These examples state that I should work with the vector from the line and that the orthognal of the vector m is given by -1/m or a new point by y = (-1/m)x + b

import math as m

coords=([5,5], [5,6])
print (coords)

x1,y1=coords[0]
x2,y2=coords[1]

s= 5
veclen= m.sqrt(m.pow(x2-x1,2)+m.pow(y2-y1,2))
u=(x2-x1)/veclen
v=(y2-y1)/veclen
print ("u,v:", u,v)

dir1 = (v, -u)
dir2 = (-v, u)


newpoint1=(x1+ s*dir1[0], y1+ s*dir1[1])
newpoint2=(x1+ s*dir2[0], y1+ s*dir2[1])

print (newpoint1, newpoint2)

xn,yn=newpoint1

dist = m.hypot(xn-x1, yn-y1)

print (dist)

This is maybe the right direction, but somehow I do not understand the derived vector 1 (v) and the orthogonal vector (v2) and how to add from point x1,y1 the distance s. Should the vector 1 not be (1,1), as in +1 in x-direction and +1 in y-direction? And likewise the orthogonal vector 2 (1, -1) as in +1 in x and -1 in y?

And is the calculation of both newpoints correct?

Answer 1

I will assume that this is the problem, in one sentence:

Code a routine that is given a tuple coords containing two 2-dimensional points and also given a positive number s, and the routine returns two other distinct points such that the line segment between each output point and coords[0] is orthogonal (perpendicular) to the line segment between coords[0] and coords[1] and the distance from each output point to coords[0] is s.

Now for your questions.

The 2-tuple v represents the vector of length one (the "unit vector") that is parallel to the vector from point coords[0] to point coords[1]. It is found by first subtracting the coordinates of the two points in coords, but that vecto will probably have the wrong length. So your code beforehand found the length of that vector in variable l (a terrible name for a variable) and divides the vector by l. Mathematics tells us that the resulting vector is parallel to the original vector and has length one.

Your code then tries to find a perpendicular unit vector. It fails in two ways. First, it does not use the unit vector; it uses the original vector instead. Second, the new vector is not necessarily perpendicular. Your code says a vector perpendicular to (u, v) is (-u, v), but actually the perpendicular vector is either (v, -u) or (-v, u)--note the swapped coordinates. This new vector is both perpendicular to the previous vector and has the same length.

Therefore the calculation of the two new points is not correct.

I have answered your given questions--let me know if you need code that actually does what you want. Note that you should improve your code by using longer, descriptive variable names and comments and by wrapping up the code into a function. The function should return the points, while the calling routine could print the results.

---

Here is my code that satisfies your problem. I reduced the amount of printing as checks--you can print more checks, if you like. I also combined some lines, since too many separate computation lines can worsen the accuracy of floating-point calculations. I never compute a unit vector--I go straight to a vector of the desired length.

import math

def orthogonal_points(coords, s):
    """Given a tuple coords containing two 2-dimensional points and also
    given a positive number s, return two other distinct points such
    that the line segment between each output point and coords[0] is
    orthogonal (perpendicular) to the line segment between coords[0] and
    coords[1] and the distance from each output point to coords[0] is s.
    """
    (point1x, point1y), (point2x, point2y) = coords
    points_vectorx, points_vectory = point2x - point1x, point2y - point1y
    points_vector_length = math.hypot(points_vectorx, points_vectory)
    normalized_x, normalized_y = (points_vectorx * s / points_vector_length,
                                  points_vectory * s / points_vector_length)
    newpoint1x, newpoint1y = point1x + normalized_y, point1y - normalized_x
    newpoint2x, newpoint2y = point1x - normalized_y, point1y + normalized_x
    return ([newpoint1x, newpoint1y], [newpoint2x, newpoint2y])


coords=([5,5], [5,6])
s= 5

print (coords, s)
print (orthogonal_points(coords, s))

The output from that is correct:

([5, 5], [5, 6]) 5
([10.0, 5.0], [0.0, 5.0])