3D视觉(四)：ORB特征提取与匹配

3D视觉(四)：ORB特征提取与匹配

根据维基百科的定义，图像特征是一组与计算任务相关的信息，计算任务取决于具体的应用。简而言之，特征是图像信息的另一种表达形式。

数字图像在计算机中以灰度值矩阵的方式存储，所以最简单的单个图像像素也是一种特征。但是在视觉里程计中，我们希望特征点在相机运动中仍然保持稳定，而灰度值受光照、形变、物体材质的影响严重，在不同图像间变化非常大，不够稳定。

理想情况是，当场景和相机视角发生少量改变时，算法还能从图像中判断哪些地方是同一个点。所以仅凭灰度值是不够的，我们需要对图像提取特征点。

一、ORB特征原理

特征点由关键点Key-point和描述子Descriptor两部分组成。例如，当我们说“在一张图像中计算SIFT特征点”时，是指“提取SIFT关键点、计算SIFT描述子”两件事情。

关键点是指该特征点在图像里的位置。描述子通常是一个向量，按照某种人为设计的方式，描述了该关键点周围像素的信息。描述子是按照“外观相似的特征应该有相似的描述子”的原则设计的，因此，只要两个特征点的描述子在向量空间上的距离相近，就可以认为它们是同样的特征点。

ORB特征由关键点和描述子两部分组成。它的关键点称为“Oriented FAST”，是一种改进的FAST角点，它的描述子称为BRIEF，是一种速度极快的二进制描述子。

1.1、FAST关键点

FAST是一种角点，主要检测局部像素灰度变化明显的地方，以速度快著称。它的思想是：如果一个像素与邻域的像素差别较大（过亮或过暗），那么它可能是角点。相比于其他角点检测算法，FAST只需比较像素亮度的大小，十分快捷。

FAST角点检测流程如下：

针对FAST角点不具有方向性和尺度的弱点，ORB添加了尺度和旋转描述。尺度不变性由构建图像金字塔，并在金字塔的每一层上检测角点来实现。而特征的旋转是由灰度质心法实现，计算每个区域块的特征方向向量，将区域块做对应旋转后，再提取相应的描述子。

在旋转方面，我们计算特征点附近的图像灰度质心。所谓质心，是指以图像块灰度值作为权重的中心。灰度质心法的具体步骤如下：

1.2、BRIEF描述子

BRIEF是一种二进制描述子，其描述向量由许多个0和1组成，这里0和1编码了关键点附近两个随机像素（比如p和q）的大小关系：如果p比q大，则取1，反之取0。如果我们取了128个这样的p和q，则最后可以得到128维由0和1组成的向量。

注意，虽然说p和q是随意选取的，实际操作中我们会采用一个固定的模板，从这个模板中选取对应的像素索引。这个模板是研究者们精心设计的，能保证提取出的BRIEF向量有较好的效果。

BRIEF使用了随机选点的比较，速度非常快，而且由于使用了二进制表达，存储起来也十分方便，适用于实时的图像匹配。

1.3、ORB特征匹配

特征匹配是视觉SLAM中极为关键的一步，它解决了SLAM中的数据关联问题(data association）,即确定当前看到的landmark与之前看到的landmark之间的对应关系。通过对图像与图像之间的描述子进行准确匹配，可以为后续姿态估计、优化等操作减轻大量负担。

然而由于图像特征的局部特性，误匹配的情况广泛存在，而且长期一来一直没有得到有效解决，目前已经称为视觉SLAM中制约性能提升的一大瓶颈。部分原因是场景中经常存在大量的重复纹理，使得特征描述非常相似，在这种情况下，仅利用局部特征解决误匹配是非常困难的。

二、算法流程

2.1、提取ORB特征的流程

step 1：提取FAST关键点，得到一系列landmark坐标位置。

step 2：对每个landmark标志点，选定patch，计算图像块的矩，得到旋转方向。

step 3：利用已经设计好的orb pattern，选取特定点对，得到二维点坐标。

step 4：根据旋转方向，对二维点坐标进行旋转，实现特征提取的旋转不变性。

step 5：比较二维点坐标位置的像素值，赋予0或1，重复步骤256次，计算得到BRIEF特征。

2.2、ORB特征匹配的流程

step 1：检测两张图片各自的Oriented FAST角点位置，得到keypoints_1、 keypoints_2。

step 2：根据角点位置，计算各自的BRIEF描述子，得到descriptors_1、descriptors_2。

step 3：对两幅图像中的BRIEF描述子进行匹配，基于Hamming距离，得到匹配点对matches。

step 4：对匹配点对做筛选剔除，保留下正确的匹配，得到good_matches。

三、实验过程

由双目摄像头拍摄得到两张图像：

分别提取各自的ORB特征，得到landmark位置和描述子：

进行特征匹配，得到对应点对：

四、源码

借助OpenCV函数的ORB特征提取：

#include <iostream>
#include <opencv2/core/core.hpp>
// core是opencv的主要头文件，包含数据结构，矩阵运算，数据变换，内存管理，文本、数学等功能
#include <opencv2/features2d/features2d.hpp>
// features2d模块，包含特征提取和匹配等功能
#include <opencv2/highgui/highgui.hpp>
// highgui模块，包含图形界面、视频图像处理等功能
#include <chrono>
// chrono是C++11新加入的方便时间日期操作的标准库，它既是相应的头文件名称，也是std命名空间下的一个子命名空间，所有时间日期相关定义均在std::chrono命名空间下
// 通过这个新的标准库，可以非常方便进行时间日期相关操作。


using namespace std;
using namespace cv;


// ORB特征匹配算法流程：
// 第1步：检测两张图片各自的Oriented FAST角点位置，得到keypoints_1, keypoints_2;
// 第2步：根据角点位置，计算各自的BRIEF描述子，得到descriptors_1, descriptors_2;
// 第3步：对两幅图像中的BRIEF描述子进行匹配，基于Hamming距离，得到匹配点对matches;
// 第4步：对匹配点对做筛选剔除，保留下正确的匹配，得到good_matches;
// 第5步：作图，绘制匹配结果


int main(int argc, char **argv) {
   
   
  
  // 读取图像
  Mat img_1 = imread("../left_3.jpg");
  Mat img_2 = imread("../right_3.jpg");
  assert(img_1.data != nullptr && img_2.data != nullptr);

  // 创建vector容器，存储特征点
  std::vector<KeyPoint> keypoints_1, keypoints_2;
  // 创建Mat矩阵，存储特征点的描述子
  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);
  
  // 输出提取到的特征点位置
  cout << "keypoints_1.size :" << keypoints_1.size() << "  keypoints_2.size :" << keypoints_2.size() << endl;
  // for(int k=0; k<keypoints_1.size();k++)
  // {
   
   
  //     cout << keypoints_1[k].pt.x << "  " << keypoints_1[k].pt.y << endl;
  // }
  
  chrono::steady_clock::time_point t2 = chrono::steady_clock::now();
  chrono::duration<double> time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);
  cout << "检测特征点耗时: " << time_used.count() << "s" << endl;
  
  // 作图显示
  Mat outimg1, outimg2;
  drawKeypoints(img_1, keypoints_1, outimg1, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
  drawKeypoints(img_2, keypoints_2, outimg2, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
  imshow("ORB features1", outimg1);
  imshow("ORB features2", outimg2);
  waitKey(0);
  cv::imwrite("../demo/ORB_features1.png", outimg1);
  cv::imwrite("../demo/ORB_features2.png", outimg2);
  
  // 第二步:根据角点位置计算 BRIEF 描述子
  descriptor->compute(img_1, keypoints_1, descriptors_1);
  descriptor->compute(img_2, keypoints_2, descriptors_2);
  // 这里descriptors是一个 500*32 的二维矩阵，表示有500个landmark，每个标志点特征用32维的向量记录
  cout << "第1张图片检测出来的ORB特征的描述子: " << descriptors_1.rows << " " << descriptors_1.cols << endl;
  cout << "第2张图片检测出来的ORB特征的描述子: " << descriptors_2.rows << " " << descriptors_2.cols << endl;
  
  // 每个特征点位置，提取得到一个32维度的特征
  // cout << descriptors_1 << endl;
  // [232,  84, 213,  84, 104,  76, 109,  48,  49, 170,  98, 120, 115,  55, 133, 255,  20, 244, 108, 106, 105,  86, 225,  46,  23, 186, 101, 144,  2, 241,  70,  61;
  // 138, 204, 146, 255,  85, 213, 190, 230,  31,  14,  84,   2, 172, 255,  33,  64, 249, 123, 147, 194,  98, 156,  90, 255, 103, 215, 158, 139,  22,  89,  61, 138;
  // 11, 159,  50, 223,  53, 183,  30, 246,  95,  73,  92,  38, 172, 186, 166, 228, 223,  58, 150, 128, 134, 152, 113, 255,  47, 127, 154, 131,  22, 204, 184,  15;
  // ... ... ...
  //  181,  94, 110, 254, 102, 130,  79, 112, 212, 130, 246, 230, 115, 201, 177,  97, 126, 228,  22, 238, 233, 167,  12,  46, 114, 171, 227, 136, 125, 187, 112, 49;
  // 66, 178, 187, 186,  41, 237,  57,  87, 175,  93, 177, 125, 190, 158,  74, 123, 167,  51, 253,   1, 151,  73, 178, 209, 211, 209, 122, 251,   8,   4, 135,  83]
  
  // 第三步:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离
  vector<DMatch> matches;
  t1 = chrono::steady_clock::now();
  matcher->match(descriptors_1, descriptors_2, matches);
  
  // matches数据结构包含的内容有：
  // size：配对成功的特征点对数
  // queryIdx：当前“匹配点”在查询图像的特征在KeyPoints1向量中的索引号，可以据此找到匹配点在查询图像中的位置
  // trainIdx：当前“匹配点”在训练（模板）图像的特征在KeyPoints2向量中的索引号，可以据此找到匹配点在训练图像中的位置
  // distance：两个特征点之间的欧氏距离，越小表明匹配度越高
  // imgIdx：当前匹配点对应训练图像（如果有若干个）的索引，如果只有一个训练图像跟查询图像配对，即两两配对，则imgIdx=0
  
  // 输出匹配好的特征点对的距离和索引
  // cout << matches.size() << endl;  // 497
  // for(int k=0; k<matches.size(); k++)
  // {
   
   
  //     cout << matches[k].distance << " " << matches[k].queryIdx << " " << matches[k].trainIdx  << " " << matches[k].imgIdx << endl;
  // }
  
  t2 = chrono::steady_clock::now();
  time_used = chrono::duration_cast<chrono::duration<double>>(t2 - t1);
  cout << "特征点对匹配耗时: " << time_used.count() << "s" << endl;
  
  
  // 第四步:匹配点对筛选
  // 计算最小距离和最大距离
  
  // minmax_element函数，返回指定范围内的最大最小值的元素的迭代器组成的一个pair, 如果最值多于一个，firstf返回的是第一个出现的最小值的迭代器，second返回的是最后一个出现的最大值的迭代器
  // 第三个参数cmp可写可不写，max_element() 和 min_element() 默认是从小到大排列，然后 max_element() 输出最后一个值，min_element() 输出第一个值
  // 但是如果自定义的cmp函数写的是从大到小排列，那么会导致max_element()和min_element()的两个结果是对调的，这里利用lambda表达式定义了cmp函数
  // []后面的代码称为lambda表达式，获取代码{}中的返回值，函数符返回值是一个bool

  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;

  cout  << "匹配点对的最大距离: " << max_dist << endl;
  cout  << "匹配点对的最小距离: " << min_dist << endl;
  
  // 当描述子之间的距离大于两倍的最小距离时，即认为匹配有误，但有时候最小距离会非常小，设置一个经验值30作为下限
  std::vector<DMatch> good_matches;
  for (int i = 0; i < matches.size(); 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);
  cv::imwrite("../demo/all_matches.png", img_match);
  cv::imwrite("../demo/good_matches.png", img_goodmatch);

  return 0;
}

自己实现的ORB特征提取：

#include <opencv2/opencv.hpp>
// opencv.hpp中包含了OpenCV各模块的头文件，如高层GUI图形用户界面模块头文件highgui.hpp、图像处理模块头文件imgproc.hpp、2D特征模块头文件features2d.hpp等
#include <string>
// string头文件基本已经包含在iostream中，但平时使用建议加上#include <string>，尤其是使用string类型、使用cin、cout语句输入输出string类型变量、使用strlen()、strcpy()等函数时
#include <nmmintrin.h>
// SSE指令集，能大幅优化文本处理速度
#include <chrono>
// chrono是C++11新加入的方便时间日期操作的标准库，它既是相应的头文件名称，也是std命名空间下的一个子命名空间，所有时间日期相关定义均在std::chrono命名空间下


using namespace std;
using namespace cv;


// 提取ORB特征具体细节：
// 1、利用OpenCV的cv::FAST函数，检测出图像中FAST特征标志点landmark;
// 2、对于每个landmark标志点，选定patch，计算图像块的矩，得到旋转方向;
// 3、利用已经设计好的orb pattern，选取特定点对，得到二维点坐标;
// 4、根据旋转方向，对二维点坐标进行旋转;
// 5、比较此时点对的像素值，赋予0或1，重复步骤256次，计算得到BRIEF特征


string first_file = "../1.png";
string second_file = "../2.png";

// 每个unsigned int型含32位，容器中存储8个，则可以表示256维的0-1的BRIEF特征

typedef vector<uint32_t> DescType; // Descriptor type


/**
 * compute descriptor of orb keypoints
 * @param img input image
 * @param keypoints detected fast keypoints
 * @param descriptors descriptors
 * 
 * 也就是说，如果FAST算法检测到的landmark在边界附近，无法得到周边的邻域，则也无法计算出BRIEF描述子，此时该landmark将被舍弃忽略
 * 
 * 如果关键点超出边界（8像素），描述符将不会被计算，并将保留为空
 * 
 * NOTE: if a keypoint goes outside the image boundary (8 pixels), descriptors will not be computed and will be left as empty
 * 
 */
void ComputeORB(const cv::Mat &img, vector<cv::KeyPoint> &keypoints, vector<DescType> &descriptors);


/**
 * 根据两幅图像各自提取出来的BRIEF特征描述子，进行特征匹配，并存储于matches中
 * 
 * brute-force match two sets of descriptors
 * @param desc1 the first descriptor
 * @param desc2 the second descriptor
 * @param matches matches of two images
 */
void BfMatch(const vector<DescType> &desc1, const vector<DescType> &desc2, vector<cv::DMatch> &matches);


int main(int argc, char **argv) {
   
   

  // 加载图像
  cv::Mat first_image = cv::imread(first_file);
  cv::Mat second_image = cv::imread(second_file);
  assert(first_image.data != nullptr && second_image.data != nullptr);

  chrono::steady_clock::time_point t1 = chrono::steady_clock::now();
  
  // 调用OpenCV库 FAST算法， 设置参数threshold=40，检测图片中的landmark标志点
  vector<cv::KeyPoint> keypoints1;
  cv::FAST(first_image, keypoints1, 40);
  
  // 调用自定义的函数，根据检测得到的landmark，提取其对应的BRIEF特征描述子
  vector<DescType> descriptor1;
  ComputeORB(first_image, keypoints1, descriptor1);

  // 同样进行landmark检测、并提取BRIEF特征描述子
  vector<cv::KeyPoint> keypoints2;
  vector<DescType> descriptor2;
  cv::FAST