Image Transformations

Learn how to resize, rotate, flip, crop, and apply geometric transformations to images

This guide covers essential geometric transformations including resizing, rotation, flipping, cropping, and more advanced affine and perspective transformations.

Overview

Image transformations allow you to modify the geometry of images. Common operations include:

• Resizing images to different dimensions
• Rotating images by any angle
• Flipping images horizontally or vertically
• Cropping regions of interest
• Applying affine and perspective transformations

Resizing Images

Resize images to specific dimensions or by a scaling factor.

Python

import cv2 as cv
import numpy as np

# Load image
img = cv.imread("image.jpg")
height, width = img.shape[:2]

# Resize to specific dimensions
resized = cv.resize(img, (800, 600))

# Resize by scaling factor
scaled = cv.resize(img, None, fx=0.5, fy=0.5, interpolation=cv.INTER_LINEAR)

# Resize maintaining aspect ratio
new_width = 640
aspect_ratio = new_width / width
new_height = int(height * aspect_ratio)
resized_aspect = cv.resize(img, (new_width, new_height))

cv.imshow("Original", img)
cv.imshow("Resized", resized)
cv.imshow("Scaled", scaled)
cv.waitKey(0)
cv.destroyAllWindows()

C++

#include <opencv2/opencv.hpp>
using namespace cv;

Mat img = imread("image.jpg");
int height = img.rows;
int width = img.cols;

// Resize to specific dimensions
Mat resized;
resize(img, resized, Size(800, 600));

// Resize by scaling factor
Mat scaled;
resize(img, scaled, Size(), 0.5, 0.5, INTER_LINEAR);

// Resize maintaining aspect ratio
int new_width = 640;
double aspect_ratio = (double)new_width / width;
int new_height = (int)(height * aspect_ratio);
Mat resized_aspect;
resize(img, resized_aspect, Size(new_width, new_height));

imshow("Original", img);
imshow("Resized", resized);
imshow("Scaled", scaled);
waitKey(0);

Interpolation Methods

Method	Description	Use Case
INTER_NEAREST	Nearest neighbor	Fastest, lowest quality
INTER_LINEAR	Bilinear interpolation	Good balance (default)
INTER_CUBIC	Bicubic interpolation	Slower, higher quality
INTER_AREA	Resampling using pixel area	Best for downsampling
INTER_LANCZOS4	Lanczos interpolation	Highest quality, slowest

Rotating Images

Rotate images by 90-degree increments or arbitrary angles.

Simple 90-Degree Rotations

Python

import cv2 as cv

img = cv.imread("image.jpg")

# Rotate 90 degrees clockwise
rotated_90_cw = cv.rotate(img, cv.ROTATE_90_CLOCKWISE)

# Rotate 90 degrees counter-clockwise
rotated_90_ccw = cv.rotate(img, cv.ROTATE_90_COUNTERCLOCKWISE)

# Rotate 180 degrees
rotated_180 = cv.rotate(img, cv.ROTATE_180)

cv.imshow("Original", img)
cv.imshow("90° CW", rotated_90_cw)
cv.imshow("180°", rotated_180)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

Mat img = imread("image.jpg");
Mat rotated_90_cw, rotated_90_ccw, rotated_180;

// Rotate 90 degrees clockwise
rotate(img, rotated_90_cw, ROTATE_90_CLOCKWISE);

// Rotate 90 degrees counter-clockwise
rotate(img, rotated_90_ccw, ROTATE_90_COUNTERCLOCKWISE);

// Rotate 180 degrees
rotate(img, rotated_180, ROTATE_180);

imshow("Original", img);
imshow("90° CW", rotated_90_cw);
imshow("180°", rotated_180);
waitKey(0);

Arbitrary Angle Rotation

Python

import cv2 as cv
import numpy as np

img = cv.imread("image.jpg")
height, width = img.shape[:2]

# Define rotation center (image center)
center = (width // 2, height // 2)

# Rotation angle in degrees (positive = counter-clockwise)
angle = 45

# Scale factor (1.0 = no scaling)
scale = 1.0

# Get rotation matrix
rotation_matrix = cv.getRotationMatrix2D(center, angle, scale)

# Apply rotation
rotated = cv.warpAffine(img, rotation_matrix, (width, height))

cv.imshow("Original", img)
cv.imshow("Rotated 45°", rotated)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

Mat img = imread("image.jpg");
int height = img.rows;
int width = img.cols;

// Define rotation center (image center)
Point2f center(width / 2.0, height / 2.0);

// Rotation angle in degrees (positive = counter-clockwise)
double angle = 45.0;

// Scale factor (1.0 = no scaling)
double scale = 1.0;

// Get rotation matrix
Mat rotation_matrix = getRotationMatrix2D(center, angle, scale);

// Apply rotation
Mat rotated;
warpAffine(img, rotated, rotation_matrix, Size(width, height));

imshow("Original", img);
imshow("Rotated 45°", rotated);
waitKey(0);

When rotating by arbitrary angles, parts of the image may be cropped. To preserve the entire rotated image, calculate new dimensions and adjust the rotation matrix accordingly.

Flipping Images

Flip images horizontally, vertically, or both.

Python

import cv2 as cv

img = cv.imread("image.jpg")

# Flip horizontally (mirror)
flipped_h = cv.flip(img, 1)

# Flip vertically
flipped_v = cv.flip(img, 0)

# Flip both horizontally and vertically
flipped_both = cv.flip(img, -1)

cv.imshow("Original", img)
cv.imshow("Horizontal Flip", flipped_h)
cv.imshow("Vertical Flip", flipped_v)
cv.imshow("Both", flipped_both)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

Mat img = imread("image.jpg");
Mat flipped_h, flipped_v, flipped_both;

// Flip horizontally (mirror)
flip(img, flipped_h, 1);

// Flip vertically
flip(img, flipped_v, 0);

// Flip both horizontally and vertically
flip(img, flipped_both, -1);

imshow("Original", img);
imshow("Horizontal Flip", flipped_h);
imshow("Vertical Flip", flipped_v);
imshow("Both", flipped_both);
waitKey(0);

Cropping Images

Crop a region of interest from an image using array slicing.

Python

import cv2 as cv

img = cv.imread("image.jpg")

# Define crop region (y1:y2, x1:x2)
y1, y2 = 100, 400
x1, x2 = 200, 600

# Crop the image
cropped = img[y1:y2, x1:x2]

cv.imshow("Original", img)
cv.imshow("Cropped", cropped)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;

Mat img = imread("image.jpg");

// Define crop region using Rect(x, y, width, height)
Rect roi(200, 100, 400, 300);

// Crop the image
Mat cropped = img(roi);

imshow("Original", img);
imshow("Cropped", cropped);
waitKey(0);

Affine Transformations

Affine transformations preserve parallel lines and include translation, rotation, scaling, and shearing.

Python

import cv2 as cv
import numpy as np

img = cv.imread("image.jpg")
rows, cols = img.shape[:2]

# Define source points (3 points from original image)
src_points = np.float32([[50, 50], [200, 50], [50, 200]])

# Define destination points (where those points should move to)
dst_points = np.float32([[10, 100], [200, 50], [100, 250]])

# Get affine transformation matrix
affine_matrix = cv.getAffineTransform(src_points, dst_points)

# Apply affine transformation
transformed = cv.warpAffine(img, affine_matrix, (cols, rows))

cv.imshow("Original", img)
cv.imshow("Affine Transform", transformed)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

Mat img = imread("image.jpg");
int rows = img.rows;
int cols = img.cols;

// Define source points (3 points from original image)
Point2f src_points[3];
src_points[0] = Point2f(50, 50);
src_points[1] = Point2f(200, 50);
src_points[2] = Point2f(50, 200);

// Define destination points
Point2f dst_points[3];
dst_points[0] = Point2f(10, 100);
dst_points[1] = Point2f(200, 50);
dst_points[2] = Point2f(100, 250);

// Get affine transformation matrix
Mat affine_matrix = getAffineTransform(src_points, dst_points);

// Apply affine transformation
Mat transformed;
warpAffine(img, transformed, affine_matrix, Size(cols, rows));

imshow("Original", img);
imshow("Affine Transform", transformed);
waitKey(0);

Perspective Transformations

Perspective transformations correct for camera angle and viewpoint changes.

Python

import cv2 as cv
import numpy as np

img = cv.imread("image.jpg")
rows, cols = img.shape[:2]

# Define source points (4 corners from original image)
src_points = np.float32([[56, 65], [368, 52], [28, 387], [389, 390]])

# Define destination points (rectangle)
dst_points = np.float32([[0, 0], [300, 0], [0, 300], [300, 300]])

# Get perspective transformation matrix
perspective_matrix = cv.getPerspectiveTransform(src_points, dst_points)

# Apply perspective transformation
warped = cv.warpPerspective(img, perspective_matrix, (300, 300))

cv.imshow("Original", img)
cv.imshow("Perspective Transform", warped)
cv.waitKey(0)

C++

#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

Mat img = imread("image.jpg");

// Define source points (4 corners from original image)
vector<Point2f> src_points;
src_points.push_back(Point2f(56, 65));
src_points.push_back(Point2f(368, 52));
src_points.push_back(Point2f(28, 387));
src_points.push_back(Point2f(389, 390));

// Define destination points (rectangle)
vector<Point2f> dst_points;
dst_points.push_back(Point2f(0, 0));
dst_points.push_back(Point2f(300, 0));
dst_points.push_back(Point2f(0, 300));
dst_points.push_back(Point2f(300, 300));

// Get perspective transformation matrix
Mat perspective_matrix = getPerspectiveTransform(src_points, dst_points);

// Apply perspective transformation
Mat warped;
warpPerspective(img, warped, perspective_matrix, Size(300, 300));

imshow("Original", img);
imshow("Perspective Transform", warped);
waitKey(0);

Perspective transformations are commonly used for document scanning, where you select the four corners of a document in a photo and transform it to a flat, rectangular view.

Key Functions

Function	Description
resize()	Resize image to specific dimensions or scale
rotate()	Rotate image by 90, 180, or 270 degrees
flip()	Flip image horizontally, vertically, or both
getRotationMatrix2D()	Get rotation matrix for arbitrary angles
getAffineTransform()	Get affine transformation matrix from 3 point pairs
getPerspectiveTransform()	Get perspective transformation matrix from 4 point pairs
warpAffine()	Apply affine transformation
warpPerspective()	Apply perspective transformation

When applying transformations, pixels that fall outside the destination image are cropped. Use appropriate border modes or adjust output dimensions to preserve all data.