Scikit Image - Affine Transform

Quiz

An affine transform is a type of geometric transformation, applied to an input image to move each pixel to a new position in the output image. The transformation involves shifting the image along the x- and y-axes by a specified amount in both horizontal (tx) and vertical (ty) directions. This transformation is used in image processing and computer vision to map points from one coordinate space to another. This is commonly used for tasks like image registration, alignment, geometric correction, and image warping.

The Scikit-image library in Python provides a class called AffineTransform() to perform this geometric transformation on images.

The class AffineTransform in skimage library

The class skimage.transform.AffineTransform is used to perform an affine transformation on images or coordinate data. It can perform translation, rotation, scaling, and shearing operations. The transformation is defined by a set of parameters or a homogeneous transformation matrix.

The AffineTransform class is inherited from the ProjectiveTransform class.

Syntax

Following is the syntax of this class −

class skimage.transform.AffineTransform(matrix=None, scale=None, rotation=None, shear=None, translation=None, *, dimensionality=2)

Parameters

matrix: Optional. A (D+1, D+1) array-like representing the homogeneous transformation matrix. If this matrix is provided,then it cannot be used with scale, rotation, shear, or translation.
scale: Optional. Scale factor(s) for the transformation. Can be a single scalar value or a tuple (sx, sy) representing scale factors in the x and y directions. Available only for 2D transformations.
rotation: float, optional. Rotation angle in radians (clockwise). Available only for 2D transformations.
shear: float or 2-tuple of float, optional. Shear angles around the x and y axes (clockwise rotation). Can be a single value (x shear) or a tuple (sx, sy). Available only for 2D transformations.
translation: Optional. Translation parameters (tx, ty) for the transformation. Available only for 2D transformations.
dimensionality: int, optional. The dimensionality of the transform. Not used if other parameters are provided.

Here is the attribute of the class −

params: A (D+1, D+1) array representing the homogeneous transformation matrix.

The following are the methods of the class −

estimate(src, dst): Estimate the transformation matrix based on a set of corresponding source and destination points.
inverse: Get the inverse transformation of the affine transform.

Example

The following example demonstrates how to use the AffineTransform() class to perform the Affine transform on an image using the Homogeneous transformation matrix.

import numpy as np
import matplotlib.pyplot as plt
from skimage.transform import AffineTransform, warp
from skimage import io

# Load the input image
image = io.imread('Images/butterfly.jpg')

# Define source and destination points for the transformation
src = np.array([[150, 150],
                [250, 100],
                [150, 200]])
dst = np.array([[200, 200],
                [300, 150],
                [150, 200]])

# Create an instance of the AffineTransform class
tform = AffineTransform()

# Estimate the transformation matrix based on source and destination points
tform.estimate(src, dst)

# Apply the transformation using the warp function
warped = warp(image, inverse_map=tform.inverse)

# Display the original and transformed images
fig, axes = plt.subplots(1, 2, figsize=(10, 5))
axes[0].imshow(image)
axes[0].set_title('Original Image')
axes[0].axis('off')

axes[1].imshow(warped)
axes[1].set_title('Affine Transformed Image')
axes[1].axis('off')

plt.tight_layout()
plt.show()

Output

On executing the above program, you will get the following output −

Example

The following example demonstrates how to use the AffineTransform() class to perform the Affine transform on an image using the rotation and translation parameters.

import numpy as np
import matplotlib.pyplot as plt
from skimage.transform import AffineTransform, warp
from skimage import io

# Load the input image
image = io.imread('Images/Flower1.jpg')

# Define rotation angle (in radians) and translation parameters
angle = np.deg2rad(30)  # 30 degrees
translation = (50, 20)  # 50 pixels in x, 20 pixels in y

# Create an AffineTransform object
tform = AffineTransform(rotation=angle, translation=translation)

# Apply the transformation to the image
transformed_image = warp(image, tform)

# Plot the original and transformed images
fig, axes = plt.subplots(1, 2, figsize=(10, 5))
axes[0].imshow(image, cmap='gray')
axes[0].set_title('Original Image')
axes[0].axis('off')

axes[1].imshow(transformed_image, cmap='gray')
axes[1].set_title('Transformed Image')
axes[1].axis('off')

plt.tight_layout()
plt.show()

Output

On executing the above program, you will get the following output −

Print Page