How to Find Laplassian Pyramids for an Image Using OpenCV in Python?

If you are interested in image processing, then you may have heard of Laplacian pyramids. The Laplacian pyramid is a data structure used to represent an image at different scales. It is a hierarchical representation of an image with each level representing an image at a different level of detail.

In this article, we will discuss how to find Laplacian pyramids for an image using OpenCV in Python.

What is OpenCV?

OpenCV (Open Source Computer Vision) is a library of programming functions mainly aimed at real-time computer vision. It is written in C++, but there are also Python bindings, which we will be using in this article.

OpenCV provides a range of functions for image processing, such as image filtering, edge detection, and feature detection. It also provides the ability to create a Laplacian pyramid for an image.

What is a Laplacian Pyramid?

A Laplacian pyramid is a data structure for representing an image at multiple scales. In simple terms, it is a pyramid of images representing an image at different scales.

The Laplacian pyramid is created by recursively decomposing an image into two sub-images, a low-resolution image, and a high-resolution image. The low-resolution image is obtained by smoothing the original image, and the high-resolution image is obtained by subtracting the smoothed image from the original image.

This process is repeated on the low-resolution image until a desired size of the pyramid is reached. The resulting pyramid can be used for image compression, image blending, and other image processing tasks.

Steps to Find Laplacian Pyramids for an Image

Now that we have an understanding of what a Laplacian pyramid is, let’s see how we can find one for an image using OpenCV in Python.

Step 1: Importing the Required Libraries

We will start by importing the required libraries, which are numpy and cv2. Numpy is a library for the Python programming language that adds support for large, multi-dimensional arrays and matrices. Cv2 is the OpenCV library for Python.

import cv2
import numpy as np

Step 2: Loading the Image

Next, we will load the image we want to find the Laplacian pyramid for. We will be using the cv2.imread() function to load the image.

img = cv2.imread('image.jpg')

Step 3: Creating a Gaussian Pyramid

Now that we have loaded the image, we will create a Gaussian pyramid for the image. A Gaussian pyramid is created by recursively decomposing an image into two sub-images, a low-resolution image, and a high-resolution image. The low-resolution image is obtained by smoothing the original image with a Gaussian filter, and the high-resolution image is obtained by subtracting the smoothed image from the original image.

# Generating Gaussian Pyramid
G = img.copy()
gp = [G]
for i in range(6):
    G = cv2.pyrDown(G)
    gp.append(G)

Here, we have created a Gaussian pyramid with six levels. The cv2.pyrDown() function is used to downsample the image by removing every other row and column of pixels. It uses a Gaussian filter to smooth the image before subsampling.

Step 4: Creating a Laplacian Pyramid

Now that we have the Gaussian pyramid, we can use it to create the Laplacian pyramid. The Laplacian pyramid is created by subtracting each level of the Gaussian pyramid from the next higher level and expanding the result. This process is repeated until we have obtained a desired size of the pyramid.

# Generating Laplacian Pyramid
lp = [gp[5]]
for i in range(5, 0, -1):
    gaussian_expanded = cv2.pyrUp(gp[i])
    laplacian = cv2.subtract(gp[i-1], gaussian_expanded)
    lp.append(laplacian)

Here, we have created a Laplacian pyramid with six levels. The cv2.pyrUp() function is used to expand the image by duplicating every pixel and interpolating the intermediate values using a Gaussian filter. The cv2.subtract() function is used to subtract one image from another.

Step 5: Reconstructing the Original Image

Finally, we can reconstruct the original image from the Laplacian pyramid. This is done by adding each level of the Laplacian pyramid to the next higher level and expanding the result. This process is repeated until we have obtained the original image.

# Reconstructing the original image
reconstructed_image = lp[0]
for i in range(1, 6):
    reconstructed_image = cv2.add(cv2.pyrUp(reconstructed_image), lp[i])

Here,we have reconstructed the original image by adding each level of the Laplacian pyramid to the next higher level and expanding the result.

Step 6: Display the Results

Finally, we can display the results using the cv2.imshow() function.

cv2.imshow('Original Image', img)
cv2.imshow('Laplacian Pyramid', lp[0])
cv2.imshow('Reconstructed Image', reconstructed_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Here, we have displayed the original image, the Laplacian pyramid, and the reconstructed image using the cv2.imshow() function. The cv2.waitKey() function is used to wait for a key press before closing the window. The cv2.destroyAllWindows() function is used to close all windows.

Conclusion

In this article, we have discussed how to find Laplacian pyramids for an image using OpenCV in Python. We have seen how to create a Gaussian pyramid, a Laplacian pyramid, and how to reconstruct the original image from the Laplacian pyramid. We hope this article has been helpful in understanding how to use OpenCV for image processing tasks.