2D Scaling Matrix

You are working with 2D homogeneous coordinates and linear transformations. In 2D, a point $(x, y)$ is represented as a 3D vector $(x, y, 1)$. This lets you express geometric operations (like scaling, rotation, translation) as matrix multiplications with a $3 \times 3$ matrix. The big advantage is that you can compose multiple transforms just by multiplying their matrices (e.g., scale then rotate then translate), which is very convenient in computer vision and graphics.

A scaling transformation changes the size of objects relative to the origin. Scaling by factors $s_x$ and $s_y$ along the x- and y-axes maps a point $(x, y)$ to $(s_x x, s_y y)$. In matrix form with homogeneous coordinates, this is captured by a diagonal matrix where the scale factors appear on the diagonal entries corresponding to x and y, and the homogeneous coordinate remains 1. The result is the standard 3×3 scaling matrix used throughout CV and graphics.

---

1. Background Knowledge

• A 2D point in homogeneous coordinates:

$$(x, y) \rightarrow \begin{pmatrix} x \\ y \\ 1 \end{pmatrix}$$

• A linear/affine transform in homogeneous coordinates is:

$$p' = T p$$

where $T$ is a $3 \times 3$ matrix and $p, p'$ are 3×1 homogeneous vectors.

• For pure scaling (no rotation/translation), the transform should:

$$(x, y) \rightarrow (s_x x, s_y y)$$

and leave the homogeneous component as 1.

---

2. Algorithm / Approach

For “build a 2D scaling matrix” problems, the pattern is:

1. Start from the identity $3 \times 3$ matrix.
2. Replace the diagonal entries that correspond to x and y with the scale factors $s_x$ and $s_y$.
3. Keep the bottom-right entry as 1 (to preserve homogeneous coordinates).
4. Ensure all off-diagonal elements are 0 for pure scaling.

Conceptually, you are encoding:

$$\begin{pmatrix} x' \\ y' \\ 1 \end{pmatrix} = \begin{pmatrix} s_x & 0 & 0 \\ 0 & s_y & 0 \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} x \\ y \\ 1 \end{pmatrix}$$

---

3. Step-by-Step Strategy

1. Understand Inputs Identify the scaling factors $s_x$ and $s_y$ given by the problem (e.g., as variables or function parameters).

2. Initialize Matrix Start with a 3×3 matrix initialized to all zeros or to the identity matrix.

3. Fill Diagonal Elements

• Set entry $(0,0)$ (row 0, col 0) to $s_x$.
• Set entry $(1,1)$ to $s_y$.
• Set entry $(2,2)$ to $1$.

4. Fill Off-Diagonal Elements

• All other entries (off-diagonal) should be 0 for pure scaling.

5. Return or Print the Matrix Ensure the matrix is in the format expected by the platform (e.g., nested lists, 2D array, etc.).

Example in pseudocode:

def scaling_matrix_2d(sx, sy):
 S = [[0.0 for _ in range(3)] for _ in range(3)]
 S = sx
 S = sy
 S = 1.0
 return S

---

4. Common Pitfalls

• Wrong position of scale factors Accidentally putting $s_x$ or $s_y$ in off-diagonal positions (e.g., instead of ) will introduce shear, not pure scaling.

• Forgetting the homogeneous coordinate Setting the bottom-right element to 0 or not setting it at all breaks homogeneous behavior; it must be 1.

• Using translation slots The last column (except bottom-right) corresponds to translation in homogeneous matrices. For pure scaling, those entries must be 0.

• Mixing up row-major and column-major thinking Make sure your indexing matches how you think about rows and columns. In most programming languages, M[i][j] means row i, column j.

---

5. Time & Space Complexity

• Time complexity: Constructing a fixed-size $3 \times 3$ matrix and writing constant many values is $O(1)$.

• Space complexity: Storing a 3×3 matrix requires constant space $O(1)$.