Image Pyramids with Python and OpenCV

• Part #1: Image Pyramids with Python and OpenCV.
• Part #2: Sliding Windows for Image Classification with Python and OpenCV.

An “image pyramid” is a multi-scale representation of an image.

Utilizing an image pyramid allows us to find objects in images at different scales of an image. And when combined with a sliding window we can find objects in images in various locations.

At the bottom of the pyramid we have the original image at its original size (in terms of width and height). And at each subsequent layer, the image is resized (subsampled) and optionally smoothed (usually via Gaussian blurring).

The image is progressively subsampled until some stopping criterion is met, which is normally a minimum size has been reached and no further subsampling needs to take place.

Method #1: Image Pyramids with Python and OpenCV

The first method we’ll explore to construct image pyramids will utilize Python + OpenCV.

In fact, this is the exact same image pyramid implementation that I utilize in my own projects!

Let’s go ahead and get this example started. Create a new file, name it helpers.py , and insert the following code:

Image Pyramids with Python and OpenCV

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

# import the necessary packages import imutils def pyramid(image, scale=1.5, minSize=(30, 30)): # yield the original image yield image # keep looping over the pyramid while True: # compute the new dimensions of the image and resize it w = int(image.shape[1] / scale) image = imutils.resize(image, width=w) # if the resized image does not meet the supplied minimum # size, then stop constructing the pyramid if image.shape[0] < minSize[1] or image.shape[1] < minSize[0]: break # yield the next image in the pyramid yield image

We start by importing the imutils  package which contains a handful of image processing convenience functions that are commonly used such as resizing, rotating, translating, etc. You can read more about the  imutils  package here. You can also grab it off my GitHub. The package is also pip-installable:

Image Pyramids with Python and OpenCV

Shell

1	$ pip install imutils

Next up, we define our pyramid  function on Line 4. This function takes two arguments. The first argument is the scale , which controls by how much the image is resized at each layer. A small scale  yields more layers in the pyramid. And a larger scale  yields less layers.

Secondly, we define the minSize , which is the minimum required width and height of the layer. If an image in the pyramid falls below this minSize , we stop constructing the image pyramid.

Line 6 yields the original image in the pyramid (the bottom layer).

From there, we start looping over the image pyramid on Line 9.

Lines 11 and 12 handle computing the size of the image in the next layer of the pyramid (while preserving the aspect ratio). This scale is controlled by the scale  factor.

On Lines 16 and 17 we make a check to ensure that the image meets theminSize  requirements. If it does not, we break from the loop.

Finally, Line 20 yields our resized image.

But before we get into examples of using our image pyramid, let’s quickly review the second method.

Method #2: Image pyramids with Python + scikit-image

The second method to image pyramid construction utilizes Python and scikit-image. The scikit-image library already has a built-in method for constructing image pyramids calledpyramid_gaussian , which you can read more about here.

Here’s an example on how to use the pyramid_gaussian  function in scikit-image:

Image Pyramids with Python and OpenCV

Python

1 2 3 4 5 6 7 8 9

# METHOD #2: Resizing + Gaussian smoothing. for (i, resized) in enumerate(pyramid_gaussian(image, downscale=2)): # if the image is too small, break from the loop if resized.shape[0] < 30 or resized.shape[1] < 30: break # show the resized image cv2.imshow("Layer {}".format(i + 1), resized) cv2.waitKey(0)

Similar to the example above, we simply loop over the image pyramid and make a check to ensure that the image has a sufficient minimum size. Here we specify downscale=2  to indicate that we are halving the size of the image at each layer of the pyramid.

Image pyramids in action

Now that we have our two methods defined, let’s create a driver script to execute our code. Create a new file, name it pyramid.py , and let’s get to work:

Image Pyramids with Python and OpenCV

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

# import the necessary packages from pyimagesearch.helpers import pyramid from skimage.transform import pyramid_gaussian import argparse import cv2 # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--image", required=True, help="Path to the image") ap.add_argument("-s", "--scale", type=float, default=1.5, help="scale factor size") args = vars(ap.parse_args()) # load the image image = cv2.imread(args["image"]) # METHOD #1: No smooth, just scaling. # loop over the image pyramid for (i, resized) in enumerate(pyramid(image, scale=args["scale"])): # show the resized image cv2.imshow("Layer {}".format(i + 1), resized) cv2.waitKey(0) # close all windows cv2.destroyAllWindows() # METHOD #2: Resizing + Gaussian smoothing. for (i, resized) in enumerate(pyramid_gaussian(image, downscale=2)): # if the image is too small, break from the loop if resized.shape[0] < 30 or resized.shape[1] < 30: break # show the resized image cv2.imshow("Layer {}".format(i + 1), resized) cv2.waitKey(0)

We’ll start by importing our required packages. I put my personal pyramid  function in ahelpers  sub-module of pyimagesearch  for organizational purposes.

You can download the code at the bottom of this blog post for my project files and directory structure.

We then import the scikit-image pyramid_gaussian function, argparse  for parsing command line arguments, and cv2  for our OpenCV bindings.

Next up, we need to parse some command line arguments on Lines 9-11. Our script requires only two switches, --image , which is the path to the image we are going to construct an image pyramid for, and --scale , which is the scale factor that controls how the image will be resized in the pyramid.

Line 14 loads then our image from disk.

We can start utilize our image pyramid Method #1 (my personal method) on Lines 18-21where we simply loop over each layer of the pyramid and display it on screen.

Then from Lines 27-34 we utilize the scikit-image method (Method #2) for image pyramid construction.

To see our script in action, open up a terminal, change directory to where your code lives, and execute the following command:

Image Pyramids with Python and OpenCV

Shell

1	$ python pyramid.py --image images/adrian_florida.jpg --scale 1.5

Reference