FAST Keypoint Detection Example with OpenCV in Python

     One of the fundamental tasks in computer vision is feature detection, where distinctive points in an image are identified for further analysis. The FAST (Features from Accelerated Segment Test) algorithm is a popular and efficient method for detecting key points or features in an image. These key points are distinctive locations in the image that can be used for various computer vision tasks, such as object recognition, image matching, and tracking. 

    In this tutorial, we will explore the FAST algorithm and how it can be implemented using OpenCV. The tutorial covers:

1. Understanding the FAST algorithm
2. Implementing FAST in OpenCV
3. Conclusion
   

     Let's get started.

 

Understanding the FAST algorithm

    Before diving into the FAST algorithm, let's understand what keypoints are. Keypoints, also known as feature points, are specific locations in an image that stand out due to unique characteristics. These features can be corners, edges, or other interesting structures that make an image distinguishable.

    While there are various feature detection algorithms, FAST distinguishes itself with its computational efficiency. It was designed to identify keypoints quickly, making it suitable for real-time applications, such as object tracking, robotic navigation, and others.

    The core idea of FAST algorithm is to focus on local intensity variations in an image. It examines a circular region around each pixel and checks if at least 12 neighboring pixels are brighter or darker than the center pixel. If this condition is met, the center pixel is considered a keypoint.

    The algorithm includes the following steps.

1. Feature Selection: The FAST algorithm starts by selecting a pixel as the center pixel in the image.
2. Circle Test: Next, it examines a small circle of neighboring pixels around the center pixel. This circle consists of 16 pixels, which are evenly spaced at 22.5 degrees apart. 
3. Brightness Comparison: For each of the 16 neighboring pixels, the algorithm compares their intensity (brightness) with the intensity of the center pixel.
4. Feature Detection: If at least 12 consecutive pixels in the circle are all brighter or all darker than the center pixel, it means that the center pixel is a key point or feature.
5. Non-Maximum Suppression: The algorithm quickly checks all pixels in the image using the circle test. Once all potential key points are found, it applies a process called non-maximum suppression. This step removes redundant and less significant key points, ensuring that only the most distinctive features are retained.
6. Output: The final output of the FAST algorithm is a list of key points with their corresponding positions in the image.

    FAST is designed to be computationally efficient, making it suitable for real-time applications and scenarios where fast feature detection is essential. By focusing on the brightness variations in the neighborhood of each pixel, FAST can quickly identify important features in the image, making it a popular choice for feature detection tasks.

 

Implementing FAST in OpenCV

 

   OpenCV library provides cv2.FastFeatureDetector_create() function for creating a FAST (Features from Accelerated Segment Test) feature detector object. This function is used to initialize and configure the FAST keypoint detector, allowing us to find distinctive points, known as keypoints or corner, in an image.

We'll start to call function and it returns a new FAST feature detector object that is ready to use. By default, it creates the FAST detector with standard parameters. However, we can pass optional arguments to the function to modify the detector's behavior:

• threshold: Specifies the threshold for keypoint detection. Higher values result in fewer keypoints, while lower values detect more keypoints.
• nonmaxSuppression: A boolean flag that determines whether non-maximum suppression should be applied. Setting it to `True` will perform non-maximum suppression, which removes redundant keypoints.
  

 

fast = cv2.FastFeatureDetector_create(threshold=20, nonmaxSuppression=True)

 

    The detector is then used to find keypoints in the image using the detect() method. The detect() function takes an input image as its parameter. The detect() function returns a list of Keypoint objects, where each object represents a detected keypoint in the image. This list contains all the keypoints found by the FAST algorithm in the input image.

 

 

keypoints = fast.detect(gray_image)

 

    Now we can implement all the steps of the algorithm with Opencv. First we load the required libraries for this code. Then, load the image and convert it to grayscale. We create the FAST detector object using cv2.FastFeatureDetector_create() function. Next, we apply the FAST algorithm on the grayscale image to detect keypoints using fast.detect() function. Finally, we draw the keypoints on the original image using cv2.drawKeypoints() function and display the result.

 

import cv2

from matplotlib import pyplot as plt

import numpy as np

# Load the image

image = cv2.imread("chess.jpg")

# Convert the image to grayscale

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Create the FAST detector object

# A lower threshold value will result in less suppression

fast = cv2.FastFeatureDetector_create(threshold=30)

# Detect keypoints using the FAST algorithm

keypoints = fast.detect(gray, None)

# Draw the keypoints on the image

result_image = cv2.drawKeypoints(image, keypoints, None, color=(0, 255, 0))

# Display the original image with keypoints marked

plt.figure(figsize = (10, 8))

plt.imshow(cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB))

plt.title('FAST Feature Detection')

plt.show()

 

 

 

 

 Conclusion

 

    The FAST algorithm is a powerful tool for identifying key features in images quickly. Its simplicity and efficiency make it an ideal choice for real-time applications. By implementing FAST using OpenCV, we can easily integrate this algorithm into various computer vision projects. Keypoint detection is a fundamental step in many computer vision tasks, and understanding FAST opens the door to a wide range of exciting applications.

    In this tutorial, we've briefly explored FAST keypoint detection algorithm and its implementation with OpenCV API in Python. 

 

 

References:

1. OpenCV image processing
2. https://en.wikipedia.org/wiki/Features_from_accelerated_segment_test