OpenCV-Contrib: A Python Library for Computer Vision Extensions

OpenCV-Contrib: A Python Library for Computer Vision Extensions

by

OpenCV (Open Source Computer Vision Library) is an open-source computer vision library that provides powerful tools for image and video processing. Most people using OpenCV may only involve basic image processing functions, such as edge detection and image filtering. However, opencv-contrib is an extension package of OpenCV that contains some advanced computer vision features. If you want more functionalities, opencv-contrib is undoubtedly a good choice.

How to Install opencv-contrib

First, ensure that you have installed the basic OpenCV library. If not, you can install it using the following command:

pip install opencv-python

Next, install the opencv-contrib extension package:

pip install opencv-contrib-python

Once installed, you can import the cv2 module in Python to use all the functionalities of OpenCV, including the additional features in contrib.

Basic Usage

The opencv-contrib extension package includes many advanced features. Here, we will introduce two commonly used functionalities.

Method 1: Feature Detection Using SIFT (Scale-Invariant Feature Transform)

SIFT is an algorithm used for detecting and describing feature points in images, and it has strong robustness for images with different scales and perspectives.

import cv2

# Read image
image = cv2.imread('image.jpg')

# Convert image to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Create SIFT object
sift = cv2.SIFT_create()

# Detect keypoints and compute descriptors
keypoints, descriptors = sift.detectAndCompute(gray_image, None)

# Draw keypoints
output_image = cv2.drawKeypoints(image, keypoints, None)

# Show result
cv2.imshow('SIFT Keypoints', output_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code detects keypoints in the image using the SIFT algorithm and draws them. This is a classic task in computer vision, widely used in image matching, object recognition, and other scenarios.

Method 2: Feature Matching Using SURF (Speeded-Up Robust Features)

SURF is another algorithm for feature point detection that is faster than SIFT but also has strong robustness. Although SURF has been removed in some versions of OpenCV, it is still available in opencv-contrib.

import cv2

# Read image
image = cv2.imread('image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Create SURF object
surf = cv2.xfeatures2d.SURF_create(400)

# Detect keypoints and descriptors
keypoints, descriptors = surf.detectAndCompute(gray_image, None)

# Draw keypoints
output_image = cv2.drawKeypoints(image, keypoints, None)

# Show result
cv2.imshow('SURF Keypoints', output_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code is similar to SIFT, except it uses the SURF algorithm to detect feature points and draw the results. The cv2.xfeatures2d.SURF_create() function creates a SURF object, specifying a threshold (e.g., 400) to control the precision of feature point detection.

Note: The SURF and SIFT algorithms are patented, and in certain cases (especially for commercial use), you may need to pay the corresponding fees or choose to use other open-source algorithms.

Code Examples

Next, let’s look at two practical code examples to help you better understand some common functionalities of opencv-contrib.

Example 1: Feature Detection Using ORB (Oriented FAST and Rotated BRIEF)

ORB is an algorithm that combines FAST keypoint detection and BRIEF descriptors, offering fast speed and good performance, suitable for real-time applications.

import cv2

# Read image
image = cv2.imread('image.jpg')

# Convert to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Create ORB object
orb = cv2.ORB_create()

# Detect keypoints and compute descriptors
keypoints, descriptors = orb.detectAndCompute(gray_image, None)

# Draw keypoints
output_image = cv2.drawKeypoints(image, keypoints, None)

# Show result
cv2.imshow('ORB Keypoints', output_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code detects keypoints in the image using the ORB algorithm and draws them. ORB is an efficient feature detection algorithm suitable for resource-limited devices.

Example 2: Detecting Circles Using Hough Transform

The Hough Transform is a classic technique in image analysis, commonly used to detect geometric shapes in images, such as lines and circles. In opencv-contrib, we can easily implement this functionality.

import cv2
import numpy as np

# Read image
image = cv2.imread('image.jpg')

# Convert to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Gaussian blur
blurred_image = cv2.GaussianBlur(gray_image, (15, 15), 0)

# Detect circles using Hough Transform
circles = cv2.HoughCircles(blurred_image, cv2.HOUGH_GRADIENT, dp=1.2, minDist=20,
                           param1=50, param2=30, minRadius=10, maxRadius=100)

# Draw circles
if circles is not None:
    circles = np.round(circles[0, :]).astype("int")
    for (x, y, r) in circles:
        cv2.circle(image, (x, y), r, (0, 255, 0), 4)

# Show result
cv2.imshow('Detected Circles', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code detects circles in the image using the Hough Transform and draws the detected circles on the original image. It is a classic method for geometric shape detection.

Practical Application Scenarios

The opencv-contrib not only helps us with feature point detection but also plays a role in some practical applications. Here are two common application scenarios.

Scenario 1: Face Recognition and Detection

Face recognition is one of the important applications in computer vision. With opencv-contrib, you can easily implement face detection based on Haar cascade classifiers.

import cv2

# Load face detection model
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# Read image
image = cv2.imread('image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Detect faces
faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# Draw rectangles around detected faces
for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2)

# Show result
cv2.imshow('Detected Faces', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This code uses Haar cascade classifier to detect faces in the image and draws a rectangle around each detected face. Face detection has wide applications in security monitoring, user verification, and more.

Scenario 2: Image Stitching and Panorama Creation

Image stitching is the process of combining multiple images into a large panorama. The opencv-contrib provides a stitcher class that can help us quickly implement this functionality.

import cv2

# Read multiple images
image1 = cv2.imread('image1.jpg')
image2 = cv2.imread('image2.jpg')

# Create stitcher
stitcher = cv2.createStitcher()

# Stitch images
status, result = stitcher.stitch([image1, image2])

# Check if stitching was successful
if status == cv2.Stitcher_OK:
    cv2.imshow('Stitched Image', result)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
else:
    print("Stitching failed")

This code stitches two images into one large image and is suitable for creating panoramic images and similar applications.

Advanced Usage

The opencv-contrib also provides many advanced features, such as DNN modules related to deep learning and object tracking. These features can help you better solve practical problems.

For example, the DNN module can be used to load and run pre-trained deep learning models for image classification, object detection, and other tasks. You can load models from frameworks like TensorFlow and Caffe.

Leave a Comment