Homogeneous Coordinates

Under perspective projection, the parallel tracks appear to meet at a point on the horizon. A photograph maps points from three-dimensional Euclidean space to a two-dimensional image plane. Perspective projection does not preserve circles, distances, angles, or ratios of distances. A circle, for example, can appear as an ellipse. Straight lines remain straight, while parallel lines can appear to meet. A projective plane extends the Euclidean plane so that every pair of distinct lines intersects in exactly one point. Parallel lines intersect at a point at infinity. In three-dimensional projective space, the same property holds for two lines in a common plane. Skew lines still do not meet (Hartley & Zisserman, 2004). A choice of coordinates selects an origin, but any point could serve as the origin.

A point expressed in two different coordinate frames.

The coordinates of a point in 2D depend on the chosen coordinate system. The solid and dashed axes define two coordinate systems, so the same point has different coordinates in each. Its position in space does not change. The figure shows two frames. Each frame consists of an origin and two linearly independent basis vectors that define the axes of the two-dimensional space. More generally, an origin

p_o

and

n

linearly independent basis vectors define an n-dimensional affine frame. For any vector

\mathbf v

, a unique set of scalars

s_i

satisfies

\mathbf v = s_1 \mathbf u_1 + s_2 \mathbf u_2 + ... + s_n \mathbf u_n = \mathbf s^T [\mathbf u_1, \mathbf u_2, ..., \mathbf u_n]^T

where

\mathbf s

gives the coordinates of

\mathbf v

in the frame. Each point also has unique scalars

s_i

that express it in terms of the origin

p_o

and the basis vectors:

p = p_o + s_1 \mathbf u_1 + s_2 \mathbf u_2 + ... + s_n \mathbf u_n = p_o + \mathbf s^T [\mathbf u_1, \mathbf u_2, ..., \mathbf u_n]^T

An affine space of dimension

n

consists of a set of points

\mathcal{A}

and an associated vector space

V

of dimension

n

. It supports two operations:

Point subtraction: $p - q \in V$ (gives a vector)
Point translation: $p + v \in \mathcal{A}$ (moves a point by a vector)

An affine space has no fixed origin, preferred coordinate system, or basis until you choose one.A coordinate frame on an affine space consists of a chosen origin point

p_0 \in \mathcal{A}

and a basis

\{v_1, \dots, v_n\}

for the associated vector space

V

.A vector space has a built-in origin, defined by the zero vector. It is closed under addition and scalar multiplication, so it supports linear combinations such as

a\mathbf{v}_1 + b\mathbf{v}_2

. For this reason, it is also called a linear space. In an affine space, you cannot add two points directly, and there is no zero point.Euclidean space adds an inner product, which defines angles and lengths.

Points and vectors may both have x, y, and z coordinates in 3D, but they are different mathematical objects. A 3D frame defined by

(p_o, \mathbf u_1, \mathbf u_2, \mathbf u_3)

does not distinguish a point

(p_x, p_y, p_z)

from a vector

(v_x, v_y, v_z)

with the same coordinates. Homogeneous coordinates make the distinction explicit. In this frame, the point is

p = [s_1 s_2 s_3 1][\mathbf u_1 \mathbf u_2 \mathbf u_3 p_o]^T

and the vector is

\mathbf v = [s_1' s_2' s_3' 0][\mathbf u_1 \mathbf u_2 \mathbf u_3 p_o]^T

The point representation

[s_1 s_2 s_3 1]

and the vector representation

[s_1' s_2' s_3' 0]

are called homogeneous coordinates. The fourth coordinate

w

is the weight. A point

(x,y,z)

in three-dimensional Euclidean space can be represented by the 4-tuple

(x,y,z,1)

. More generally,

(x,y,z,1)

and

(\lambda x, \lambda y, \lambda z, \lambda)

represent the same point for any

\lambda \neq 0

. Dividing every coordinate by

\lambda

gives

(x,y,z,1)

. A point with weight

w \neq 0

therefore represents the Cartesian point obtained by dividing by the weight:

(x, y, z, w) \equiv (x/w,\; y/w,\; z/w), \qquad w \neq 0

Homogeneous coordinates represent a family of equivalent points along a ray in projective space. Each member is a scaled version of the same Cartesian point. These coordinates can:

Represent points at infinity (when $w = 0$ ), as required for parallel lines in perspective projections.
Express transformations such as perspective camera models and 3D projections as linear matrix operations.

Transformations in homogeneous coordinates

Homogeneous matrices represent common 2D transformations.

Rigid transformation

A rigid transformation combines a rotation and a translation. It preserves lengths and angles and does not include scaling or shearing. Its matrix is

\mathbf{T}_{\text{rigid}} = \begin{bmatrix} \cos\theta & -\sin\theta & t_x \\ \sin\theta & \cos\theta & t_y \\ 0 & 0 & 1 \end{bmatrix}

$\theta$ : rotation angle
$(t_x, t_y)$ : translation

Similarity transformation

A similarity transformation includes rotation, translation, and uniform scaling. It preserves shape but not necessarily size.

\mathbf{T}_{\text{sim}} = \begin{bmatrix} s \cos\theta & -s \sin\theta & t_x \\ s \sin\theta & s \cos\theta & t_y \\ 0 & 0 & 1 \end{bmatrix}

The scaling factor is

s

Affine transformation

An affine transformation can combine translation, rotation, scaling, and shearing. It preserves parallel lines, but it need not preserve lengths or angles.

\mathbf{T}_{\text{affine}} = \begin{bmatrix} a_{11} & a_{12} & t_x \\ a_{21} & a_{22} & t_y \\ 0 & 0 & 1 \end{bmatrix}

This matrix gives the general form of a 2D affine transformation.

Example

The following code applies each transformation to a square:

import matplotlib.pyplot as plt
import numpy as np

# Original square: corner at origin, size 1
square = np.array(
    [
        [0, 0, 1],
        [1, 0, 1],
        [1, 1, 1],
        [0, 1, 1],
        [0, 0, 1],  # close the square
    ]
).T


# Define transformations
def apply_transform(matrix, shape):
    return (matrix @ shape).T[:, :2]


# Rigid: rotate 45 deg and translate (1, 1)
theta = np.pi / 4
T_rigid = np.array(
    [[np.cos(theta), -np.sin(theta), 1], [np.sin(theta), np.cos(theta), 1], [0, 0, 1]]
)

# Similarity: scale by 1.5, rotate 30 deg, translate (0.5, 0.5)
theta_sim = np.pi / 6
s = 1.5
T_similarity = np.array(
    [
        [s * np.cos(theta_sim), -s * np.sin(theta_sim), 0.5],
        [s * np.sin(theta_sim), s * np.cos(theta_sim), 0.5],
        [0, 0, 1],
    ]
)

# Affine: shear and scale
T_affine = np.array([[1.2, 0.5, 1.5], [0.2, 1.0, 1.0], [0, 0, 1]])

# Translation only
T_translation = np.array([[1, 0, 2], [0, 1, 1], [0, 0, 1]])

# Apply transformations
square_rigid = apply_transform(T_rigid, square)
square_similarity = apply_transform(T_similarity, square)
square_affine = apply_transform(T_affine, square)
square_translation = apply_transform(T_translation, square)
square_original = square.T[:, :2]

References

Hartley, R., Zisserman, A. (2004). Multiple View Geometry in Computer Vision.

Found an error on this page? Report an issue.

Robotics Systems

Motion Algebras

Kinematics

Dynamics

Systems Integration

Homogeneous Coordinates

Transformations in homogeneous coordinates

Rigid transformation

Similarity transformation

Affine transformation

Example

References

​Transformations in homogeneous coordinates

​Rigid transformation

​Similarity transformation

​Affine transformation

​Example

​References

Transformations in homogeneous coordinates

Rigid transformation

Similarity transformation

Affine transformation

Example

References