OpenCV——SURF特征检测、匹配与对象查找

SURF原理详解：https://wenku.baidu.com/view/2f1e4d8ef705cc1754270945.html

SURF算法工作原理

1. 选择图像中的POI(Points of interest) Hessian Matrix

2. 在不同的尺度空间发现关键点，非最大信号压制

3. 发现特征点方法、旋转不变性要求

4. 生成特征向量

SURF构造函数介绍

C++:  SURF::SURF(

double hessianThreshold, --阈值检测器使用Hessian的关键点，默认值在

300-500之间

int nOctaves=4,                 -- 4表示在四个尺度空间

int nOctaveLayers=2,        -- 表示每个尺度的层数

bool extended=false,

bool upright=false              --表示计算旋转不变性，不计算的速度更快

)

特征点绘制

特征点绘制是为了把检测出来的Surf特征点在原图上绘制出来，这一步是为了把特征点直观的显示出来给我们看，跟整个Surf算子的特征提取和匹配流程没关系。

绘制使用drawKeypoints方法：

void drawKeypoints( const Mat& image,
　　　　　　　　　　　　const vector<KeyPoint>& keypoints,
　　　　　　　　　　　　CV_OUT Mat& outImage,
　　　　　　　　　　　　const Scalar& color=Scalar::all(-),
　　　　　　　　　　　　int flags=DrawMatchesFlags::DEFAULT
);

第一个参数image：原始图像，可以使三通道或单通道图像；

第二个参数keypoints：特征点向量，向量内每一个元素是一个KeyPoint对象，包含了特征点的各种属性信息；

第三个参数outImage：特征点绘制的画布图像，可以是原图像；

第四个参数color：绘制的特征点的颜色信息，默认绘制的是随机彩色；

第五个参数flags：特征点的绘制模式，其实就是设置特征点的那些信息需要绘制，那些不需要绘制，有以下几种模式可选：

　　DEFAULT：只绘制特征点的坐标点,显示在图像上就是一个个小圆点,每个小圆点的圆心坐标都是特征点的坐标。
　　DRAW_OVER_OUTIMG：函数不创建输出的图像,而是直接在输出图像变量空间绘制,要求本身输出图像变量就是一个初始化好了的,size与type都是已经初始化好的变量
　　NOT_DRAW_SINGLE_POINTS：单点的特征点不被绘制
　　DRAW_RICH_KEYPOINTS：绘制特征点的时候绘制的是一个个带有方向的圆,这种方法同时显示图像的坐标,size，和方向,是最能显示特征信息的一种绘制方式。

 #include <opencv2/opencv.hpp>
 #include <opencv2/xfeatures2d.hpp>
 #include <iostream>

 using namespace cv;
 using namespace cv::xfeatures2d;
 using namespace std;

 int main(int argc, char** argv) {
     Mat src = imread("test.jpg", IMREAD_GRAYSCALE);
     if (src.empty()) {
         printf("could not load image...\n");
         return -;
     }
     namedWindow("input image", CV_WINDOW_AUTOSIZE);
     imshow("input image", src);

     // SURF特征点检测
     int minHessian = ;
     Ptr<SURF> detector = SURF::create(minHessian);//创建一个surf类对象并初始化
     vector<KeyPoint> keypoints;
     detector->detect(src, keypoints, Mat());//找出关键点

     // 绘制关键点
     Mat keypoint_img;
     drawKeypoints(src, keypoints, keypoint_img, Scalar::all(-), DrawMatchesFlags::DEFAULT);
     imshow("KeyPoints Image", keypoint_img);

     waitKey();
     return ;
 }

绘制匹配点

drawMatches( const Mat& img1, const vector<KeyPoint>& keypoints1,
                             const Mat& img2, const vector<KeyPoint>& keypoints2,
                             const vector<DMatch>& matches1to2, Mat& outImg,
                             const Scalar& matchColor=Scalar::all(-), const Scalar& singlePointColor=Scalar::all(-),
                             const vector<char>& matchesMask=vector<char>(), int flags=DrawMatchesFlags::DEFAULT );

其中参数如下：

* img1 – 源图像1

* keypoints1 –源图像1的特征点.

* img2 – 源图像2.

* keypoints2 – 源图像2的特征点

* matches1to2 – 源图像1的特征点匹配源图像2的特征点[matches[i]] .

* outImg – 输出图像具体由flags决定.

* matchColor – 匹配的颜色（特征点和连线),若matchColor==Scalar::all(-1)，颜色随机.

* singlePointColor – 单个点的颜色，即未配对的特征点，若matchColor==Scalar::all(-1)，颜色随机.

*matchesMask – Mask决定哪些点将被画出，若为空，则画出所有匹配点.

*flags—它跟drawKeypoints方法中flags的含义是一样的。

当仅使用筛选出的最优匹配点进行匹配的时候，意味着会有很多非最优的特征点不会被匹配，这时候可以设置flags=DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS

BF(暴力)匹配(src目标图，temp需要查找的背景图)

 #include <opencv2/opencv.hpp>
 #include <opencv2/xfeatures2d.hpp>
 #include <iostream>

 using namespace cv;
 using namespace cv::xfeatures2d;
 using namespace std;

 int main(int argc, char** argv) {
     Mat src = imread("数字.jpg");
     Mat temp = imread("2.png");
     if (src.empty() || temp.empty()) {
         printf("could not load image...\n");
         return -;
     }
     namedWindow("input image", CV_WINDOW_AUTOSIZE);
     imshow("input image", src);

     // SURF特征点检测
     int minHessian = ;
     Ptr<SURF> detector = SURF::create(minHessian, , , true, true);//创建一个surf类检测器对象并初始化
     vector<KeyPoint> keypoints1, keypoints2;
     Mat src_vector, temp_vector;//用来存放特征点的描述向量

     //detector->detect(src, keypoints1, Mat());//找出关键点
     //detector->detect(temp, keypoints2, Mat());//找出关键点

     //找到特征点并计算特征描述子(向量)
     detector->detectAndCompute(src, Mat(), keypoints1, src_vector);//输入图像，输入掩码，输入特征点，输出Mat，存放所有特征点的描述向量
     detector->detectAndCompute(temp, Mat(), keypoints2, temp_vector);//这个Mat行数为特征点的个数，列数为每个特征向量的尺寸，SURF是64（维）

     //匹配
     BFMatcher matcher(NORM_L2);         //实例化一个暴力匹配器(括号里可以选择匹配方法)

     vector<DMatch> matches;    //DMatch是用来描述匹配好的一对特征点的类，包含这两个点之间的匹配信息
                                //比如左图有个特征m，它和右图的特征点n最匹配，这个DMatch就记录它俩最匹配，并且还记录m和n的
                                //特征向量的距离和其他信息，这个距离在后面用来做筛选    

     matcher.match(src_vector, temp_vector, matches);             //匹配，数据来源是特征向量，结果存放在DMatch类型里面  

     //匹配点筛选
     //sort函数对数据进行升序排列
     //筛选匹配点，根据match里面特征对的距离从小到大排序
     //筛选出最优的30个匹配点（可以不使用，会画出所有特征点）

     sort(matches.begin(), matches.end());
     vector< DMatch > good_matches;
     int ptsPairs = std::min(, (int)(matches.size() * 0.15));//匹配点数量不大于50
     cout << ptsPairs << endl;
     for (int i = ; i < ptsPairs; i++)
     {
         good_matches.push_back(matches[i]);//距离最小的50个压入新的DMatch
     }

     Mat MatchesImage;                                //drawMatches这个函数直接画出摆在一起的图
     drawMatches(src, keypoints1, temp, keypoints2, good_matches, MatchesImage, Scalar::all(-), Scalar::all(-), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);  //绘制匹配点
     imshow("BFMatcher Image", MatchesImage);

     waitKey();
     return ;
 }

FLANN匹配

 #include <opencv2/opencv.hpp>
 #include <opencv2/xfeatures2d.hpp>
 #include <iostream>
 #include <math.h>

 using namespace cv;
 using namespace cv::xfeatures2d;
 using namespace std;

 int main(int argc, char** argv) {
     Mat src = imread("数字.jpg",);
     Mat temp = imread("2.png",);
     if (src.empty() || temp.empty()) {
         printf("could not load image...\n");
         return -;
     }
     namedWindow("input image", CV_WINDOW_AUTOSIZE);
     imshow("input image", src);

     // SURF特征点检测
     int minHessian = ;
     Ptr<SURF> detector = SURF::create(minHessian, , , true, true);//创建一个surf类检测器对象并初始化
     vector<KeyPoint> keypoints1, keypoints2;
     Mat src_vector, temp_vector;//用来存放特征点的描述向量

     //detector->detect(src, keypoints1, Mat());//找出关键点
     //detector->detect(temp, keypoints2, Mat());//找出关键点

     //找到特征点并计算特征描述子(向量)
     detector->detectAndCompute(src, Mat(), keypoints1, src_vector);//输入图像，输入掩码，输入特征点，输出Mat，存放所有特征点的描述向量
     detector->detectAndCompute(temp, Mat(), keypoints2, temp_vector);//这个Mat行数为特征点的个数，列数为每个特征向量的尺寸，SURF是64（维）

     //匹配
     FlannBasedMatcher matcher;         //实例化一个FLANN匹配器(括号里可以选择匹配方法)

     vector<DMatch> matches;    //DMatch是用来描述匹配好的一对特征点的类，包含这两个点之间的匹配信息
                                //比如左图有个特征m，它和右图的特征点n最匹配，这个DMatch就记录它俩最匹配，并且还记录m和n的
                                //特征向量的距离和其他信息，这个距离在后面用来做筛选    

     matcher.match(src_vector, temp_vector, matches);             //匹配，数据来源是特征向量，结果存放在DMatch类型里面  

     //求最小最大距离
     double minDistance = ;//反向逼近
     double maxDistance = ;
     for (int i=; i< src_vector.rows; i++) {
         double distance = matches[i].distance;
         if (distance > maxDistance)        {
             maxDistance = distance;
         }
         if (distance < minDistance)        {
             minDistance = distance;
         }
     }
     printf("max distance : %f\n", maxDistance);
     printf("min distance : %f\n", minDistance);

     //筛选较好的匹配点
     vector< DMatch > good_matches;
     for (int i = ; i < src_vector.rows; i++) {
         double distance = matches[i].distance;
         if (distance < max(minDistance * , 0.02)) {
             good_matches.push_back(matches[i]);//距离小于范围的压入新的DMatch
         }
     }

     /*//sort函数对数据进行升序排列
     //筛选匹配点，根据match里面特征对的距离从小到大排序
     //筛选出最优的50个匹配点（可以不使用，会画出所有特征点）

     sort(matches.begin(), matches.end());
     vector< DMatch > good_matches;
     int ptsPairs = std::min(50, (int)(matches.size() * 0.15));//匹配点数量不大于50
     cout << ptsPairs << endl;
     for (int i = 0; i < ptsPairs; i++)
     {
         good_matches.push_back(matches[i]);//距离最小的50个压入新的DMatch
     }
     */

     Mat MatchesImage;                                //drawMatches这个函数直接画出摆在一起的图
     drawMatches(src, keypoints1, temp, keypoints2, good_matches, MatchesImage, Scalar::all(-), Scalar::all(-), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);  //绘制匹配点
     imshow("FLANN Image", MatchesImage);

     waitKey();
     return ;
 }

对象查找

 #include <opencv2/opencv.hpp>
 #include <opencv2/xfeatures2d.hpp>
 #include <iostream>
 #include <math.h>

 using namespace cv;
 using namespace cv::xfeatures2d;
 using namespace std;

 int main(int argc, char** argv) {
     Mat src = imread("fire_5.jpg");
     Mat temp = imread("数字.jpg");
     if (src.empty() || temp.empty()) {
         printf("could not load image...\n");
         return -;
     }
     namedWindow("input image", CV_WINDOW_AUTOSIZE);
     imshow("input image", src);

     // SURF特征点检测
     int minHessian = ;
     Ptr<SURF> detector = SURF::create(minHessian, , , true, true);//创建一个surf类检测器对象并初始化
     vector<KeyPoint> keypoints1, keypoints2;
     Mat src_vector, temp_vector;//用来存放特征点的描述向量

     //detector->detect(src, keypoints1, Mat());//找出关键点
     //detector->detect(temp, keypoints2, Mat());//找出关键点

     //找到特征点并计算特征描述子(向量)
     detector->detectAndCompute(src, Mat(), keypoints1, src_vector);//输入图像，输入掩码，输入特征点，输出Mat，存放所有特征点的描述向量
     detector->detectAndCompute(temp, Mat(), keypoints2, temp_vector);//这个Mat行数为特征点的个数，列数为每个特征向量的尺寸，SURF是64（维）

     //匹配
     FlannBasedMatcher matcher;         //实例化一个FLANN匹配器(括号里可以选择匹配方法)

     vector<DMatch> matches;    //DMatch是用来描述匹配好的一对特征点的类，包含这两个点之间的匹配信息
                                //比如左图有个特征m，它和右图的特征点n最匹配，这个DMatch就记录它俩最匹配，并且还记录m和n的
                                //特征向量的距离和其他信息，这个距离在后面用来做筛选    

     matcher.match(src_vector, temp_vector, matches);             //匹配，数据来源是特征向量，结果存放在DMatch类型里面  

     //求最小最大距离
     double minDistance = ;//反向逼近
     double maxDistance = ;
     for (int i = ; i < src_vector.rows; i++) {
         double distance = matches[i].distance;
         if (distance > maxDistance) {
             maxDistance = distance;
         }
         if (distance < minDistance) {
             minDistance = distance;
         }
     }
     printf("max distance : %f\n", maxDistance);
     printf("min distance : %f\n", minDistance);

     //筛选较好的匹配点
     vector< DMatch > good_matches;
     for (int i = ; i < src_vector.rows; i++) {
         double distance = matches[i].distance;
         if (distance < max(minDistance * , 0.02)) {
             good_matches.push_back(matches[i]);//距离小于范围的压入新的DMatch
         }
     }

     Mat MatchesImage;                                //drawMatches这个函数直接画出摆在一起的图
     drawMatches(src, keypoints1, temp, keypoints2, good_matches, MatchesImage, Scalar::all(-), Scalar::all(-), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);  //绘制匹配点  

     vector<Point2f> obj;
     vector<Point2f> objInScene;
     for (size_t t = ; t < good_matches.size(); t++) {
         obj.push_back(keypoints1[good_matches[t].queryIdx].pt);//返回对象在模板图特征点坐标
         objInScene.push_back(keypoints2[good_matches[t].trainIdx].pt);//返回对象在背景查找图的坐标
     }

     Mat H = findHomography(obj,objInScene,RANSAC);//计算透视变换矩阵

     vector<Point2f> obj_corner();
     vector<Point2f> scene_corner();
     obj_corner[] = Point(, );
     obj_corner[] = Point(src.cols, );
     obj_corner[] = Point(src.cols,src.rows);
     obj_corner[] = Point(, src.rows);

     perspectiveTransform(obj_corner, scene_corner,H);//透视变换

     //画出边框线
     line(MatchesImage, scene_corner[] + Point2f(src.cols, ), scene_corner[] + Point2f(src.cols, ), Scalar(, , ), , , );
     line(MatchesImage, scene_corner[] + Point2f(src.cols, ), scene_corner[] + Point2f(src.cols, ), Scalar(, , ), , , );
     line(MatchesImage, scene_corner[] + Point2f(src.cols, ), scene_corner[] + Point2f(src.cols, ), Scalar(, , ), , , );
     line(MatchesImage, scene_corner[] + Point2f(src.cols, ), scene_corner[] + Point2f(src.cols, ), Scalar(, , ), , , );
     imshow("FLANN Image", MatchesImage);

     line(temp, scene_corner[], scene_corner[], Scalar(, , ), , , );
     line(temp, scene_corner[], scene_corner[], Scalar(, , ), , , );
     line(temp, scene_corner[], scene_corner[], Scalar(, , ), , , );
     line(temp, scene_corner[], scene_corner[], Scalar(, , ), , , );
     imshow("temp Image", temp);

     waitKey();
     return ;
 }