C++实现ORB特征检测与特征匹配

最新推荐文章于 2024-05-09 21:28:50 发布

梅花暖楠

最新推荐文章于 2024-05-09 21:28:50 发布

阅读量1.1k

点赞数 5

文章标签： c++ 计算机视觉 opencv

本文链接：https://blog.youkuaiyun.com/weixin_43283119/article/details/137518571

版权

本文介绍了如何使用OpenCV中的ORB算法进行图像特征检测、BRIEF描述子计算以及匹配过程，同时记录了每个步骤的时间消耗，展示了匹配点对的筛选方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码注释1：

  //-- 初始化
  // 定义了两个std::vector<KeyPoint>类型的变量keypoints_1和keypoints_2，用于保存检测到的特征点。
  std::vector<KeyPoint> keypoints_1, keypoints_2;

  // 定义了两个cv::Mat类型的变量descriptors_1和descriptors_2，用于保存提取到的特征描述子。
  cv::Mat descriptors_1, descriptors_2;

  // 创建了一个cv::Ptr<FeatureDetector>类型的指针detector，使用cv::ORB::create()函数创建了ORB特征检测器。
  cv::Ptr<FeatureDetector> detector = cv::ORB::create();

  // 创建了一个cv::Ptr<DescriptorExtractor>类型的指针descriptor，同样使用cv::ORB::create()函数创建了ORB特征描述子提取器。
  cv::Ptr<DescriptorExtractor> descriptor = cv::ORB::create();

  // 创建了一个cv::Ptr<DescriptorMatcher>类型的指针matcher，
  // 使用cv::DescriptorMatcher::create("BruteForce-Hamming")函数创建了一个使用汉明距离的暴力匹配器。
  cv::Ptr<DescriptorMatcher> matcher = cv::DescriptorMatcher::create("BruteForce-Hamming");

代码注释2：

 //-- 第一步:检测 Oriented FAST 角点位置
  chrono::steady_clock::time_point t1 = chrono::steady_clock::now();
  detector->detect(img_1, keypoints_1); // 对 img_1 进行特征点检测，并将检测到的特征点保存在 keypoints_1 中。
  detector->detect(img_2, keypoints_2); // 对 img_2 进行特征点检测，并将检测到的特征点保存在 keypoints_2 中。

  //-- 第二步:根据角点位置计算 BRIEF 描述子
  // 对 img_1 中的特征点 keypoints_1 进行特征描述子提取，并将提取到的特征描述子保存在 descriptors_1 中。
  descriptor->compute(img_1, keypoints_1, descriptors_1);
  // 对 img_2 中的特征点 keypoints_2 进行特征描述子提取，并将提取到的特征描述子保存在 descriptors_2 中。
  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;

代码注释3：

  /**
   * 通过调用 cv::drawKeypoints 函数来绘制特征点。函数的参数依次为：
   * img_1：输入的原始图像。
   * keypoints_1：特征点的位置信息
   * outimg1：输出的绘制特征点后的图像
   * cv::Scalar::all(-1)：绘制特征点的颜色，这里使用 -1 表示随机颜色。
   * cv::DrawMatchesFlags::DEFAULT：绘制特征点的附加标志，这里使用默认值。
  */

  cv::Mat outimg1; // 用于存储绘制特征点后的图像
  cv::drawKeypoints(img_1, keypoints_1, outimg1, cv::Scalar::all(-1), cv::DrawMatchesFlags::DEFAULT);
  cv::imshow("ORB features", outimg1);

代码注释4：

  //-- 第三步:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离
  // matches 用于匹配关键点描述符的类查询描述符索引、训练描述符索引、训练图像索引和描述符之间的距离。
  vector<cv::DMatch> matches;
  t1 = chrono::steady_clock::now();
  // 使用 matcher 对 descriptors_1 和 descriptors_2 进行特征描述子匹配，并将匹配结果保存在matches中。
  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;

代码注释5：

  //-- 第四步:匹配点对筛选
  // 计算最小距离和最大距离
  /**
   * 首先，通过调用 minmax_element 函数，传入 matches.begin() 和 matches.end() 迭代器范围，
   * 使用 lambda 表达式 [](const cv::DMatch &m1, const cv::DMatch &m2) { return m1.distance < m2.distance; } 作为比较函数，
   * 来找到 matches 中距离最小和最大的元素。
   * 然后，使用 min_max.first 获取最小值的迭代器，并通过 ->distance 获取对应的距离值，将其赋值给 min_dist 变量。
   * 接下来，使用 min_max.second 获取最大值的迭代器，并通过 ->distance 获取对应的距离值，将其赋值给 max_dist 变量。
  */

  auto min_max = std::minmax_element(matches.begin(), matches.end(),
                                [](const cv::DMatch &m1, const cv::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);

完整代码：

#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;

int main(int argc, char **argv) {
  if (argc != 3) {
    cout << "usage: feature_extraction img1 img2" << endl;
    return 1;
  }

  //-- 读取图像
  cv::Mat img_1 = cv::imread(argv[1], cv::IMREAD_COLOR);
  cv::Mat img_2 = cv::imread(argv[2], cv::IMREAD_COLOR);
  assert(img_1.data != nullptr && img_2.data != nullptr);

  //-- 初始化
  // 定义了两个std::vector<KeyPoint>类型的变量keypoints_1和keypoints_2，用于保存检测到的特征点。
  std::vector<KeyPoint> keypoints_1, keypoints_2;

  // 定义了两个cv::Mat类型的变量descriptors_1和descriptors_2，用于保存提取到的特征描述子。
  cv::Mat descriptors_1, descriptors_2;

  // 创建了一个cv::Ptr<FeatureDetector>类型的指针detector，使用cv::ORB::create()函数创建了ORB特征检测器。
  cv::Ptr<FeatureDetector> detector = cv::ORB::create();

  // 创建了一个cv::Ptr<DescriptorExtractor>类型的指针descriptor，同样使用cv::ORB::create()函数创建了ORB特征描述子提取器。
  cv::Ptr<DescriptorExtractor> descriptor = cv::ORB::create();

  // 创建了一个cv::Ptr<DescriptorMatcher>类型的指针matcher，
  // 使用cv::DescriptorMatcher::create("BruteForce-Hamming")函数创建了一个使用汉明距离的暴力匹配器。
  cv::Ptr<DescriptorMatcher> matcher = cv::DescriptorMatcher::create("BruteForce-Hamming");



  //-- 第一步:检测 Oriented FAST 角点位置
  chrono::steady_clock::time_point t1 = chrono::steady_clock::now();
  detector->detect(img_1, keypoints_1); // 对 img_1 进行特征点检测，并将检测到的特征点保存在 keypoints_1 中。
  detector->detect(img_2, keypoints_2); // 对 img_2 进行特征点检测，并将检测到的特征点保存在 keypoints_2 中。

  //-- 第二步:根据角点位置计算 BRIEF 描述子
  // 对 img_1 中的特征点 keypoints_1 进行特征描述子提取，并将提取到的特征描述子保存在 descriptors_1 中。
  descriptor->compute(img_1, keypoints_1, descriptors_1);
  // 对 img_2 中的特征点 keypoints_2 进行特征描述子提取，并将提取到的特征描述子保存在 descriptors_2 中。
  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;


  /**
   * 通过调用 cv::drawKeypoints 函数来绘制特征点。函数的参数依次为：
   * img_1：输入的原始图像。
   * keypoints_1：特征点的位置信息
   * outimg1：输出的绘制特征点后的图像
   * cv::Scalar::all(-1)：绘制特征点的颜色，这里使用 -1 表示随机颜色。
   * cv::DrawMatchesFlags::DEFAULT：绘制特征点的附加标志，这里使用默认值。
  */

  cv::Mat outimg1; // 用于存储绘制特征点后的图像
  cv::drawKeypoints(img_1, keypoints_1, outimg1, cv::Scalar::all(-1), cv::DrawMatchesFlags::DEFAULT);
  cv::imshow("ORB features", outimg1);

  //-- 第三步:对两幅图像中的BRIEF描述子进行匹配，使用 Hamming 距离
  // matches 用于匹配关键点描述符的类查询描述符索引、训练描述符索引、训练图像索引和描述符之间的距离。
  vector<cv::DMatch> matches;
  t1 = chrono::steady_clock::now();
  // 使用 matcher 对 descriptors_1 和 descriptors_2 进行特征描述子匹配，并将匹配结果保存在matches中。
  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;

  //-- 第四步:匹配点对筛选
  // 计算最小距离和最大距离
  /**
   * 首先，通过调用 minmax_element 函数，传入 matches.begin() 和 matches.end() 迭代器范围，
   * 使用 lambda 表达式 [](const cv::DMatch &m1, const cv::DMatch &m2) { return m1.distance < m2.distance; } 作为比较函数，
   * 来找到 matches 中距离最小和最大的元素。
   * 然后，使用 min_max.first 获取最小值的迭代器，并通过 ->distance 获取对应的距离值，将其赋值给 min_dist 变量。
   * 接下来，使用 min_max.second 获取最大值的迭代器，并通过 ->distance 获取对应的距离值，将其赋值给 max_dist 变量。
  */

  auto min_max = std::minmax_element(matches.begin(), matches.end(),
                                [](const cv::DMatch &m1, const cv::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, 40.0)) {
      good_matches.push_back(matches[i]);
    }
  }

  //-- 第五步:绘制匹配结果
  cv::Mat img_match; // 创建一个空的图像用于存储所有匹配的关键点
  cv::Mat img_goodmatch;  // 创建一个空的图像用于存储好的匹配的关键点

  // 绘制所有匹配的关键点
  cv::drawMatches(img_1, keypoints_1, img_2, keypoints_2, matches, img_match);

  // 绘制好的匹配的关键点
  cv::drawMatches(img_1, keypoints_1, img_2, keypoints_2, good_matches, img_goodmatch);

  cv::imshow("all matches", img_match);
  cv::imshow("good matches", img_goodmatch);
  cv::waitKey(0);

  return 0;
}