What is the difference between OpenCV and Pillow?

Pillow is a powerful library for opening, manipulating, and saving various image file formats. It provides tools for basic image processing tasks, including resizing, cropping, rotating, adjusting contrast/brightness, applying filters, and basic geometric transformations. Pillow also supports various image formats, making it a versatile choice for image-related projects. It stands for Python Imaging Library and is abbreviated as PIL.

OpenCV is an open-source computer vision and machine learning software library. It was developed by Intel in 1999 and eventually evolved into a versatile tool for real-time computer vision applications. It provides various functions and algorithms for image processing, video analysis, object detection, feature extraction, camera calibration, and more.

Let’s explore their differences in this blog.

What can these libraries do? #

Let’s examine the capabilities offered by both libraries.

Displaying images#

Suppose we want to display the following image:

Lines 1–2: We import the necessary libraries, cv2 for OpenCV and matplotlib.pyplot for plotting images.
Line 4: We use OpenCV (cv2) to load an image named Book.png located in the /content/ directory. The cv2.imread() function is used to read the image.
Line 7: We convert the image from BGR to RGB using the cv2.cvtColor() function. OpenCV reads images in BGR (Blue, Green, Red) format by default, whereas standard images are in RGB (Red, Green, Blue) format.
Line 10: This line uses plt.imshow() from Matplotlib to display the image. Use the imshow() function to display data as an image.
Line 11: This line turns off the axis of the plot, effectively hiding it from the display. The axis refers to the coordinate axes (x-axis and y-axis) of the plot.
Line 12: This line displays the image plot. Use the plt.show() function to show all the plots created using Matplotlib.

If we do not convert the image to RGB, the BGR image will be displayed by default.

Line 3: This line uses the Image.open() function from the PIL (Pillow) library to open an image file named Book.png in the /content/ directory. The resulting image is stored in the variable image_pil.
Lines 6–7: We use Matplotlib to display the image stored in image_pil. The plt.imshow() function displays the image. It takes the image data (image_pil) as input and plots it on the current axes.

Other functionalities#

Some of the common functionalities supported by both libraries are explained as follows:

Resizing images: Resizing an image involves changing its dimensions. Most image processing libraries, including PIL, typically preserve the aspect ratio by default when resizing images. In OpenCV, however, we can preserve the aspect ratio while resizing images by manually calculating the dimensions based on the desired aspect ratio.
Converting images to grayscale: Converting an image to grayscale removes color information, resulting in a single-channel image.
Rotating images: Rotating an image by a specified angle around a chosen center point.

# Resizing the image
new_width=25
new_height=50
image_opencv_rgb = cv2.cvtColor(image_opencv, cv2.COLOR_BGR2RGB)
resized_image_opencv = cv2.resize(image_opencv_rgb, (new_width, new_height))
# Grayscale
gray_image_opencv = cv2.cvtColor(image_opencv_rgb, cv2.COLOR_RGB2GRAY)
# Image rotation
rows, cols = image_opencv.shape[:2]
angle = 45
rotation_matrix = cv2.getRotationMatrix2D((cols / 2, rows / 2), angle, 1)
rotated_image_opencv = cv2.warpAffine(image_opencv_rgb, rotation_matrix, (cols, rows))
# Blurred image
kernel_size = (5, 5)
blurred_image_opencv = cv2.GaussianBlur(image_opencv_rgb, kernel_size, 0)
# Define the coordinates of the rectangle
x1, y1, x2, y2 = 100, 50, 400, 300
# Define the thickness of the rectangle outline
thickness = 2
# Crop the region defined by the rectangle
cropped_image_opencv = image_opencv_rgb[y1:y2, x1:x2]
# Save the image
cv2.imwrite('output_opencv.jpg', image_opencv)

Note: In OpenCV, when converting an image to grayscale using the cv2.cvtColor() function, the default method uses the formula: $Y=0.299×𝑅+0.587×𝐺+0.114×𝐵Y=0.299×R+0.587×G+0.114×B$ , where $R$ , $G$ , and $B$ represent the red, green, and blue channels of the original image, respectively. This method gives a weighted average of the RGB channels, which results in a slightly bluish tint in the grayscale image due to the coefficients used.


# Resize the image
new_width, new_height = 25, 50
resized_image_pil = image_pil.resize((new_width, new_height))
# Convert the image to grayscale
gray_image_pil = image_pil.convert('L')
# Rotate the image
angle = 45
rotated_image_pil = image_pil.rotate(angle)
# Apply Gaussian blur
blurred_image_pil = image_pil.filter(ImageFilter.GaussianBlur(radius=5))
# Crop the region defined by the rectangle
x1, y1, x2, y2 = 100, 50, 400, 300
cropped_image_pil = image_pil.crop((x1, y1, x2, y2))
# Save the original image
image_pil.save('output_pil.png')

Line 4: This line resizes the image to dimensions defined by new_width and new_height.
Line 7: This line converts the image to grayscale.
Line 11: This line rotates the image by the specified angle using a rotation matrix.
Line 14: This line blurs the image using Gaussian blur with a kernel size of kernel_size.
Line 18: This line crops the image to the region defined by (x1, y1) and (x2, y2).
Line 21: This line saves the processed image as 'output_opencv.jpg'.

The following results are the outputs for the abovementioned commands:

As we observe, the commands using the PIL library are much simpler than those using the OpenCV library, but resizing the result is much better for OpenCV. The resized image generated by PIL is blurrier as the default interpolation method in Pillow’s resize() function is PIL.Image.BILINEAR, which can cause blurriness.

Unique features#

Let’s explore functions supported by OpenCV and PIL that are unique to each library, along with code snippet examples.

OpenCV#

OpenCV has several features that set it apart from Pillow. One notable distinction is its extensive support for computer vision algorithms, including object detection, feature extraction, camera calibration, and image segmentation. It also provides integration with machine learning libraries like TensorFlow and PyTorch.

Let's explore some image-processing tasks.

import cv2
import numpy as np
import matplotlib.pyplot as plt
# Changing volorspaces
def change_colorspace(image):
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    return gray_image
# Geometric transformations of images
def geometric_transformations(image):
    rows, cols = image.shape
    M = cv2.getRotationMatrix2D((cols/2, rows/2), 45, 1)
    rotated_image = cv2.warpAffine(image, M, (cols, rows))
    return rotated_image
# Image thresholding
def image_thresholding(image):
    ret, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
    return thresh
# Smoothing images
def smoothing_images(image):
    blurred_image = cv2.GaussianBlur(image, (5, 5), 0)
    return blurred_image
# Morphological transformations
def morphological_transformations(image):
    kernel = np.ones((5,5),np.uint8)
    erosion = cv2.erode(image, kernel, iterations = 1)
    dilation = cv2.dilate(image, kernel, iterations = 1)
    return erosion, dilation
# Image gradients
def image_gradients(image):
    sobelx = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5)
    sobely = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5)
    return sobelx, sobely
# Canny Edge Detection
def canny_edge_detection(image):
    edges = cv2.Canny(image, 100, 200)
    return edges
# Hough Line Transform
def hough_line_transform(image):
    lines = cv2.HoughLines(image, 1, np.pi/180, 200)
    return lines
# Image Segmentation with Watershed Algorithm
def image_segmentation(image):
    gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
    ret, thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
    return thresh
# Interactive Foreground Extraction using GrabCut Algorithm
def grabcut_foreground_extraction(image):
    mask = np.zeros(image.shape[:2],np.uint8)
    bgdModel = np.zeros((1,65),np.float64)
    fgdModel = np.zeros((1,65),np.float64)
    rect = (50,50,450,290)
    cv2.grabCut(image,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)
    mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
    return mask2
# Read the image
image = cv2.imread('/content/Book.png')
# Apply different image processing techniques
gray_image = change_colorspace(image)
rotated_image = geometric_transformations(gray_image)
thresh_image = image_thresholding(rotated_image)
blurred_image = smoothing_images(thresh_image)
erosion_image, dilation_image = morphological_transformations(blurred_image)
sobelx_image, sobely_image = image_gradients(erosion_image)
edges_image = canny_edge_detection((sobelx_image*255).astype(np.uint8))

Canny edge detection is a popular edge detection algorithm. Morphological transformations, like erosion and dilation, manipulate the structure of features in images. Here, cv2.erode() and cv2.dilate() perform erosion and dilation, respectively, altering the shape of objects in the image based on a predefined kernel (lines 28–32 and 75). Image gradients highlight the edges and boundaries in images. Sobel operators are commonly used for gradient computation; cv2.Sobel() is used here to calculate the gradients of the image in the x and y directions (lines 35–38 and 76). OpenCV’s cv2.Canny() function applies Canny edge detection to the input image, detecting edges based on gradients and thresholds (lines 41–43 and 77).

PIL supports reading and embedding ICC profilesAn ICC profile is a standardized data set defining the color characteristics of a device such as a digital camera, monitor, or printer, ensuring consistent and accurate color reproduction across different devices and software applications., which are used for accurate image color management. OpenCV does not directly support this feature (lines 4–6). PIL also offers comprehensive support for reading and manipulating image metadata,Image metadata refers to descriptive information embedded within an image file, including details like camera settings, location, and timestamps, aiding in organization, searchability, and understanding of image content. including EXIF, IPTC, and XMP data. While OpenCV can read some metadata, PIL provides more advanced metadata manipulation capabilities (lines 8–13).

If you’re interested in creating interactive projects using Pillow, consider exploring the following links for inspiration:

Conclusion#

The Python Imaging Library (PIL) and OpenCV are powerful libraries for image processing and manipulation, each with strengths and capabilities. OpenCV is widely recognized for its robust computer vision algorithms and real-time processing capabilities, making it an excellent choice for tasks such as object detection, image segmentation, and video processing. Additionally, OpenCV’s extensive support for hardware acceleration and compatibility with various platforms and languages make it highly versatile for research and production environments. On the other hand, PIL excels in areas such as image metadata handling and ICC profile support, making it suitable for tasks that require precise color management, advanced image manipulation, or dealing with specific image formats. In summary, OpenCV is preferred for computer vision tasks and real-time applications, while PIL is more suitable for tasks requiring specialized image processing, metadata manipulation, or compatibility with specific image formats. Ultimately, the choice between the two libraries depends on the specific requirements of the project and the desired functionality needed to accomplish the task at hand.

If you want to learn more about the OpenCV library, look no further! Check out the following exciting courses available on the Educative platform:

Mastering Computer Vision in Python with OpenCV

Mastering Computer Vision in Python with OpenCV

OpenCV is an open-source machine learning library for Python that adds enhanced artificial intelligence capabilities in computer vision and image processing. This course is a comprehensive introduction to building applications using OpenCV, including viewing, identifying, and editing image and video files using Python. You’ll start with an introduction to the library before immediately applying the framework to view images, video, webcam input, and text. You’ll then take your image captures and apply various edits, including decolorization, cropping, resizing, and captioning with layered text and objects. You’ll continue with basic machine learning functions, including edge, object, and face detection. With the basics in hand, you’ll wrap up with real-world projects to build document scanners and object trackers. By the end of this course, you’ll have a working knowledge of OpenCV and machine learning. You’ll be prepared to build functional applications using the principles of computer vision in Python.

20hrs

Intermediate

91 Exercises

3 Quizzes

Learning OpenCV from Scratch with C++

OpenCV is extensively used in the business world for various applications, including facial recognition, object detection, and image and video manipulation. In this course, you'll learn the basics of OpenCV—an open-source machine learning library. You'll begin with an overview of the OpenCV library before moving on to practical applications like viewing images, videos, and webcam input. Next, you'll learn how to edit images with tools like decolorizing, cropping, resizing, and captioning. You'll dive into machine learning functions like edge detection, contour detection, corner detection, and face detection. Finally, you'll work on practical projects like document scanners and object trackers. By the end of this course, you’ll have a solid understanding of OpenCV and machine learning with C++. You'll be able to create functional applications using computer vision principles, preparing you for real-world projects. Taking this course will allow you to take your programming skills to the next level.

6hrs

Beginner

62 Exercises

4 Quizzes