Image Similarity Comparison with OpenCV

Image similarity comparison is a fundamental task in computer vision, widely used in duplicate image detection, object recognition, and image retrieval. OpenCV, as a powerful open-source library, offers multiple techniques to quantify how similar two images are. This article delves into three primary methods: histogram comparison, template matching, and feature matching, with code examples to demonstrate their implementation.

Histogram Comparison

Histogram comparison is a simple and efficient approach that evaluates similarity by analyzing color distributions. The core idea is that images with similar color patterns (e.g., multiple forest scenes) will have comparable histograms. However, this method is overly simplistic and may misclassify different objects (such as a banana and a beach) as similar due to shared colors.

In OpenCV, the cv2.compareHist() function is used for this purpose. It takes two histograms and a comparison method as input, returning a similarity score. Here is a basic example code:

import cv2
import numpy as np

# Load two images
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# Convert to HSV color space for better color representation
img1_hsv = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)
img2_hsv = cv2.cvtColor(img2, cv2.COLOR_BGR2HSV)

# Compute histograms
hist1 = cv2.calcHist([img1_hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
hist2 = cv2.calcHist([img2_hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])

# Normalize histograms
cv2.normalize(hist1, hist1, 0, 1, cv2.NORM_MINMAX)
cv2.normalize(hist2, hist2, 0, 1, cv2.NORM_MINMAX)

# Compare histograms using correlation method
similarity = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
print(f"Similarity score: {similarity}")

The score ranges from -1 to 1, with 1 indicating perfect similarity. It can be scaled to a percentage if needed.

Template Matching

Template matching is suitable for locating a smaller image (template) within a larger one. It works by sliding the template across the search image and computing a similarity measure at each position. This method performs well with identical images in terms of size and orientation but fails with variations in scale, rotation, or distortion.

OpenCV provides the cv2.matchTemplate() function for this task, which returns a result matrix where higher values indicate better matches. An example is as follows:

import cv2
import numpy as np

# Load the main image and the template
img = cv2.imread('main_image.jpg')
template = cv2.imread('template.jpg')

# Perform template matching
result = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)

# Find the location of the best match
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
print(f"Best match score: {max_val}")

The score is between 0 and 1, with 1 representing a perfect match.

Feature Matching

Feature matching is a more robust method that extracts keypoints and descriptors from images, enabling comparisons under transformations such as rotation, scaling, or skewing. Common algorithms include SIFT, SURF, or ORB.

In OpenCV, the features2d module handles this process. It involves detecting features, computing descriptors, and matching them between images. A high proportion of matching features indicates similarity, and homography can be computed to analyze geometric relationships. Here is an example using ORB:

import cv2
import numpy as np

# Load images in grayscale
img1 = cv2.imread('image1.jpg', cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread('image2.jpg', cv2.IMREAD_GRAYSCALE)

# Initialize ORB detector
orb = cv2.ORB_create()

# Find keypoints and descriptors
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)

# Create BFMatcher object
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

# Match descriptors
matches = bf.match(des1, des2)

# Sort matches by distance
matches = sorted(matches, key=lambda x: x.distance)

# Calculate similarity based on number of good matches
similarity = len(matches) / min(len(kp1), len(kp2))  # Simple metric
print(f"Similarity score: {similarity}")

This score can be normalized to a percentage.

Other Methods

Beyond OpenCV's core functions, other libraries offer advanced techniques. For instance, the Structural Similarity Index (SSIM) from scikit-image assesses similarity from a perceptual perspective, considering luminance, contrast, and structure, with scores ranging from -1 to 1 (1 for identical images), but it requires images of the same size and is sensitive to transformations. Deep learning approaches, such as the OpenAI CLIP model, encode images into vectors and compute cosine similarity, providing scale invariance, though they rely on external dependencies and higher computational resources. These methods expand application possibilities but require balancing accuracy and resource demands.

In summary, OpenCV provides multiple approaches for image similarity comparison, each with its strengths and weaknesses. Histogram comparison is fast but simplistic, template matching is precise for identical images, and feature matching is robust to transformations. The choice depends on application requirements, such as speed, accuracy, and invariance. Integrating other techniques can further enhance performance.