Vectors and Transformations

Two points can look identical on paper yet mean different things: (4, 3) as a place is a spot on the plane, but (4, 3) as a vector is a move - go 4 across and 3 up - that you can apply starting from anywhere. That double life trips up beginners, so hold the distinction firmly: a point answers where, a vector answers which way and how far.

You get a vector by subtracting one point from another. The vector from a to b is (b[0] - a[0], b[1] - a[1]) - exactly the dx, dy you used for distance, now treated as a thing in its own right. Its magnitude (length) is that same math.hypot, and its direction is the way it points.

import math

def vector(a, b):
    return (b[0] - a[0], b[1] - a[1])   # the move from a to b

def magnitude(v):
    return math.hypot(v[0], v[1])

v = vector((2, 1), (6, 4))
print(v)              # (4, 3)
print(magnitude(v))   # 5.0

The payoff of thinking in moves is reuse: the vector from a door to its handle is the same move whether the door is here or across the building, so you compute it once and apply it wherever the door lands. That is the seed of copying and arraying geometry, which the rest of the lesson grows.

Two more ideas make vectors easier to reason about. A vector has a direction independent of its length: divide a vector by its magnitude and you get a unit vector, a pure direction of length one, useful whenever you care about which way something points but not how far. And because a vector is just its components, it works the same in 3D - (dx, dy, dz) - so everything here carries straight into three dimensions with one extra number, exactly as points did in the last lesson.

def unit(v):
    m = magnitude(v)
    return (v[0] / m, v[1] / m)   # same direction, length 1

print(unit((3, 4)))   # (0.6, 0.8)

Think of a unit vector as an arrow that only tells you a heading. Multiply it by any length and you get a move of exactly that distance in that direction - which is precisely how you step along a wall, offset a line, or march a fixed distance toward a target.

Two operations make vectors useful, and both are just componentwise arithmetic. Adding two vectors means doing one move then the other: add the x parts and add the y parts. Scaling a vector by a number stretches or shrinks the move while keeping its direction: multiply both parts by the number.

def add(u, v):
    return (u[0] + v[0], u[1] + v[1])

def scale(v, k):
    return (v[0] * k, v[1] * k)

step = (5, 0)                 # move 5 to the right
print(add((1, 1), step))      # (6, 1): start at (1,1), apply the move
print(scale(step, 3))         # (15, 0): the same move, three times as far

These two little functions already do real work. To translate (slide) a point, add a vector to it. To place a row of copies along a wall, scale a step vector by 0, 1, 2, 3 and add each to a start point - which is exactly an array command written as arithmetic.

start = (0, 0)
step = (2.5, 0)
row = [add(start, scale(step, i)) for i in range(5)]
print(row)   # [(0.0, 0.0), (2.5, 0.0), (5.0, 0.0), (7.5, 0.0), (10.0, 0.0)]

Change step to (0, 3) and the row becomes a column; change it to (2, 2) and it marches diagonally. The array logic never changes - only the vector does. This is the first taste of how much geometry collapses into add and scale.

Subtracting vectors is just as useful as adding them, and it is where the point-versus-vector distinction pays off. Subtracting one point from another gives the move between them (which is how vector above works); subtracting two vectors gives the difference in their moves. A neat consequence: the midpoint of two points is their average, which you can read as start, then go half the way there.

def midpoint(a, b):
    return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)

print(midpoint((0, 0), (4, 6)))   # (2.0, 3.0)

Generalise that halfway idea and you can find any point along a line between two others - a quarter of the way, three-fifths of the way - by scaling the move and adding it to the start. This single pattern, called linear interpolation, is how you distribute points evenly along an edge, place balusters on a stair, or blend between two values, and it is nothing more than the add-and-scale you just met.

Sometimes you do not want to move geometry but to ask about it: are these two walls parallel, is this panel facing the sun, what is the angle between two directions? The tool for that is the dot product - one number computed from two vectors that quietly encodes the angle between them. You multiply matching components and add: u[0]*v[0] + u[1]*v[1].

The useful facts are simple. If the dot product is zero, the vectors are perpendicular. If it is positive, they point broadly the same way; if negative, broadly opposite. And divided by the two magnitudes it gives the cosine of the angle, so math.acos recovers the angle itself.

import math

def dot(u, v):
    return u[0] * v[0] + u[1] * v[1]

def angle_between(u, v):
    cos_t = dot(u, v) / (math.hypot(*u) * math.hypot(*v))
    return math.degrees(math.acos(cos_t))

print(dot((1, 0), (0, 1)))        # 0  -> perpendicular
print(round(angle_between((1, 0), (1, 1)), 1))   # 45.0

This is the one place a little trigonometry earns its keep, and you rarely compute the sines and cosines yourself - math does. With angle_between you can check whether elements are square to each other, sort directions, or find how far a surface normal is off from due south. It is a small function that answers a surprising number of spatial questions.

The dot product has a second, quieter use: projection - how much of one vector points along another. That is exactly what you need to find how far a point lies along a wall, or the shadow one direction casts on another, and it too is built from the same multiply-and-add. You will not need the projection formula today, but it is worth knowing that this one small operation - a couple of multiplications and an addition - is doing the heavy lifting behind angles, perpendicularity checks and projections alike.

Almost every operation in a modeller is one of three transformations: translate (slide), rotate (turn), and scale (resize). You have already met translate - it is just adding a vector. Scale multiplies coordinates by a factor, usually about a chosen centre. Rotate is the one that needs trigonometry: to turn a point by an angle you combine its coordinates with the sine and cosine of that angle.

import math

def translate(p, dx, dy):
    return (p[0] + dx, p[1] + dy)

def scale(p, k, about=(0, 0)):
    return (about[0] + (p[0] - about[0]) * k,
            about[1] + (p[1] - about[1]) * k)

def rotate(p, degrees, about=(0, 0)):
    a = math.radians(degrees)
    x, y = p[0] - about[0], p[1] - about[1]
    rx = x * math.cos(a) - y * math.sin(a)
    ry = x * math.sin(a) + y * math.cos(a)
    return (rx + about[0], ry + about[1])

print(rotate((1, 0), 90))   # (~0.0, 1.0): a quarter turn

Notice the shared pattern in scale and rotate: shift so the centre is at the origin, do the maths, shift back. That move-to-origin, act, move-back sandwich is how every transformation about an arbitrary point works, and it explains a common source of confusion - rotate or scale without choosing a centre and everything happens about the origin (0, 0), which can fling your geometry far across the drawing. Deciding the pivot deliberately is half of getting transformations right.

Order matters, too, and this trips up beginners constantly. Rotating then translating is not the same as translating then rotating - the second turns the shape about a different effective point. Whenever a transformed result lands somewhere surprising, the cause is almost always the order of operations or the choice of centre, not the arithmetic. Apply a transform to every point of a shape and the whole shape moves together.

room = [(0, 0), (4, 0), (4, 3), (0, 3)]
turned = [rotate(p, 30) for p in room]
copies = [[translate(p, i * 5, 0) for p in room] for i in range(4)]
print(len(copies))   # 4 copies of the room, 5 units apart

If translate, rotate and scale are each a bit of arithmetic, why does every graphics textbook and every CAD API talk about matrices? Because a matrix is a way to pack a whole transformation into one tidy object, and - crucially - to combine several into one. Rotate then move then scale becomes a single matrix you build once and apply to thousands of points, which is both faster and cleaner than juggling three separate steps.

You do not need to hand-multiply matrices to be productive; NumPy and every geometry library do it for you, and Rhino, Grasshopper and Revit hand you ready-made transformation objects. But it helps to know the shape of the idea: a transformation matrix is the professional packaging of exactly the translate-rotate-scale arithmetic you just wrote by hand. Libraries also fold translation in using a small trick (an extra coordinate, called homogeneous coordinates) so that even sliding fits the same matrix machinery.

The honest takeaway is this: for a lot of design scripting, the plain functions above are enough, and they keep the logic visible. When you start transforming large amounts of geometry, or chaining many moves, reach for NumPy or your CAD tool's transform objects - they are the same maths, industrialised. What matters is that you now understand what those objects do, so they stop being magic and become a convenience you can reason about.