How to Match Image Shapes in OpenCV Python?

OpenCV is an open-source computer vision library that performs tasks such as face recognition, object detection, and image processing. One of the common tasks of image processing is feature matching. In feature matching, the goal is to identify the same object or pattern in two different images. However, matching the shapes of the images can be difficult, especially when the images are not the same size. Fortunately, OpenCV provides various functions to match the shapes of images. In this article, we will discuss different methods for matching image shapes in OpenCV Python.

1. Resize the Images

One of the easiest ways to match the shapes of images is to resize them. For example, if we have two images with different sizes, we can resize them to the same size before performing feature matching. OpenCV provides a resize() function that takes the input image and the desired size as arguments. Sample code for resizing the images in OpenCV Python is given below:

import cv2

img1 = cv2.imread("image1.jpg")
img2 = cv2.imread("image2.jpg")

# resize the images
width, height = 500, 500
img1_resized = cv2.resize(img1, (width, height))
img2_resized = cv2.resize(img2, (width, height))

# display the images
cv2.imshow("Image 1 Resized", img1_resized)
cv2.imshow("Image 2 Resized", img2_resized)
cv2.waitKey(0)

In the above code, we read two images “image1.jpg” and “image2.jpg” and then resize them to the same size of 500×500 using the resize() function. The resized images are then displayed using the imshow() function.

2. Homography Transformation

Homography transformation is another popular way to match the shapes of images in OpenCV. Homography is a transformation matrix that maps the points in one image to the corresponding points in another image. The homography matrix can be used to warp the images so that they have the same perspective, rotation, and scale. The findHomography() function in OpenCV is used to find the homography matrix between two images.

import cv2
import numpy as np

img1 = cv2.imread("image1.jpg")
img2 = cv2.imread("image2.jpg")

# convert the images to grayscale
img1_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
img2_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

# find the keypoints and descriptors with SIFT
sift = cv2.xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(img1_gray, None)
kp2, des2 = sift.detectAndCompute(img2_gray, None)

# find the matches
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)

# apply ratio test
good_matches = []
for m, n in matches:
    if m.distance < 0.75 * n.distance:
        good_matches.append(m)

# find the homography transformation
src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)

# apply the homography transformation to image 1
h, w = img1_gray.shape
img1_transformed = cv2.warpPerspective(img1, M, (w, h))

# display the images
cv2.imshow("Image 1", img1)
cv2.imshow("Image 2", img2)

# display the transformed image
cv2.imshow("Image 1 Transformed", img1_transformed)
cv2.waitKey(0)

In the above code, we first read two images “image1.jpg” and “image2.jpg” and convert them to grayscale. Then, we use the SIFT (Scale-Invariant Feature Transform) algorithm to extract keypoints and descriptors from both images. The BFMatcher() function is used to find the matches between the keypoints in the two images. The matches are then filtered using the ratio test.

Using the findHomography() function, we find the homography transformation between the keypoints in the two images. The warpPerspective() function is used to apply the homography transformation to img1, and the transformed image is displayed using the imshow() function.

3. Template Matching

Template matchingis another method for matching the shapes of images in OpenCV. In this method, a smaller image (template) is compared with a larger image to find a match. The matchTemplate() function in OpenCV is used to perform template matching.

import cv2
import numpy as np

img = cv2.imread("image.jpg")
template = cv2.imread("template.jpg")

# convert the images to grayscale
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)

# get the template size
h, w = template_gray.shape[:2]

# perform template matching
res = cv2.matchTemplate(img_gray, template_gray, cv2.TM_CCOEFF_NORMED)

# find the location of the best match
loc = np.where(res >= 0.8)
for pt in zip(*loc[::-1]):
    cv2.rectangle(img, pt, (pt[0] + w, pt[1] + h), (0, 0, 255), 2)

# display the images
cv2.imshow("Image", img)
cv2.imshow("Template", template)
cv2.waitKey(0)

In the above code, we first read the main image “image.jpg” and the template image “template.jpg”. Both images are converted to grayscale. The size of the template image is then obtained using the shape attribute.

The matchTemplate() function is used to find the matching score between the template image and the main image. The where() function is used to find the location(s) in the main image where the matching score is above a certain threshold (0.8 in this case). A rectangle is drawn around each location using the rectangle() function, and the resulting image is displayed using the imshow() function.

Conclusion

Matching image shapes is an important task in image processing. OpenCV provides various functions for matching the shapes of images, including resizing, homography transformation, and template matching. These methods can help to improve the accuracy and reliability of feature matching algorithms. By using the methods discussed in this article, you can easily match the shapes of images in OpenCV Python.