📘

2D Translation Matrix

Implement a 3×3 homogeneous transformation matrix for 2D translation, which is a fundamental concept in 2D/3D Transformations used to change the position of an object in a 2D space. This transformation is essential in Computer Vision for tasks such as image registration and object tracking.

The concept of homogeneous coordinates allows for efficient representation of geometric transformations, including translation, rotation, and scaling. In the context of 2D translation, a point $(x, y)$ is represented in homogeneous coordinates as $(x, y, 1)$ , enabling the use of matrix multiplication to apply the transformation.

To create the transformation matrix, follow these steps:

Initialize a 3×3 identity matrix.
Update the last column with the translation values $t_x$ and $t_y$ .

\begin{pmatrix} 1 & 0 & t_x \\ 0 & 1 & t_y \\ 0 & 0 & 1 \end{pmatrix}

This technique is widely used in image processing applications.

Example:

Input:

translation_matrix(5, 3)

Output:

[[1,0,5],[0,1,3],[0,0,1]]

Reasoning:

The function translation_matrix(5, 3) means we want a 2D translation by $t_x = 5$ units in $x$ and $t_y = 3$ units in $y$ .
The homogeneous 2D translation matrix has the fixed form $T = \begin{pmatrix} 1 & 0 & t_x \\ 0 & 1 & t_y \\ 0 & 0 & 1 \end{pmatrix}$
Substituting $t_x = 5$ and $t_y = 3$ gives $T = \begin{pmatrix} 1 & 0 & 5 \\ 0 & 1 & 3 \\ 0 & 0 & 1 \end{pmatrix}$
Converting this matrix to list form yields the output [[1,0,5],[0,1,3],[0,0,1]].

Constraints:

tx and ty are floating-point numbers
Return a 3×3 matrix

More from CV: Image Formation

Perspective Projection with IntrinsicsMedium Rodrigues Rotation FormulaHard Compose 3D TransformationsMedium Distortion Center OffsetMedium Undistort PointHard

To represent a 2D translation in homogeneous coordinates, you use a 3×3 matrix where the translation amounts $t_x, t_y$ appear in the last column, and the rest is mostly an identity matrix.

1. Background Knowledge (Key Concepts)

In 2D, a point is usually written as $(x, y)$ . For image transformations and computer vision, we often switch to homogeneous coordinates, where a 2D point becomes a 3D vector $(x, y, 1)$ . This extra coordinate allows us to represent translations, rotations, scaling, and more using matrix multiplication only, which is convenient for chaining many transformations together.

A homogeneous transformation matrix in 2D is a $3 \times 3$ matrix that acts on these 3D homogeneous vectors. Its structure is typically:

a 2×2 block in the top-left for rotation/scale/shear,
a 2×1 translation vector in the top-right,
and a bottom row that keeps the homogeneous coordinate as 1: $[0\ 0\ 1]$ .

For a pure translation by $(t_x, t_y)$ , the rotation/scale part is just the identity, and only the translation entries are nonzero in the last column (besides the final 1).

2. Algorithm / General Approach

The pattern for constructing a 2D homogeneous transform is:

Start with a 3×3 identity matrix.
Insert the appropriate values:

The upper-left 2×2 block represents linear transformation (here: identity for pure translation).
The top-right 2 entries represent the translation $(t_x, t_y)$ .
The bottom row is $[0, 0, 1]$ .

For translation specifically, you just fill in $t_x$ and $t_y$ in the proper positions while keeping everything else as in the identity matrix.

3. Step-by-Step Strategy

Assume you are given $t_x$ and $t_y$ :

Initialize a 3×3 matrix $T$ as the identity:

T = \begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix}

Set translation components:

Set $T = t_x$
Set $T = t_y$

Return the matrix $T$ .

In pseudocode:

def translation_matrix(tx, ty):
 T = [[1.0, 0.0, tx],
 [0.0, 1.0, ty],
 [0.0, 0.0, 1.0]]
 return T

When you multiply a point $(x, y, 1)$ by $T$ , you get $(x + t_x, y + t_y, 1)$ , which is the translated point.

4. Common Pitfalls

Mixing coordinate and matrix order: Be consistent whether you treat points as column vectors (most common in math/vision) or row vectors; this changes whether you write $T \cdot p$ or $p \cdot T$ and can affect where you place $t_x, t_y$ .
Wrong position of translation terms: $t_x, t_y$ go in the last column of the first two rows (for column-vector convention), not in the last row.
Forgetting homogeneous coordinate: Make sure the point is represented as $(x, y, 1)$ so that the translation is applied correctly; using $(x, y, 0)$ would break the translation effect.

5. Time & Space Complexity

Time complexity to construct the matrix: $O(1)$ (You are just assigning a constant number of values.)
Space complexity: $O(1)$ (The matrix size is fixed at 3×3, independent of input size.)

solution.py

Python 3.13

Test Results

0/0

Run code to see test results.