Python+OpenCV：图像快速角点检测算法(FAST Algorithm for Corner Detection)

旧城等待， 2022-12-24 00:42 159阅读 0赞

## Python+OpenCV：图像快速角点检测算法(FAST Algorithm for Corner Detection) ##

### 理论 ###

**Feature Detection using FAST**

1.  Select a pixel **p** in the image which is to be identified as an interest point or not. Let its intensity be** Ip**.
2.  Select appropriate threshold value **t**.
3.  Consider a circle of 16 pixels around the pixel under test. (See the image below).
4.  Now the pixel **p** is a corner if there exists a set of **n** contiguous pixels in the circle (of 16 pixels) which are all brighter than **Ip+t**, or all darker than **Ip−t**. (Shown as white dash lines in the above image). **n** was chosen to be 12.
5.  A **high-speed test** was proposed to exclude a large number of non-corners. This test examines only the four pixels at 1, 9, 5 and 13 (First 1 and 9 are tested if they are too brighter or darker. If so, then checks 5 and 13). If **p** is a corner, then at least three of these must all be brighter than **Ip+t** or darker than **Ip−t**. If neither of these is the case, then **p** cannot be a corner. The full segment test criterion can then be applied to the passed candidates by examining all pixels in the circle. This detector in itself exhibits high performance, but there are several weaknesses:

*  It does not reject as many candidates for n < 12.
 *  The choice of pixels is not optimal because its efficiency depends on ordering of the questions and distribution of corner appearances.
 *  Results of high-speed tests are thrown away.
 *  Multiple features are detected adjacent to one another.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70][]

First 3 points are addressed with a machine learning approach. Last one is addressed using non-maximal suppression.

**Machine Learning a Corner Detector**

1.  Select a set of images for training (preferably from the target application domain)
2.  Run FAST algorithm in every images to find feature points.
3.  For every feature point, store the 16 pixels around it as a vector. Do it for all the images to get feature vector P.
4.  Each pixel (say x) in these 16 pixels can have one of the following three states:  
    ![20201125215230656.jpg][]
5.  Depending on these states, the feature vector P is subdivided into 3 subsets, Pd, Ps, Pb.
6.  Define a new boolean variable, Kp, which is true if p is a corner and false otherwise.
7.  Use the ID3 algorithm (decision tree classifier) to query each subset using the variable Kp for the knowledge about the true class. It selects the x which yields the most information about whether the candidate pixel is a corner, measured by the entropy of Kp.
8.  This is recursively applied to all the subsets until its entropy is zero.
9.  The decision tree so created is used for fast detection in other images.

**Non-maximal Suppression**

Detecting multiple interest points in adjacent locations is another problem. It is solved by using Non-maximum Suppression.

1.  Compute a score function, **V** for all the detected feature points. **V** is the sum of absolute difference between p and 16 surrounding pixels values.
2.  Consider two adjacent keypoints and compute their **V** values.
3.  Discard the one with lower **V** value.

### FAST Feature Detector in OpenCV ###

####################################################################################################
    # 图像快速角点检测算法(FAST Algorithm for Corner Detection)
    def lmc_cv_image_fast_corner_detection():
        """
            函数功能: 图像快速角点检测算法(FAST Algorithm for Corner Detection)。
        """
    
        stacking_images = []
        image_file_name = ['D:/99-Research/Python/Image/Butterfly01.jpg',
                           'D:/99-Research/Python/Image/Butterfly02.jpg',
                           'D:/99-Research/Python/Image/Butterfly03.jpg',
                           'D:/99-Research/Python/Image/Butterfly04.jpg']
        for i in range(len(image_file_name)):
            # 读取图像
            image = lmc_cv.imread(image_file_name[i])
            image = lmc_cv.cvtColor(image, lmc_cv.COLOR_BGR2RGB)
            gray_image = lmc_cv.cvtColor(image, lmc_cv.COLOR_BGR2GRAY)
    
            # Initiate FAST object with default values
            fast = lmc_cv.FastFeatureDetector_create()
    
            # find and draw the keypoints
            keypoints = fast.detect(gray_image, None)
            result_image1 = lmc_cv.drawKeypoints(gray_image, keypoints, None, color=(255, 0, 0),
                                                 flags=lmc_cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
            # Print all default params
            print("Threshold: {}".format(fast.getThreshold()))
            print("nonmaxSuppression:{}".format(fast.getNonmaxSuppression()))
            print("neighborhood: {}".format(fast.getType()))
            print("Total Keypoints with nonmaxSuppression: {}".format(len(keypoints)))
    
            # Disable nonmaxSuppression
            fast.setNonmaxSuppression(0)
            kp = fast.detect(gray_image, None)
            print("Total Keypoints without nonmaxSuppression: {}".format(len(kp)))
            result_image2 = lmc_cv.drawKeypoints(gray_image, keypoints, None, color=(255, 0, 0),
                                                 flags=lmc_cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
    
            # stacking images side-by-side
            stacking_image = np.hstack((image, result_image1, result_image2))
            stacking_images.append(stacking_image)
    
        # 显示图像
        for i in range(len(stacking_images)):
            pyplot.figure('FAST Algorithm for Corner Detection %d' % (i + 1))
            pyplot.subplot(1, 1, 1)
            pyplot.imshow(stacking_images[i], 'gray')
            pyplot.title('FAST Algorithm for Corner Detection')
            pyplot.xticks([])
            pyplot.yticks([])
        pyplot.show()
    
        # 根据用户输入保存图像
        if ord("q") == (lmc_cv.waitKey(0) & 0xFF):
            # 销毁窗口
            pyplot.close('all')
        return

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 4][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70]: /images/20221120/74410945c148495a849fe965699450b0.png
[20201125215230656.jpg]: /images/20221120/a94574f3c69f4c3fbfd8e14c6dadf7e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 1]: /images/20221120/76efcc20aff947fc9dbd051852177d1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 2]: /images/20221120/b6e8b5c251304a1b9b1e73db09a42272.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 3]: /images/20221120/099adc4e435542ba8236dbbc7ee200fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201125220441670.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdWJpbmc4NjA5,size_16,color_FFFFFF,t_70