[人工智能]opencv的ORB特征（slambook2 orb_cv.cpp代码详解）

ORB特征提取与匹配

slambook2/ch7/orb_cv.cpp

1. 头文件

#include <iostream>
#include <opencv2/core/core.hpp>//处理图像的工具
#include <opencv2/features2d/features2d.hpp>//处理特征点信息
#include <opencv2/highgui/highgui.hpp>//作图绘制关键点圆圈和描述子信息
#include <chrono> //用于计时

using namespace std;//标准命名空间
using namespace cv;//cv命名空间

在opencv头文件

#include <opencv2/opencv.hpp>

包含了前面的部分头文件

#include <opencv2/core/core.hpp>//处理图像的工具
#include <opencv2/features2d/features2d.hpp>//处理特征点信息
#include <opencv2/highgui/highgui.hpp>//作图绘制关键点圆圈和描述子信息

可以替换，节省代码开发量

2. 图片输入

取保输入图片的数量为2

int main(int argc, char **argv) { //argc 输入参数的个数，argv 输入的参数
	if (argc != 3) {  // 系统本身加两张图片argc 表示传入数目
		cout << "usage: feature_extraction img1 img2" << endl;
		return 1;
	}

	Mat img_1 = imread(argv[1], CV_LOAD_IMAGE_COLOR);//表示以彩色图像形式读取argv中的参数信息，并且存贮于img_1中
	Mat img_2 = imread(argv[2], CV_LOAD_IMAGE_COLOR);
	assert(img_1.data != nullptr && img_2.data != nullptr);//判断传入数据是否为图像

Mat 为 opencv 中的类 ，无需定义维度 ，自适应。另外，这里img_1和img_2存储了两张图像的颜色信息，其维度为2维，大小为480640（这里存储数据的矩阵维度并非480640，而是480*(640*3)，因为要存储每个像素点的BGR信息，因此每个像素的信息对应1行和3列）。

imread函数

#include <opencv2/imgcodecs.hpp>
Mat cv::imread	(	const String & 	filename,int flags = IMREAD_COLOR )		

• 返回值，Mat 类型， 即返回读取的图像，读取图像失败时返回一个空的矩阵对象（Mat::data == NULL)
• 参数1 filename， 读取的图片文件名，可以使用相对路径或者绝对路径，但必须带完整的文件扩展名（图片格式后缀）
• 参数2 flags, 一个读取标记，用于选择读取图片的方式，默认值为1，flag值的设定与用什么颜色格式读取图片有关

图像类型有以下几种：

CV_LOAD_IMAGE_UNCHANGED——等价取值为-1，这个标识在新版本中已被废置，可以忽略

CV_LOAD_IMAGE_GRAYSCALE——等价取值为0，返回灰色图像

CV_LOAD_IMAGE_COLOR——等价取值为1，返回彩色图像

CV_LOAD_IMAGE_ANYDEPTH——等价取值为2，若图像深度是16位或者32位，就返回对应深度，否则，返回8位图像

如果输入有冲突的标志，将采用较小的数字值

assert断言函数
assert宏的原型定义在<assert.h>中，其作用是如果它的条件返回错误，则终止程序执行，原型定义：

#include <assert.h>
 
void assert( int expression );

个人理解：
assert()的用法本质就像一个if语句，如果程序在我的假设条件下，能够正常运行，

3.初始化

	std::vector<KeyPoint> keypoints_1, keypoints_2;//容器vector类型<keypoint>图片1 -> 关键点1 图片2 -> 关键点2;存储角度 距离 分类 关键点坐标 金字塔层数等关键信息。
	Mat descriptors_1, descriptors_2;//描述子
	Ptr<FeatureDetector> detector = ORB::create();可以修改特征点的个数来增加匹配点数量 特征点检测
	Ptr<DescriptorExtractor> descriptor = ORB::create();//描述子
	Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");//特征匹配 匹配时计算描述子之间的距离使用汉明距离

FeatureDetector特征检测器类，通过创建该类对象来使用多种特征检测方法。【用于检测指定特征点的角点位置】 OpenCV2.4.3中提供了10种特征检测方法：FAST，SIFT，SURF，ORB，HARRIS，SimpleBlob，STAR，MSER，GFTT，Dense。
这里使用ORB特征检测方法

DescriptorExtractor特征描述子提取类，提供了一些特征描述子提取的算法。
其可以针对图像关键点，计算其特征描述子，其可以被表达成密集(dense)，即固定维数的向量。 其计算方式为每隔固定个像素计算。
一个特征描述子是一个向量，特征描述子的集合为Mat格式，每一行是一个关键点的特征描述子。
OpenCV支持四种类型的特征描述子提取方法：SIFT，SURF，ORB，BRIEF。

DescriptorMatcher特征匹配类，提供了一些特征点匹配的方法。 该类主要包含图像对之间的匹配以及图像和一个图像集之间的匹配。
OpenCV2中的特征匹配方法都继承自该类。 对于误匹配情况，提供了KNNMatch方法。

vector

vector<T> v1 // 保存类型为T 对象

Ptr detector = ORB::create();

 static Ptr<ORB> cv::ORB::create (
        int     nfeatures = 500,    //The maximum number of features to retain.
        float   scaleFactor = 1.2f,
                                    //金字塔抽取比，大于1。scaleFactor==2表示经典金字塔，每一层的像素都比上一层少4倍，
                                    //但如此大的尺度因子会显著降低特征匹配得分。
                                    //另一方面，过于接近1的比例因素将意味着要覆盖一定的比例范围，
                                    //你将需要更多的金字塔级别，因此速度将受到影响。
        int     nlevels = 8,        //金字塔等级的数量。
                                    //最小级别的线性大小等于input_image_linear_size/pow(scaleFactor, nlevels).
                                    //输入图像线性大小/功率(缩放因子，非线性)。
        int     edgeThreshold = 31,  //这是未检测到特征的边框大小。它应该大致匹配patchSize参数.
        int     firstLevel = 0,     //It should be 0 in the current implementation.
        int     WTA_K = 2,          //产生oriented BRIEF描述子的每个元素的点数。
        int     scoreType = ORB::HARRIS_SCORE,
                                    //默认的HARRIS_SCORE意味着HARRIS算法用于对特征进行排序
                                    //(分数被写入KeyPoint::score，并用于保留最佳特征)；
                                    //FAST_SCORE是参数的另一个值，它会产生稍微不太稳定的关键点，
                                    //但是计算起来要快一点。
        int     patchSize = 31,     //oriented BRIEF描述符使用的补丁大小。
                                    //在较小的金字塔层上，被特征覆盖的感知图像区域会更大。
        int     fastThreshold = 20
   )

nfeatures ：最多提取的特征点的数量；
scaleFactor ： 金字塔图像之间的尺度参数，类似于SIFT中的?；
nlevels： 高斯金字塔的层数；
edgeThreshold ：边缘阈值，这个值主要是根据后面的patchSize来定的，靠近边缘edgeThreshold以内的像素是不检测特征点的。
firstLevel-：看过SIFT都知道，我们可以指定第一层的索引值，这里默认为0。
WET_K ： 用于产生BIREF描述子的点对的个数，一般为2个，也可以设置为3个或4个，那么这时候描述子之间的距离计算就不能用汉明距离了，而是应该用一个变种。OpenCV中，如果设置WET_K = 2，则选用点对就只有2个点，匹配的时候距离参数选择NORM_HAMMING，如果WET_K设置为3或4，则BIREF描述子会选择3个或4个点，那么后面匹配的时候应该选择的距离参数为NORM_HAMMING2。
scoreType ：用于对特征点进行排序的算法，你可以选择HARRIS_SCORE，也可以选择FAST_SCORE，但是它也只是比前者快一点点而已。
patchSize ：用于计算BIREF描述子的特征点邻域大小。

4.第一步:检测 Oriented FAST 角点位置

  //使用detect方法，将其存入Keypoints变量中
  chrono::steady_clock::time_point t1 = chrono::steady_clock::now();//检测 Oriented FAST 角点前计时
  detector->detect(img_1, keypoints_1);//检测图片1的Oriented FAST 角点
  detector->detect(img_2, keypoints_2);//检测图片2的Oriented FAST 角点

C++11 chrono库

5.第二步:根据角点位置计算 BRIEF 描述子

  descriptor->compute(img_1, keypoints_1, descriptors_1);//计算图片1的描述子
  descriptor->compute(img_2, keypoints_2, descriptors_2);//计算图片2的描述子
  chrono::steady_clock::time_point t2 = chrono::steady_clock::now();//计算耗时
  chrono::duration<double> time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);//计算检测角点和计算描述子所用的时间
  cout << "extract ORB cost = " << time_used.count() << " seconds. " << endl;//输出extract ORB cost =
 
  Mat outimg1;//定义ORB特征显示结果的变量
  drawKeypoints(img_1, keypoints_1, outimg1, Scalar::all(-1), DrawMatchesFlags::DEFAULT);//画出图像1的ORB特征点提取结果
  imshow("ORB features", outimg1);//显示图像1的ORB特征点提取结果

drawKeypoint函数

cv2.drawKeypoints(image, keypoints, outImage, color=None, flags=None)

image
原始图像，可以使三通道或单通道图像；

keypoints 特征点向量，向量内每一个元素是一个KeyPoint对象，包含了特征点的各种属性信息； outImage
特征点绘制的画布图像，可以是原图像； color 绘制的特征点的颜色信息，默认绘制的是随机彩色； Scalar::all(-1) //颜色随机
flags 特征点的绘制模式，其实就是设置特征点的那些信息需要绘制，那些不需要绘制，有以下几种模式可选：

DEFAULT：只绘制特征点的坐标点,显示在图像上就是一个个小圆点,每个小圆点的圆心坐标都是特征点的坐标。

DRAW_OVER_OUTIMG：函数不创建输出的图像,而是直接在输出图像变量空间绘制,要求本身输出图像变量就是一个初始化好了的,size与type都是已经初始化好的变量
NOT_DRAW_SINGLE_POINTS：单点的特征点不被绘制

DRAW_RICH_KEYPOINTS：绘制特征点的时候绘制的是一个个带有方向的圆,这种方法同时显示图像的坐标,size，和方向,是最能显示特征的一种绘制方式。

6. 第三步:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离

  vector<DMatch> matches;//匹配matches
  t1 = chrono::steady_clock::now();//计时
  matcher->match(descriptors_1, descriptors_2, matches);//描述子1和描述子2进行匹配
   // 使用match方法，获取最匹配的两个特征点(匹配的特征点可以有多对，均存放在matche中)
  t2 = chrono::steady_clock::now();//计时
  time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);//计算耗时
  cout << "match ORB cost = " << time_used.count() << " seconds. " << endl;//输出match ORB cost

7. 第四步:匹配点对筛选

 // 计算最小距离和最大距离
  auto min_max = minmax_element(matches.begin(), matches.end(),
                                [](const DMatch &m1, const DMatch &m2) { return m1.distance < m2.distance; });//Dmatch对象保存的是匹配成功的结果，当然这个匹配结果里面包含了不少的误匹配。                                
  //minmax_element()为c++中定义的寻找最小值和最大值的函数。
  //第3个参数表示比较函数，默认从小到大，可以省略

  //distance： 为两个描述子之间的距离
  double min_dist = min_max.first->distance;//将两幅图像的ORB特征点之间的最小距离赋值给min_dist
  double max_dist = min_max.second->distance;//将两幅图像的ORB特征点之间的最大距离赋值给max_dist
 
  printf("-- Max dist : %f \n", max_dist);//	输出两幅图像的ORB特征点匹配的最大距离
  printf("-- Min dist : %f \n", min_dist);//	输出两幅图像的ORB特征点匹配的最小距离
  

  //当描述子之间的距离大于两倍的最小距离时,即认为匹配有误.但有时候最小距离会非常小,设置一个经验值30作为下限.
  //找出所有匹配之间的最小距离和最大距离, 即是最相似的和最不相似的两组点之间的距离
  std::vector<DMatch> good_matches;//
  for (int i = 0; i < descriptors_1.rows; i++)//遍历描述子
   {
    if (matches[i].distance <= max(2 * min_dist, 30.0)) //不同的结果可以在这里设置
    //当描述子之间的距离大于两倍的最小距离时,即认为匹配有误 30.0为经验值
    {
      good_matches.push_back(matches[i]);
    }
  }

minmax_element() 函数

    minmax_element (ForwardIterator first, ForwardIterator last, Compare comp);

first：一个输入迭代器，指示要比较的范围的第一个位置。

last：一个输入迭代器，指示要比较的范围中过去的最后一个元素。

comp： 一个用户定义的二元谓词函数，它接受两个参数，如果两个参数按顺序返回真，否则返回假。它遵循严格的弱排序来对元素进行排序。

8. 第五步:绘制匹配结果

  Mat img_match;//绘制匹配结果变量
  Mat img_goodmatch;//绘制剔除误匹配的匹配结果变量
  drawMatches(img_1, keypoints_1, img_2, keypoints_2, matches, img_match);//画出粗匹配匹配结果
  drawMatches(img_1, keypoints_1, img_2, keypoints_2, good_matches, img_goodmatch);//画出剔除误匹配的匹配结果
  imshow("all matches", img_match);//界面展示粗匹配匹配结果
  imshow("good matches", img_goodmatch);//界面展示剔除误匹配的匹配结果
  waitKey(0);

9。完整代码（稍作改动）

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgcodecs/legacy/constants_c.h>
#include <chrono>

using namespace std;
using namespace cv;

int main(int argc, char **argv) {
//   if (argc != 3) {
//     cout << "usage: feature_extraction img1 img2" << endl;
//     return 1;
//   }
  //-- 读取图像
  Mat img_1 = imread("/home/yjh/study/image/1.png", CV_LOAD_IMAGE_COLOR);
  Mat img_2 = imread("/home/yjh/study/image/2.png", CV_LOAD_IMAGE_COLOR);
  assert(img_1.data != nullptr && img_2.data != nullptr);

  //-- 初始化
  std::vector<KeyPoint> keypoints_1, keypoints_2;
  Mat descriptors_1, descriptors_2;
  Ptr<FeatureDetector> detector = ORB::create();
  Ptr<DescriptorExtractor> descriptor = ORB::create();
  Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("BruteForce-Hamming");

  //-- 第一步:检测 Oriented FAST 角点位置
  chrono::steady_clock::time_point t1 = chrono::steady_clock::now();
  detector->detect(img_1, keypoints_1);
  detector->detect(img_2, keypoints_2);

  //-- 第二步:根据角点位置计算 BRIEF 描述子
  descriptor->compute(img_1, keypoints_1, descriptors_1);
  descriptor->compute(img_2, keypoints_2, descriptors_2);
  chrono::steady_clock::time_point t2 = chrono::steady_clock::now();
  chrono::duration<double> time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);
  cout << "extract ORB cost = " << time_used.count() << " seconds. " << endl;

  Mat outimg1;
  drawKeypoints(img_1, keypoints_1, outimg1, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
  imshow("ORB features", outimg1);

  //-- 第三步:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离
  vector<DMatch> matches;
  t1 = chrono::steady_clock::now();
  matcher->match(descriptors_1, descriptors_2, matches);
  t2 = chrono::steady_clock::now();
  time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);
  cout << "match ORB cost = " << time_used.count() << " seconds. " << endl;

  //-- 第四步:匹配点对筛选
  // 计算最小距离和最大距离
  auto min_max = minmax_element(matches.begin(), matches.end(),
                                [](const DMatch &m1, const DMatch &m2) { return m1.distance < m2.distance; });
  double min_dist = min_max.first->distance;
  double max_dist = min_max.second->distance;

  printf("-- Max dist : %f \n", max_dist);
  printf("-- Min dist : %f \n", min_dist);

  //当描述子之间的距离大于两倍的最小距离时,即认为匹配有误.但有时候最小距离会非常小,设置一个经验值30作为下限.
  std::vector<DMatch> good_matches;
  for (int i = 0; i < descriptors_1.rows; i++) {
    if (matches[i].distance <= max(2 * min_dist, 30.0)) {
      good_matches.push_back(matches[i]);
    }
  }

  //-- 第五步:绘制匹配结果
  Mat img_match;
  Mat img_goodmatch;
  drawMatches(img_1, keypoints_1, img_2, keypoints_2, matches, img_match);
  drawMatches(img_1, keypoints_1, img_2, keypoints_2, good_matches, img_goodmatch);
  imshow("all matches", img_match);
  imshow("good matches", img_goodmatch);
  waitKey(0);

  return 0;
}