OpenCV中feature2D学习——ORB和BruteForceMatcher

向右看齐 2022-08-09 00:37 187阅读 0赞

**一、ORB详细介绍**

（该部分转自：[http://www.cvchina.info/2011/07/04/whats-orb/][http_www.cvchina.info_2011_07_04_whats-orb]）  
ORB是是ORiented Brief的简称。ORB的论文：[http://www.willowgarage.com/sites/default/files/orb\_final.pdf][http_www.willowgarage.com_sites_default_files_orb_final.pdf]

**首先介绍Brief：**  
Brief是Binary Robust Independent Elementary Features的缩写。这个特征描述子是由EPFL的Calonder在ECCV2010上提出的。主要思路就是在特征点附近随机选取若干点对，将这些点对的灰度值的大小，组合成一个二进制串，并将这个二进制串作为该特征点的特征描述子。详细算法描述参考如下论文：  
Calonder M., Lepetit V., Strecha C., Fua P.: BRIEF: Binary Robust Independent Elementary Features. ECCV 2010  
注意在BRIEF eccv2010的文章中，BRIEF描述子中的每一位是由随机选取的两个像素点做二进制比较得来的。文章同样提到，在此之前，需要选取合适的gaussian kernel对图像做平滑处理。（为什么要强调这一点，因为下述的ORB对此作了改进。）  
BRIEF的优点在于速度，缺点也相当明显：  
1：不具备旋转不变性。  
2：对噪声敏感  
3：不具备尺度不变性。  
ORB就是试图解决上述缺点中的1和2.

**如何解决旋转不变性：**  
在ORB的方案中，是采用了FAST作为特征点检测算子。在Sift的方案中，特征点的主方向是由梯度直方图的最大值和次大值所在的bin对应的方向决定的。略嫌耗时。  
在ORB的方案中，特征点的主方向是通过矩（moment）计算而来，公式如下：  
![这里写图片描述][20150928031105909]  
有了主方向之后，就可以依据该主方向提取BRIEF描述子。但是由此带来的问题是，由于主方向会发生变化，随机点对的相关性会比较大，从而降低描述子的判别性。解决方案也很直接，采取贪婪的，穷举的方法，暴力找到相关性较低的随机点对。  
![这里写图片描述][20150928031133814]

**如何解决对噪声敏感的问题：**  
在前面提到过，在最早的eccv2010的文章中，BRIEF使用的是pixel跟pixel的大小来构造描述子的每一个bit。这样的后果就是对噪声敏感。因此，在ORB的方案中，做了这样的改进，不再使用pixel-pair，而是使用9×9的patch-pair，也就是说，对比patch的像素值之和。（可以通过积分图快速计算）。

**关于尺度不变性：**  
ORB没有试图解决尺度不变性，（因为FAST本身就不具有尺度不变性。）但是这样只求速度的特征描述子，一般都是应用在实时的视频处理中的，这样的话就可以通过跟踪还有一些启发式的策略来解决尺度不变性的问题。

**关于计算速度：**  
ORB是sift的100倍，是surf的10倍。

**关于性能：**  
下面是一个性能对比，ORB还是很给力。点击看大图。  
![这里写图片描述][20150928031207114]

**二、代码示例**

1、在使用ORB做特征提取和匹配时，首先需要注意matcher的匹配类型：

使用特征提取过程得到的特征描述符（descriptor）数据类型有的是float类型的，比如说SurfDescriptorExtractor，
    SiftDescriptorExtractor，有的是uchar类型的，比如说有ORB，BriefDescriptorExtractor。
     对应float类型的匹配方式有：FlannBasedMatcher，BruteForce<L2<float>>，BruteForce<SL2<float>>，BruteForce<L1<float>>。
    对应uchar类型的匹配方式有：BruteForce<Hamming>，BruteForce<HammingLUT>。所以ORB和BRIEF特征描述子只能使用BruteForce匹配法。

（参考：[http://blog.csdn.net/holybin/article/details/40926315][http_blog.csdn.net_holybin_article_details_40926315]）

代码如下：

/** 
    * @概述：采用ORB算子进行特征检测与特征值提取，并使用BruteForce匹配法进行特征点的匹配 
    * @类和函数：ORB + BruteForceMatcher 
    * @author：holybin 
    */ 
    
    #include "opencv2/core/core.hpp"
    //#include "opencv2/nonfree/features2d.hpp"   //SurfFeatureDetector实际在该头文件中  
    #include "opencv2/legacy/legacy.hpp"    //BruteForceMatcher实际在该头文件中  
    //#include "opencv2/features2d/features2d.hpp"  //FlannBasedMatcher实际在该头文件中 
    #include "opencv2/highgui/highgui.hpp"
    #include <iostream>
    #include <vector>
    using namespace cv;
    using namespace std;
    
    int main()
    {
        Mat img_1 = imread("starbucks1.jpg");
        Mat img_2 = imread("starbucks2.jpg");
        if (!img_1.data || !img_2.data)
        {
            cout << "error reading images " << endl;
            return -1;
        }
    
        //1.orb检测特征点并提取特征值
        ORB orb;
        vector<KeyPoint> keyPoints_1, keyPoints_2;
        Mat descriptors_1, descriptors_2;
        orb(img_1, Mat(), keyPoints_1, descriptors_1);
        orb(img_2, Mat(), keyPoints_2, descriptors_2);
    
        //2.BruteForceMatcher匹配
        BruteForceMatcher<HammingLUT> matcher;  //也可以使用ruteForce<Hamming>
        vector<DMatch> matches;
        matcher.match(descriptors_1, descriptors_2, matches);
    
        //3.过滤匹配点
        double max_dist = 0; double min_dist = 100;
        //-- Quick calculation of max and min distances between keypoints
        for( int i = 0; i < descriptors_1.rows; i++ )
        { 
            double dist = matches[i].distance;
            if( dist < min_dist ) min_dist = dist;
            if( dist > max_dist ) max_dist = dist;
        }
        printf("-- Max dist : %f \n", max_dist );
        printf("-- Min dist : %f \n", min_dist );
        //-- Draw only "good" matches (i.e. whose distance is less than 0.6*max_dist )
        //-- PS.- radiusMatch can also be used here.
        std::vector< DMatch > good_matches;
        for( int i = 0; i < descriptors_1.rows; i++ )
        { 
            if( matches[i].distance < 0.6*max_dist )
            { 
                good_matches.push_back( matches[i]); 
            }
        }
    
        //4-1.绘制匹配点
        Mat img_matches;
        drawMatches(img_1, keyPoints_1, img_2, keyPoints_2,
            good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
            vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    
        //4-2.根据匹配点绘制目标位置
        // localize the object
        std::vector<Point2f> obj;
        std::vector<Point2f> scene;
        for (size_t i = 0; i < good_matches.size(); ++i)
        {
            // get the keypoints from the good matches
            obj.push_back(keyPoints_1[ good_matches[i].queryIdx ].pt);
            scene.push_back(keyPoints_2[ good_matches[i].trainIdx ].pt);
        }
        Mat H = findHomography( obj, scene, CV_RANSAC );
        // get the corners from the image_1
        std::vector<Point2f> obj_corners(4);
        obj_corners[0] = cvPoint(0,0);
        obj_corners[1] = cvPoint( img_1.cols, 0);
        obj_corners[2] = cvPoint( img_1.cols, img_1.rows);
        obj_corners[3] = cvPoint( 0, img_1.rows);
        std::vector<Point2f> scene_corners(4);
    
        perspectiveTransform( obj_corners, scene_corners, H);
    
        // draw lines between the corners (the mapped object in the scene - image_2)
        line( img_matches, scene_corners[0] + Point2f( img_1.cols, 0), scene_corners[1] + Point2f( img_1.cols, 0),Scalar(255,0,0));
        line( img_matches, scene_corners[1] + Point2f( img_1.cols, 0), scene_corners[2] + Point2f( img_1.cols, 0),Scalar(255,0,0));
        line( img_matches, scene_corners[2] + Point2f( img_1.cols, 0), scene_corners[3] + Point2f( img_1.cols, 0),Scalar(255,0,0));
        line( img_matches, scene_corners[3] + Point2f( img_1.cols, 0), scene_corners[0] + Point2f( img_1.cols, 0),Scalar(255,0,0));
        imshow( "Match", img_matches);
    
        cvWaitKey();
        return 0;
    }

结果：  
![这里写图片描述][20150928031735906]  
![这里写图片描述][20150928031726098]

2、有大牛对于ORB定位目标时透视变换耗时长的问题做了优化，提出了用keypoints的x与y坐标和的平均值作为目标中心点的近似估计：[http://blog.csdn.net/yangtrees/article/details/7545820][http_blog.csdn.net_yangtrees_article_details_7545820]

[http_www.cvchina.info_2011_07_04_whats-orb]: http://www.cvchina.info/2011/07/04/whats-orb/
[http_www.willowgarage.com_sites_default_files_orb_final.pdf]: http://www.willowgarage.com/sites/default/files/orb_final.pdf
[20150928031105909]: /images/20220731/9ca01a798f154610ba67ec4690641836.png
[20150928031133814]: /images/20220731/a4c3571d8dc24939b925636724f30ed8.png
[20150928031207114]: /images/20220731/324bb4fdf2714ac59f45e2679bb99fb7.png
[http_blog.csdn.net_holybin_article_details_40926315]: http://blog.csdn.net/holybin/article/details/40926315
[20150928031735906]: /images/20220731/006cb166e16f41d981c49f5c02bbb19f.png
[20150928031726098]: /images/20220731/751ea87796c346e9bcb797f16ed2b269.png
[http_blog.csdn.net_yangtrees_article_details_7545820]: http://blog.csdn.net/yangtrees/article/details/7545820