Geometric Transformations: Rotation and Translation

Besides changing the size of images (scaling), we often need to adjust their orientation or position within the frame. Two fundamental geometric transformations that achieve this are rotation and translation. These operations manipulate the spatial relationship of pixels without necessarily changing their intensity values (though interpolation might slightly alter them). They are essential for tasks like aligning images, correcting camera tilt, or preparing data for recognition algorithms that might not be rotation-invariant.

Like scaling, rotation and translation are types of affine transformations. This means they preserve points, straight lines, and planes. Parallel lines remain parallel after an affine transformation. We often use a single function in libraries like OpenCV to perform these operations, typically by defining a transformation matrix.

Rotating Images

Rotation involves turning an image around a fixed point, called the center of rotation, by a certain angle.

• Center of Rotation: This point defines the pivot around which the image spins. It's often the center of the image, but you can choose any point (x, y).
• Angle: Specifies how much to rotate the image, usually measured in degrees. Positive angles typically correspond to counter-clockwise rotation, while negative angles mean clockwise rotation (though library conventions can vary, so always check the documentation).
• Scale (Optional): Sometimes rotation functions also allow for uniform scaling (zooming in or out) simultaneously. A scale factor of 1.0 means no scaling.

When you rotate an image, especially by angles other than multiples of 90 degrees, the original rectangular grid of pixels gets mapped to new positions. This raises two considerations:

1. New Pixel Positions: Where does the intensity value of an original pixel $(x, y)$ end up after rotation? This is calculated using trigonometry, often encapsulated within a rotation matrix. For a counter-clockwise rotation by angle $\theta$ around the origin (0,0), the new coordinates $(x', y')$ are related to the old coordinates $(x, y)$ by:

   $$\begin{pmatrix} x' \\ y' \end{pmatrix} = \begin{pmatrix} \cos \theta & -\sin \theta \\ \sin \theta & \cos \theta \end{pmatrix} \begin{pmatrix} x \\ y \end{pmatrix}$$

   When rotating around a different center, translation operations are combined with this rotation.

2. Empty Areas and Interpolation: Rotating a rectangular image within its frame often leaves empty areas where no original pixel maps directly. Also, the calculated new coordinates $(x', y')$ might fall between pixel locations on the output grid. We need a way to determine the pixel value at integer grid locations in the output image. This process is called interpolation. Common methods include:

   • Nearest Neighbor: Assign the value of the closest original pixel. Fast, but can create blocky results.
   • Bilinear Interpolation: Calculate the value based on a weighted average of the four nearest original pixels. Smoother results, generally preferred.

Libraries like OpenCV handle these calculations. You typically provide the image, the rotation center, the angle, and an optional scale factor. The library computes the necessary transformation matrix and applies it, using an interpolation method you can often specify.

# Example using OpenCV (Conceptual - details depend on library version)
import cv2
import numpy as np

# Assume 'image' is loaded (e.g., using cv2.imread)
rows, cols = image.shape[:2]

# Center of rotation: center of the image
center = (cols / 2, rows / 2)
# Angle: 45 degrees counter-clockwise
angle = 45
# Scale: 1.0 (no scaling)
scale = 1.0

# Calculate the rotation matrix
M_rotate = cv2.getRotationMatrix2D(center, angle, scale)

# Apply the rotation using warpAffine
# The third argument is the output image size (width, height)
rotated_image = cv2.warpAffine(image, M_rotate, (cols, rows))

# 'rotated_image' now holds the rotated version

Translating Images

Translation is simpler: it involves shifting an image horizontally, vertically, or both. Imagine sliding the image across the screen without rotating or resizing it.

• Shift Parameters: You need to specify the displacement in the x-direction ($t_x$) and the y-direction ($t_y$).
  • A positive $t_x$ shifts the image to the right.
  • A positive $t_y$ shifts the image down.
  • Negative values shift left and up, respectively.

The transformation is straightforward: every pixel originally at $(x, y)$ moves to a new position $(x', y')$ where:

$$x' = x + t_x \\ y' = y + t_y$$

This can be represented by a translation matrix. For use with functions like OpenCV's warpAffine (which expects a 2x3 matrix for affine transformations), the translation matrix looks like this:

$$M_{translate} = \begin{pmatrix} 1 & 0 & t_x \\ 0 & 1 & t_y \end{pmatrix}$$

Here, the $t_x$ and $t_y$ directly represent the horizontal and vertical shifts.

Like rotation, translation can move parts of the image out of the visible frame, and it can create empty areas that need to be filled (usually with black or some other specified background color).

# Example using OpenCV (Conceptual)
import cv2
import numpy as np

# Assume 'image' is loaded
rows, cols = image.shape[:2]

# Shift amount: 50 pixels right, 20 pixels down
tx = 50
ty = 20

# Define the translation matrix
M_translate = np.float32([[1, 0, tx],
                          [0, 1, ty]])

# Apply the translation using warpAffine
# The third argument is the output image size (width, height)
translated_image = cv2.warpAffine(image, M_translate, (cols, rows))

# 'translated_image' now holds the shifted version

Combining Transformations with warpAffine

As seen in the examples, functions like OpenCV's cv2.warpAffine are versatile. They take a 2x3 transformation matrix M and apply the corresponding affine transformation (which can be rotation, translation, scaling, shearing, or combinations) to the input image.

The general form of the 2x3 matrix M is:

$$M = \begin{pmatrix} \alpha & \beta & (1-\alpha) c_x - \beta c_y \\ -\beta & \alpha & \beta c_x + (1-\alpha) c_y \end{pmatrix}$$

where the transformation combines scaling by $\alpha$, rotation by $\theta$ (where $\alpha = scale \cdot \cos\theta$, $\beta = scale \cdot \sin\theta$), and translation relative to a center $(c_x, c_y)$. However, you usually don't construct this matrix manually. Instead, you use helper functions like cv2.getRotationMatrix2D for rotation (which incorporates center and scale) or define the simple translation matrix directly, as shown above. The warpAffine function then applies the transformation defined by the matrix M to map pixels from the source image to the destination image, using interpolation where necessary.

Understanding rotation and translation is fundamental for manipulating image geometry. These operations are building blocks for image alignment, data augmentation in machine learning (creating slightly modified training images), and correcting perspective distortions. In the hands-on section later in this chapter, you'll get to apply these transformations yourself.