OpenCV实战（21）——基于随机样本一致匹配图像

news/2024/11/22 14:00:34/

OpenCV实战（21）——基于随机样本一致匹配图像

    • 0. 前言
    • 1. 基于随机样本一致匹配图像
      • 1.1 计算基本矩阵与匹配集
      • 1.2 随机样本一致算法
    • 2. 算法优化
      • 2.1 优化基本矩阵
      • 2.2 优化匹配集
    • 3. 完整代码
    • 小结
    • 系列链接

0. 前言

当两台摄像机拍摄同一场景时，它们会在不同视角拍摄到相同的元素。我们已经学习了特征点匹配，在本节中，我们将学习如何利用两个视图之间的对极约束来更可靠地匹配图像特征。
我们将遵循以下原则：当匹配两个图像之间的特征点时，只接受落在相应极线上的匹配。为了能够检查是否满足此条件，必须知道基本矩阵，但我们需要较好的匹配来估计这个矩阵，这似乎成了一个先有鸡还是先有蛋的问题。在本节中，我们将学习如何联合计算基本矩阵和一组良好的匹配。

1. 基于随机样本一致匹配图像

我们的目标是能够计算两个视图之间的基本矩阵和一组良好的匹配，为此，需要使用对极约束验证所有特征点的对应关系。

1.1 计算基本矩阵与匹配集

(1) 创建 RobustMatcher 类封装鲁棒匹配过程：

class RobustMatcher {private:// 指向特征点检测器对象的指针cv::Ptr<cv::FeatureDetector> detector;// 指向特征描述符提取器对象的指针cv::Ptr<cv::DescriptorExtractor> descriptor;int normType;float ratio;bool refineF;bool refineM;double distance;double confidence;  // 置信度水平public:RobustMatcher(const cv::Ptr<cv::FeatureDetector>& detector,const cv::Ptr<cv::DescriptorExtractor>& descriptor=cv::Ptr<cv::DescriptorExtractor>()) :detector(detector),descriptor(descriptor), normType(cv::NORM_L2),ratio(0.8f), refineF(true), refineM(true), confidence(0.98), distance(1.0) {if (!this->descriptor) {this->descriptor = this->detector;}}

使用 cv::FeatureDetector 和 cv::DescriptorExtractor 接口以便用户可以通过名称选择创建方法，也可以使用定义的 setter 方法 setFeatureDetector 和 setDescriptorExtractor 指定创建方法。

(2) 类中最重要的是 match 方法，它返回匹配、检测到的关键点和估计的基本矩阵。该方法分为四个步骤：

    // 使用 RANSAC 匹配特征点cv::Mat match(cv::Mat& image1, cv::Mat& image2,     // 输入图像std::vector<cv::DMatch>& matches,       // 输出匹配和关键点std::vector<cv::KeyPoint>& keypoints1,std::vector<cv::KeyPoint>& keypoints2,int check=CROSSCHECK) {                 // 检查类型// 1. 检测特征点detector->detect(image1, keypoints1);detector->detect(image2, keypoints2);std::cout << "Number of feature points (1): " << keypoints1.size() << std::endl;std::cout << "Number of feature points (2): " << keypoints2.size() << std::endl;// 2. 提取特征描述符cv::Mat descriptors1, descriptors2;descriptor->compute(image1,keypoints1,descriptors1);descriptor->compute(image2,keypoints2,descriptors2);std::cout << "descriptor matrix size: " << descriptors1.rows << " by " << descriptors1.cols << std::endl;// 3. 匹配两张图像描述符cv::BFMatcher matcher(normType,         // 距离度量check==CROSSCHECK);     // 交叉检查标记// 匹配向量std::vector<std::vector<cv::DMatch> > matches1;std::vector<std::vector<cv::DMatch> > matches2;std::vector<cv::DMatch> outputMatches;// 比率检查时调用 knnMatchif (check==RATIOCHECK || check==BOTHCHECK) {matcher.knnMatch(descriptors1, descriptors2,matches1,       // 匹配向量2);             // 返回两个最近邻居std::cout << "Number of matched points 1->2: " << matches1.size() << std::endl;if (check==BOTHCHECK) {matcher.knnMatch(descriptors2, descriptors1,matches2,       // 匹配向量2);             // 返回两个最近邻居std::cout << "Number of matched points 2->1: " << matches2.size() << std::endl;}}// 选择检查方法switch (check) {case CROSSCHECK:matcher.match(descriptors1,descriptors2,outputMatches);std::cout << "Number of matched points 1->2 (after cross-check): " << outputMatches.size() << std::endl;break;case RATIOCHECK:ratioTest(matches1,outputMatches);std::cout << "Number of matched points 1->2 (after ratio test): " << outputMatches.size() << std::endl;break;case BOTHCHECK:ratioAndSymmetryTest(matches1,matches2,outputMatches);std::cout << "Number of matched points 1->2 (after ratio and cross-check): " << outputMatches.size() << std::endl;break;case NOCHECK:default:matcher.match(descriptors1,descriptors2,outputMatches);std::cout << "Number of matched points 1->2: " << outputMatches.size() << std::endl;break;}// 4. 使用 RANSAC 验证匹配cv::Mat fundamental= ransacTest(outputMatches, keypoints1, keypoints2, matches);std::cout << "Number of matched points (after RANSAC): " << matches.size() << std::endl;return fundamental;
}

前两步检测特征点并计算它们的描述符；然后使用 cv::BFMatcher 类进行特征匹配，使用 crosscheck 标志来获得更高质量的匹配；第四步是本节引入的新概念，通过一个额外的过滤测试，使用基本矩阵来拒绝不遵守对极约束的匹配。

(3) 随机抽样一致算法 (RANdom SAmple Consensus, RANSAC) 采用迭代的方式从一组包含离群的被观测数据中估算出数学模型的参数。接下来，基于 RANSAC 方法进行过滤测试，即使在匹配集中仍然存在异常值时，也可以计算基本矩阵，编写函数 ransacTest：

// 使用 RANSAC 标示较好的匹配
cv::Mat ransacTest(const std::vector<cv::DMatch>& matches,std::vector<cv::KeyPoint>& keypoints1,std::vector<cv::KeyPoint>& keypoints2,std::vector<cv::DMatch>& outMatches) {std::vector<cv::Point2f> points1, points2;for(std::vector<cv::DMatch>::const_iterator it=matches.begin(); it!=matches.end(); ++it) {points1.push_back(keypoints1[it->queryIdx].pt);points2.push_back(keypoints2[it->trainIdx].pt);}// 使用 RANSAC 计算 F 矩阵std::vector<uchar> inliers(points1.size(), 0);cv::Mat fundamental = cv::findFundamentalMat(points1, points2,       // 匹配点inliers,                // 匹配状态cv::FM_RANSAC,          // RANSAC 方法distance,               // 到极线的距离confidence);            // 置信度// 提取正确匹配std::vector<uchar>::const_iterator itIn = inliers.begin();std::vector<cv::DMatch>::const_iterator itM = matches.begin();for (; itIn!=inliers.end(); ++itIn, ++itM) {if (*itIn) {outMatches.push_back(*itM);}}return fundamental;
}

(4) 在 F F F 矩阵计算之前需要将 keypoints 转换成 cv::Point2f。使用这个类，可以通过以下调用实现图像对的鲁棒匹配：

// 匹配器
RobustMatcher rmatcher(cv::xfeatures2d::SIFT::create(250));
// 匹配两张图像
std::vector<cv::DMatch> matches;
std::vector<cv::KeyPoint> keypoints1, keypoints2;
cv::Mat fundamental = rmatcher.match(image1, image2, matches, keypoints1, keypoints2);

可以得到 228 个匹配项，如下图所示：

鲁棒性匹配
这些匹配几乎都是正确的，有少数错误的匹配意外的落在了基本矩阵的相应核线上。

1.2 随机样本一致算法

我们已经知道可以从多个特征点匹配中估计与图像对相关联的基本矩阵。显然，这个匹配集必须只由质量较好的匹配组成。然而，在实际应用场景中，无法保证通过比较检测到的特征点的描述符获得的匹配集是完全准确的。因此引入了基于 随机抽样一致算法 (RANdom SAmple Consensus, RANSAC) 的基本矩阵估计方法。
RANSAC 算法旨在从可能包含较多异常值的数据集中估计给定的数学实体。其核心是从集合中随机选择一些数据点，并仅使用这些数据点进行估计。所选点的数量应为估计数学实体所需的最少点数。在基本矩阵中，8 个匹配对是最小数量(实际上，也可以使用 7 个匹配对，但 8 点线性算法计算速度更快)。从这 8 个随机匹配中估计出基本矩阵后，匹配集中的所有其他匹配都将根据源自该矩阵的对极约束进行测试。识别满足此约束的所有匹配项，即对应特征与其极线相距较短距离的匹配项。这些匹配形成了计算的基本矩阵的支持集。
RANSAC 算法的核心思想是支持集越大，计算出的矩阵是正确矩阵的概率就越高。相反，如果随机选择的一个(或多个)匹配是不正确的匹配，那么计算的基本矩阵也是不正确的，并且其支持集也很小。此过程会重复多次，最后，支持度最大的矩阵将被保留为最可能的矩阵。
因此，我们多次随机选择 8 个匹配项，以便最终能够选择 8 个质量较好的匹配项，并得到一个较大的支持集。根据整个数据集中错误匹配的数量，选择一组 8 个正确匹配的概率有所不同。然而，通过增加选择的次数，我们有信心能够选择出一个较好的匹配集。更准确地说，如果我们假设匹配集中有 w w w 的正确值 (inlier, 即良好匹配)，那么我们选择的 8 个匹配均是良好匹配的概率是 w 8 w^8 w8。因此，一个选择包含至少一个错误匹配的概率是 ( 1 − w 8 ) (1-w^8) (1−w8) 。如果我们进行 k k k 次选择，则拥有一个包含良好匹配的随机集合的概率仅为 1 − ( 1 − w 8 ) k 1-(1-w^8)^k 1−(1−w8)k ，将其定义为置信概率 c c c ，我们希望这个概率尽可能高，因为至少需要一组好的匹配才能获得正确的基本矩阵。因此，在运行 RANSAC 算法时，需要确定选择匹配集的数量 k k k，以获得给定的置信度。
使用 CV_FM_RANSAC 标志调用 cv::findFundamentalMat 函数时，需要两个额外的参数。第一个参数是置信度(默认值为 0.99)，它决定了要进行的迭代次数；第二个参数是被视为内值的点到极线的最大距离，点与其核线的距离大于指定距离的所有匹配对都被视为异常值。函数返回字符值向量，表明输入集中的相应匹配被识别为异常值 (0) 或正确值 (1)。
在初始匹配集中的匹配越多，使用 RANSAC 算法得到正确基本矩阵的可能性就越大，因此在匹配特征点时应用交叉检查过滤器，也可以使用比率测试以进一步提高最终匹配集的质量。这是为了平衡计算复杂性、最终匹配数以及获得仅包含精确匹配的匹配集，以得到所需的置信水平。
本节中介绍的鲁棒匹配过程的结果是获得具有最大支持度的 8 个选定匹配集，以及利用该支持集中包含的匹配集计算出基本矩阵的估计值。因此可以通过两种方式优化结果。

2. 算法优化

2.1 优化基本矩阵

由于最终我们得到了一个质量较好的匹配集，因此可以使用它们来重新估计基本矩阵。我们使用在上一节中介绍的线性八点算法来估计这个矩阵。因此，可以获得一个超定方程组，该方程组将基于最小二乘法求解基本矩阵。可以将此步骤添加到 ransacTest 函数末尾：

if (refineF) {// F 矩阵会重新计算所接受的匹配points1.clear();points2.clear();for (std::vector<cv::DMatch>::const_iterator it=outMatches.begin();it!=outMatches.end(); ++it) {points1.push_back(keypoints1[it->queryIdx].pt);points2.push_back(keypoints2[it->trainIdx].pt);}// 计算 8 点 F 矩阵fundamental = cv::findFundamentalMat(points1, points2,       // 匹配点cv::FM_8POINT);         // 8 点方法
}

cv::findFundamentalMat 函数通过使用奇异值分解求解线性方程组。

2.2 优化匹配集

我们知道在双目系统中，每个点都必须位于其对应点核线上，这是由基本矩阵表示的对极约束。因此，如果能够很好的估计基本矩阵，则可以使用对极约束通过强制每个点位于它们的核线上来纠正获得的匹配，这可以通过使用 cv::correctMatches 函数完成：

std::vector<cv::Point2f> newPoints1, newPoints2;
correctMatches(fundamental,     // F 矩阵points1, points2,       // 原位置newPoints1, newPoints2);// 新位置

该函数通过修改每个对应点的位置使其满足对极约束，同时最小化累积(平方)偏差。

3. 完整代码

头文件 (robustMatcher.h) 完整代码如下所示：

#if !defined MATCHER
#define MATCHER#include <iostream>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/xfeatures2d.hpp>#define NOCHECK 0
#define CROSSCHECK 1
#define RATIOCHECK 2
#define BOTHCHECK 3class RobustMatcher {private:// 指向特征点检测器对象的指针cv::Ptr<cv::FeatureDetector> detector;// 指向特征描述符提取器对象的指针cv::Ptr<cv::DescriptorExtractor> descriptor;int normType;float ratio;bool refineF;bool refineM;double distance;double confidence;  // 置信度水平public:RobustMatcher(const cv::Ptr<cv::FeatureDetector>& detector,const cv::Ptr<cv::DescriptorExtractor>& descriptor=cv::Ptr<cv::DescriptorExtractor>()) :detector(detector),descriptor(descriptor), normType(cv::NORM_L2),ratio(0.8f), refineF(true), refineM(true), confidence(0.98), distance(1.0) {if (!this->descriptor) {this->descriptor = this->detector;}}// 设置特征检测器void setFeatureDetector(const cv::Ptr<cv::FeatureDetector>& detect) {this->detector = detector;}// 设置描述符提取器void setDescriptorExtractor(const cv::Ptr<cv::DescriptorExtractor>& desc) {this->descriptor = desc;}// 设置匹配时使用的归一化方法void setNormType(int norm) {normType = norm;}// 在 RANSAC 中设置到极线的最小距离 void setMinDistanceToEpipolar(double d) {distance = d;}// 设置 RANSAC 中的阈值水平void setConfidenceLevel(double c) {confidence = c;}// 设置比例void setRatio(float r) {ratio = r;}// 如果要重新计算 F 矩阵void refineFundamental(bool flag) {refineF = flag;}// 如果希望使用 F 重新进行匹配void refineMatches(bool flag) {refineM = flag;}// 移除比率大于阈值的匹配项int ratioTest(const std::vector<std::vector<cv::DMatch> >& inputMatches,std::vector<cv::DMatch>& outputMatches) {int removed = 0;for (std::vector<std::vector<cv::DMatch> >::const_iterator matchIterator=inputMatches.begin();matchIterator!=inputMatches.end(); ++matchIterator) {if ((matchIterator->size()>1) && (*matchIterator)[0].distance/(*matchIterator)[1].distance<ratio) {outputMatches.push_back((*matchIterator)[0]);} else {removed++;}}return removed;}// 在 symMatches 矢量中插入对称匹配void symmetryTest(const std::vector<cv::DMatch>& matches1,const std::vector<cv::DMatch>& matches2,std::vector<cv::DMatch>& symMatches) {for (std::vector<cv::DMatch>::const_iterator matchIterator1=matches1.begin();matchIterator1!=matches1.end(); ++matchIterator1) {for (std::vector<cv::DMatch>::const_iterator matchIterator2=matches2.begin();matchIterator2!=matches2.end(); ++matchIterator2) {if (matchIterator1->queryIdx == matchIterator2->trainIdx &&matchIterator2->queryIdx == matchIterator1->trainIdx) {symMatches.push_back(*matchIterator1);break;}}}}// 应用比率和对称测试void ratioAndSymmetryTest(const std::vector<std::vector<cv::DMatch> >& matches1,const std::vector<std::vector<cv::DMatch> >& matches2,std::vector<cv::DMatch>& outputMatches) {std::vector<cv::DMatch> ratioMatches1;int removed = ratioTest(matches1, ratioMatches1);std::cout << "Number of matched points 1->2 (ratio test) : " << ratioMatches1.size() << std::endl;std::vector<cv::DMatch> ratioMatches2;removed = ratioTest(matches2, ratioMatches2);std::cout << "Number of matched points 1->2 (ratio test) : " << ratioMatches2.size() << std::endl;symmetryTest(ratioMatches1, ratioMatches2, outputMatches);std::cout << "Number of matched points (symmetry test): " << outputMatches.size() << std::endl;}// 使用 RANSAC 标示较好的匹配cv::Mat ransacTest(const std::vector<cv::DMatch>& matches,std::vector<cv::KeyPoint>& keypoints1,std::vector<cv::KeyPoint>& keypoints2,std::vector<cv::DMatch>& outMatches) {std::vector<cv::Point2f> points1, points2;for(std::vector<cv::DMatch>::const_iterator it=matches.begin(); it!=matches.end(); ++it) {points1.push_back(keypoints1[it->queryIdx].pt);points2.push_back(keypoints2[it->trainIdx].pt);}// 使用 RANSAC 计算 F 矩阵std::vector<uchar> inliers(points1.size(), 0);cv::Mat fundamental = cv::findFundamentalMat(points1, points2,       // 匹配点inliers,                // 匹配状态cv::FM_RANSAC,          // RANSAC 方法distance,               // 到极线的距离confidence);            // 置信度// 提取正确匹配std::vector<uchar>::const_iterator itIn = inliers.begin();std::vector<cv::DMatch>::const_iterator itM = matches.begin();for (; itIn!=inliers.end(); ++itIn, ++itM) {if (*itIn) {outMatches.push_back(*itM);}}if (refineF || refineM) {// F 矩阵会重新计算所接受的匹配points1.clear();points2.clear();for (std::vector<cv::DMatch>::const_iterator it=outMatches.begin();it!=outMatches.end(); ++it) {points1.push_back(keypoints1[it->queryIdx].pt);points2.push_back(keypoints2[it->trainIdx].pt);}// 计算 8 点 F 矩阵fundamental = cv::findFundamentalMat(points1, points2,       // 匹配点cv::FM_8POINT);         // 8 点方法if (refineM) {std::vector<cv::Point2f> newPoints1, newPoints2;correctMatches(fundamental,     // F 矩阵points1, points2,       // 原位置newPoints1, newPoints2);// 新位置for (int i=0; i< points1.size(); i++) {std::cout << "(" << keypoints1[outMatches[i].queryIdx].pt.x << "," << keypoints1[outMatches[i].queryIdx].pt.y << ") -> ";std::cout << "(" << newPoints1[i].x << "," << newPoints1[i].y << std::endl;std::cout << "(" << keypoints2[outMatches[i].trainIdx].pt.x << "," << keypoints2[outMatches[i].trainIdx].pt.y << ") -> ";std::cout << "(" << newPoints2[i].x << "," << newPoints2[i].y << std::endl;keypoints1[outMatches[i].queryIdx].pt.x= newPoints1[i].x;keypoints1[outMatches[i].queryIdx].pt.y= newPoints1[i].y;keypoints2[outMatches[i].trainIdx].pt.x= newPoints2[i].x;keypoints2[outMatches[i].trainIdx].pt.y= newPoints2[i].y;}}}return fundamental;}// 使用 RANSAC 匹配特征点cv::Mat match(cv::Mat& image1, cv::Mat& image2,     // 输入图像std::vector<cv::DMatch>& matches,       // 输出匹配和关键点std::vector<cv::KeyPoint>& keypoints1,std::vector<cv::KeyPoint>& keypoints2,int check=CROSSCHECK) {                 // 检查类型// 1. 检测特征点detector->detect(image1, keypoints1);detector->detect(image2, keypoints2);std::cout << "Number of feature points (1): " << keypoints1.size() << std::endl;std::cout << "Number of feature points (2): " << keypoints2.size() << std::endl;// 2. 提取特征描述符cv::Mat descriptors1, descriptors2;descriptor->compute(image1,keypoints1,descriptors1);descriptor->compute(image2,keypoints2,descriptors2);std::cout << "descriptor matrix size: " << descriptors1.rows << " by " << descriptors1.cols << std::endl;// 3. 匹配两张图像描述符cv::BFMatcher matcher(normType,         // 距离度量check==CROSSCHECK);     // 交叉检查标记// 匹配向量std::vector<std::vector<cv::DMatch> > matches1;std::vector<std::vector<cv::DMatch> > matches2;std::vector<cv::DMatch> outputMatches;// 比率检查时调用 knnMatchif (check==RATIOCHECK || check==BOTHCHECK) {matcher.knnMatch(descriptors1, descriptors2,matches1,       // 匹配向量2);             // 返回两个最近邻居std::cout << "Number of matched points 1->2: " << matches1.size() << std::endl;if (check==BOTHCHECK) {matcher.knnMatch(descriptors2, descriptors1,matches2,       // 匹配向量2);             // 返回两个最近邻居std::cout << "Number of matched points 2->1: " << matches2.size() << std::endl;}}// 选择检查方法switch (check) {case CROSSCHECK:matcher.match(descriptors1,descriptors2,outputMatches);std::cout << "Number of matched points 1->2 (after cross-check): " << outputMatches.size() << std::endl;break;case RATIOCHECK:ratioTest(matches1,outputMatches);std::cout << "Number of matched points 1->2 (after ratio test): " << outputMatches.size() << std::endl;break;case BOTHCHECK:ratioAndSymmetryTest(matches1,matches2,outputMatches);std::cout << "Number of matched points 1->2 (after ratio and cross-check): " << outputMatches.size() << std::endl;break;case NOCHECK:default:matcher.match(descriptors1,descriptors2,outputMatches);std::cout << "Number of matched points 1->2: " << outputMatches.size() << std::endl;break;}// 4. 使用 RANSAC 验证匹配cv::Mat fundamental= ransacTest(outputMatches, keypoints1, keypoints2, matches);std::cout << "Number of matched points (after RANSAC): " << matches.size() << std::endl;return fundamental;}// 使用 RANSAC 匹配特征点cv::Mat matchBook(cv::Mat& image1, cv::Mat& image2, // 输入图像std::vector<cv::DMatch>& matches,       // 输出匹配和关键点std::vector<cv::KeyPoint>& keypoints1,std::vector<cv::KeyPoint>& keypoints2) {// 1. 特征点检测detector->detect(image1,keypoints1);detector->detect(image2,keypoints2);// 2. 提取特征描述符cv::Mat descriptors1, descriptors2;descriptor->compute(image1,keypoints1,descriptors1);descriptor->compute(image2,keypoints2,descriptors2);// 3. 匹配图像描述符cv::BFMatcher matcher(normType, // 距离度量true);      // 交叉检查标记     // 匹配描述符std::vector<cv::DMatch> outputMatches;matcher.match(descriptors1,descriptors2,outputMatches);// 4. 使用 RANSAC 验证匹配cv::Mat fundamental= ransacTest(outputMatches, keypoints1, keypoints2, matches);// 返回 F 矩阵return fundamental;}
};#endif

主函数文件 (robustmatching.cpp) 完整代码如下所示：

#include <iostream>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/xfeatures2d.hpp>
#include "robustMatcher.h"int main() {// 读取输入图像cv::Mat image1= cv::imread("01.png",0);cv::Mat image2= cv::imread("02.png",0);if (!image1.data || !image2.data)return 0;cv::namedWindow("Right Image");cv::imshow("Right Image",image1);cv::namedWindow("Left Image");cv::imshow("Left Image",image2);// 匹配器RobustMatcher rmatcher(cv::xfeatures2d::SIFT::create(250));// 匹配两张图像std::vector<cv::DMatch> matches;std::vector<cv::KeyPoint> keypoints1, keypoints2;cv::Mat fundamental = rmatcher.match(image1, image2, matches, keypoints1, keypoints2);// 绘制匹配cv::Mat imageMatches;cv::drawMatches(image1,keypoints1,  // 第一张图像及其关键点image2,keypoints2,  // 第二张图像及其关键点matches,			// 匹配imageMatches,		// 结果cv::Scalar(255,255,255),  // 线颜色cv::Scalar(255,255,255),  // 关键点颜色std::vector<char>(),cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS); cv::namedWindow("Matches");cv::imshow("Matches",imageMatches);// 将关键点转换为 Point2fstd::vector<cv::Point2f> points1, points2;for (std::vector<cv::DMatch>::const_iterator it= matches.begin();it!= matches.end(); ++it) {// 获取左侧图像关键点的位置 float x= keypoints1[it->queryIdx].pt.x;float y= keypoints1[it->queryIdx].pt.y;points1.push_back(keypoints1[it->queryIdx].pt);cv::circle(image1,cv::Point(x,y),3,cv::Scalar(255,255,255),3);//  获取右侧关键点的位置 x= keypoints2[it->trainIdx].pt.x;y= keypoints2[it->trainIdx].pt.y;cv::circle(image2,cv::Point(x,y),3,cv::Scalar(255,255,255),3);points2.push_back(keypoints2[it->trainIdx].pt);}// 绘制极线std::vector<cv::Vec3f> lines1;cv::computeCorrespondEpilines(points1,1,fundamental,lines1);for (std::vector<cv::Vec3f>::const_iterator it= lines1.begin();it!=lines1.end(); ++it) {cv::line(image2,cv::Point(0,-(*it)[2]/(*it)[1]),cv::Point(image2.cols,-((*it)[2]+(*it)[0]*image2.cols)/(*it)[1]),cv::Scalar(255,255,255));}std::vector<cv::Vec3f> lines2; cv::computeCorrespondEpilines(points2,2,fundamental,lines2);for (std::vector<cv::Vec3f>::const_iterator it= lines2.begin();it!=lines2.end(); ++it) {cv::line(image1,cv::Point(0,-(*it)[2]/(*it)[1]),cv::Point(image1.cols,-((*it)[2]+(*it)[0]*image1.cols)/(*it)[1]),cv::Scalar(255,255,255));}cv::namedWindow("Right Image Epilines (RANSAC)");cv::imshow("Right Image Epilines (RANSAC)",image1);cv::namedWindow("Left Image Epilines (RANSAC)");cv::imshow("Left Image Epilines (RANSAC)",image2);cv::waitKey();return 0;
}

小结

在本节中，我们学习了如何利用两个视图之间的对极约束来更可靠地匹配图像特征，基于随机样本一致算法可以同时解决基本矩阵和匹配集的解决问题，并在最后介绍了如何改进计算结果。

系列链接

OpenCV实战（1）——OpenCV与图像处理基础
OpenCV实战（2）——OpenCV核心数据结构
OpenCV实战（3）——图像感兴趣区域
OpenCV实战（4）——像素操作
OpenCV实战（5）——图像运算详解
OpenCV实战（6）——OpenCV策略设计模式
OpenCV实战（7）——OpenCV色彩空间转换
OpenCV实战（8）——直方图详解
OpenCV实战（9）——基于反向投影直方图检测图像内容
OpenCV实战（10）——积分图像详解
OpenCV实战（11）——形态学变换详解
OpenCV实战（12）——图像滤波详解
OpenCV实战（13）——高通滤波器及其应用
OpenCV实战（14）——图像线条提取
OpenCV实战（15）——轮廓检测详解
OpenCV实战（16）——角点检测详解
OpenCV实战（17）——FAST特征点检测
OpenCV实战（18）——特征匹配
OpenCV实战（19）——特征描述符
OpenCV实战（20）——图像投影关系


http://www.ppmy.cn/news/57717.html

相关文章

jdbc和druid和mybatis之间的关系

jdbc和druid和mybatis之间的关系

第一种方式 jdbc整合了:加载数据库驱动,创建连接,写原生语句,执行,关闭这些东西. 第二种方式 mybatis对jdbc进行封装,他允许你通过配置的形式,配置数据库参数,并且允许你通过xml来写动态sql语句.if:test让你可以把sql变得灵活起来.并且还能将你的查询结果直接映射到你想要的…
阅读更多...
位置式pid和增量式pid

位置式pid和增量式pid

位置式PID控制器和增量式PID控制器的数学模型如下所示&#xff1a; 位置式PID控制器的数学模型&#xff1a; u ( t ) K p e ( t ) K i ∫ 0 t e ( τ ) d τ K d d e ( t ) d t u(t) K_p e(t) K_i \int_{0}^{t} e(\tau) d\tau K_d \frac{de(t)}{dt} u(t)Kp​e(t)Ki​∫…
阅读更多...
回首来路多感概，最是奋斗动人心。

回首来路多感概，最是奋斗动人心。

我们必需要在不同的时代有不同的领悟&#xff0c;才能充满生机地去迎接生命中每个新的开始。 文章目录 前言 初心 成长 收获 憧憬 出发 前言 今天是我成为csdn创作者一周年纪念日&#xff0c;我非常开心能够和大家分享我的写作之旅。在这一年里&#xff0c;我经历了许多挑…
阅读更多...
【Python】【进阶篇】19、Django项目创建第一个应用

【Python】【进阶篇】19、Django项目创建第一个应用

目录 19、Django项目创建第一个应用1. 创建应用2. 应用的添加 19、Django项目创建第一个应用 Django 项目就是基于 Django 框架开发的 Web 应用&#xff0c;它包含了一组配置和多个应用&#xff0c;我们把应用称之为 App&#xff0c;在前文中对它也做了相应的介绍&#xff0c;…
阅读更多...
交换机-Exchanges

交换机-Exchanges

交换机 Exchanges 概念 RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上&#xff0c;通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反&#xff0c;生产者只能将消息发送到交换机(exchange)&#xff0c;交换机工作的内容非常简…
阅读更多...
长/短 链接/轮询 和websocket

长/短 链接/轮询 和websocket

短连接和长连接 短连接&#xff1a; http协议底层基于socket的tcp协议&#xff0c;每次通信都会新建一个TCP连接&#xff0c;即每次请求和响应过程都经历”三次握手-四次挥手“优点&#xff1a;方便管理缺点&#xff1a;频繁的建立和销毁连接占用资源 长连接&#xff1a; 客…
阅读更多...
用ChatGPT问DotNet的相关问题，发现DotNet工程师的前景还不错

用ChatGPT问DotNet的相关问题，发现DotNet工程师的前景还不错

本人最近费了九牛二虎之力注册了一个ChatGPT账号&#xff0c;现在就给大家分享一下&#xff0c;问一下关于.NET的问题&#xff0c;看看ChatGPT的AI功能具体如何&#xff1f; 一、C#跟其它语言比较的优势 回答&#xff1a; C#是一门编程语言&#xff0c;它是为 Microsoft 的 …
阅读更多...
永磁同步电机（PMSM）无传感器控制基于滑膜观测器Matlab/Simulink仿真分析

永磁同步电机（PMSM）无传感器控制基于滑膜观测器Matlab/Simulink仿真分析

文章目录 前言一、状态观测器二、滑膜状态观测器2.1.滑膜观测器的原理2.2.传统的滑膜观测器2.3.改进的滑膜观测器 三、Matlab/Simulink仿真分析3.1.仿真电路分析3.1.1 电机控制模式切换3.1.2 速度环控制3.1.3 电流环控制3.1.4 电机主电路 3.2.仿真结果分析 总结 前言 本章节采…
阅读更多...
最新文章

Copyright @ 2022~2023