devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

特征点匹配及消除误匹配点_模板匹配误检去除

作者：Monodyee | 2024-03-27 21:49:56

赞

踩

模板匹配误检去除

Mastering OpenCV with Practical Computer Vision Projects 中的第三章里面讲到了几种特征点匹配的优化方式




1. OpenCV提供了两种Matching方式：

• Brute-force matcher (cv::BFMatcher) 

• Flann-based matcher (cv::FlannBasedMatcher)

Brute-force matcher就是用暴力方法找到点集一中每个descriptor在点集二中距离最近的descriptor；

Flann-based matcher 使用快速近似最近邻搜索算法寻找（用快速的第三方库近似最近邻搜索算法）

一般把点集一称为 train set （训练集）对应模板图像，点集二称为 query set（查询集）对应查找模板图的目标图像。

为了提高检测速度，你可以调用matching函数前，先训练一个matcher。训练过程可以首先使用cv::FlannBasedMatcher来优化，为descriptor建立索引树，这种操作将在匹配大量数据时发挥巨大作用（比如在上百幅图像的数据集中查找匹配图像）。而Brute-force matcher在这个过程并不进行操作，它只是将train descriptors保存在内存中。



2. 在matching过程中可以使用cv::DescriptorMatcher的如下功能来进行匹配：

  • 简单查找最优匹配：void match(const Mat& queryDescriptors, vector<DMatch>& matches,const vector<Mat>& masks=vector<Mat>() );
  • 为每个descriptor查找K-nearest-matches：void knnMatch(const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int k,const vector<Mat>&masks=vector<Mat>(),bool compactResult=false );
  • 查找那些descriptors间距离小于特定距离的匹配：void radiusMatch(const Mat& queryDescriptors, vector<vector<DMatch> >& matches, maxDistance, const vector<Mat>& masks=vector<Mat>(), bool compactResult=false );

3. matching结果包含许多错误匹配，错误的匹配分为两种：

  • False-positive matches: 将非对应特征点检测为匹配（我们可以对他做文章，尽量消除它）
  • False-negative matches: 未将匹配的特征点检测出来（无法处理，因为matching算法拒绝）
为了消除False-positive matches采用如下两种方式：
  • Cross-match filter：
在OpenCV中 cv::BFMatcher class已经支持交叉验证，建立  cv::BFMatcher将第二参数声明为true
cv::Ptr<cv::DescriptorMatcher> matcher(new cv::BFMatcher(cv::NORM_HAMMING,true));
经过 Cross-match filter的结果：

  • Ratio test
使用KNN-matching算法，令K=2。则每个match得到两个最接近的descriptor，然后计算最接近距离和次接近距离之间的比值，当比值大于既定值时，才作为最终match。

[cpp]  view plain  copy
 
  在CODE上查看代码片 派生到我的代码片
  1. void PatternDetector::getMatches(const cv::Mat& queryDescriptors,  std::vector<cv::DMatch>& matches)  
  2. {  
  3.     matches.clear();  
  4.     if (enableRatioTest)  
  5.     {  
  6.         // To avoid NaNs when best match has   
  7.         // zero distance we will use inverse ratio.   
  8.         const float minRatio = 1.f / 1.5f;  
  9.         // KNN match will return 2 nearest   
  10.         // matches for each query descriptor  
  11.         m_matcher->knnMatch(queryDescriptors, m_knnMatches, 2);  
  12.         for (size_t i=0; i<m_knnMatches.size(); i++)  
  13.         {  
  14.             const cv::DMatch& bestMatch = m_knnMatches[i][0];  
  15.             const cv::DMatch& betterMatch = m_knnMatches[i][1];  
  16.             float distanceRatio = bestMatch.distance /   
  17.                 betterMatch.distance;  
  18.             // Pass only matches where distance ratio between   
  19.             // nearest matches is greater than 1.5   
  20.             // (distinct criteria)  
  21.             if (distanceRatio < minRatio)  
  22.             {  
  23.                 matches.push_back(bestMatch);  
  24.             }  
  25.         }  
  26.     }  
  27.     else  
  28.     {  
  29.         // Perform regular match  
  30.         m_matcher->match(queryDescriptors, matches);  
  31.     }  
  32. }   

4. Homography estimation

为了进一步提升匹配精度，可以采用随机样本一致性（RANSAC）方法。
因为我们是使用一幅图像（一个平面物体），我们可以将它定义为刚性的，可以在pattern image和query image的特征点之间找到单应性变换（homography transformation ）。使用cv::findHomography找到这个单应性变换，使用RANSAC找到最佳单应性矩阵。（由于这个函数使用的特征点同时包含正确和错误匹配点，因此计算的单应性矩阵依赖于二次投影的准确性）
[cpp]  view plain  copy
 
  在CODE上查看代码片 派生到我的代码片
  1. bool PatternDetector::refineMatchesWithHomography  
  2. (  
  3. const std::vector<cv::KeyPoint>& queryKeypoints,  
  4. const std::vector<cv::KeyPoint>& trainKeypoints,   
  5. float reprojectionThreshold,  
  6. std::vector<cv::DMatch>& matches,  
  7. cv::Mat& homography  
  8. )  
  9. {  
  10. const int minNumberMatchesAllowed = 8;  
  11. if (matches.size() < minNumberMatchesAllowed)  
  12. return false;  
  13. // Prepare data for cv::findHomography  
  14. std::vector<cv::Point2f> srcPoints(matches.size());  
  15. std::vector<cv::Point2f> dstPoints(matches.size());  
  16. for (size_t i = 0; i < matches.size(); i++)  
  17. {  
  18. srcPoints[i] = trainKeypoints[matches[i].trainIdx].pt;  
  19. dstPoints[i] = queryKeypoints[matches[i].queryIdx].pt;  
  20. }  
  21. // Find homography matrix and get inliers mask  
  22. std::vector<unsigned char> inliersMask(srcPoints.size());  
  23. homography = cv::findHomography(srcPoints,   
  24. dstPoints,   
  25. CV_FM_RANSAC,   
  26. reprojectionThreshold,   
  27. inliersMask);  
  28. std::vector<cv::DMatch> inliers;  
  29. for (size_t i=0; i<inliersMask.size(); i++)  
  30. {  
  31. if (inliersMask[i])  
  32. inliers.push_back(matches[i]);  
  33. }  
  34. matches.swap(inliers);  //释放空内存
  35. return matches.size() > minNumberMatchesAllowed;  
  36. }   

经过单应性变换的过滤结果

运用H矩阵进行误匹配点去除：
[cpp]  view plain  copy
  1.   
[cpp]  view plain  copy
  1. #include "opencv2/core/core.hpp"  
  2. #include "opencv2/features2d/features2d.hpp"  
  3. #include "opencv2/highgui/highgui.hpp"  
  4. #include "opencv2/calib3d/calib3d.hpp"  
  5. #include "opencv2/nonfree/nonfree.hpp"  
  6. #include <iostream>  
  7. using namespace cv;  
  8. using namespace std;  
  9.   
  10. int main(  )  
  11. {  
  12.     //【0】改变console字体颜色  
  13.     system("color 1F");   
  14.   
  15.   
  16.     //【1】载入原始图片  
  17.     Mat srcImage1 = imread( "1.jpg", 1 );  
  18.     Mat srcImage2 = imread( "2.jpg", 1 );  
  19.     Mat copysrcImage1=srcImage1.clone();  
  20.     Mat copysrcImage2=srcImage2.clone();  
  21.   
  22.     if( !srcImage1.data || !srcImage2.data )  
  23.     { printf("读取图片错误，请确定目录下是否有imread函数指定的图片存在~！ \n"); return false; }    
  24.   
  25.     //【2】使用SURF算子检测关键点  
  26.     int minHessian = 400;//SURF算法中的hessian阈值  
  27.     SurfFeatureDetector detector( minHessian );//定义一个SurfFeatureDetector（SURF） 特征检测类对象    
  28.     vector<KeyPoint> keypoints_object, keypoints_scene;//vector模板类，存放任意类型的动态数组  
  29.   
  30.     //【3】调用detect函数检测出SURF特征关键点，保存在vector容器中  
  31.     detector.detect( srcImage1, keypoints_object );  
  32.     detector.detect( srcImage2, keypoints_scene );  
  33.   
  34.     //【4】计算描述符（特征向量）  
  35.     SurfDescriptorExtractor extractor;  
  36.     Mat descriptors_object, descriptors_scene;  
  37.     extractor.compute( srcImage1, keypoints_object, descriptors_object );  
  38.     extractor.compute( srcImage2, keypoints_scene, descriptors_scene );  
  39.   
  40.     //【5】使用FLANN匹配算子进行匹配  
  41.     FlannBasedMatcher matcher;  
  42.     vector< DMatch > matches;  
  43.     matcher.match( descriptors_object, descriptors_scene, matches );  
  44.     double max_dist = 0; double min_dist = 100;//最小距离和最大距离  
  45.   
  46.     //【6】计算出关键点之间距离的最大值和最小值  
  47.     for( int i = 0; i < descriptors_object.rows; i++ )  
  48.     {   
  49.         double dist = matches[i].distance;  
  50.         if( dist < min_dist ) min_dist = dist;  
  51.         if( dist > max_dist ) max_dist = dist;  
  52.     }  
  53.   
  54.     printf(">Max dist 最大距离 : %f \n", max_dist );  
  55.     printf(">Min dist 最小距离 : %f \n", min_dist );  
  56.   
  57.     //【7】存下匹配距离小于3*min_dist的点对  
  58.     std::vector< DMatch > good_matches;  
  59.     for( int i = 0; i < descriptors_object.rows; i++ )  
  60.     {   
  61.         if( matches[i].distance < 3*min_dist )  
  62.         {   
  63.             good_matches.push_back( matches[i]);  
  64.         }  
  65.     }  
  66.   
  67.     //绘制出匹配到的关键点  
  68.     Mat img_matches;  
  69.     drawMatches( srcImage1, keypoints_object, srcImage2, keypoints_scene,  
  70.         good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),  
  71.         vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );  
  72.   
  73.     //定义两个局部变量  
  74.     vector<Point2f> obj;  
  75.     vector<Point2f> scene;  
  76.   
  77.     //从匹配成功的匹配对中获取关键点  
  78.     for( unsigned int i = 0; i < good_matches.size(); i++ )  
  79.     {  
  80.         obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );  
  81.         scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );  
  82.     }  
  83.     vector<unsigned char> listpoints;  
  84.   
  85.     //Mat H = findHomography( obj, scene, CV_RANSAC );//计算透视变换   
  86.     Mat H = findHomography( obj, scene, CV_RANSAC,3, listpoints);//计算透视变换   
  87.   
  88.   
  89.     std::vector< DMatch > goodgood_matches;  
  90.     for (int i=0;i<listpoints.size();i++)  
  91.     {  
  92.         if ((int)listpoints[i])  
  93.         {     
  94.           
  95.             goodgood_matches.push_back(good_matches[i]);  
  96.           
  97.               
  98.             cout<<(int)listpoints[i]<<endl;  
  99.         }  
  100.           
  101.     }  
  102.     cout<<"listpoints大小："<<listpoints.size()<<endl;  
  103.     cout<<"goodgood_matches大小："<<goodgood_matches.size()<<endl;  
  104.     cout<<"good_matches大小："<<good_matches.size()<<endl;  
  105.     Mat Homgimg_matches;  
  106.     drawMatches( copysrcImage1, keypoints_object, copysrcImage2, keypoints_scene,  
  107.         goodgood_matches, Homgimg_matches, Scalar::all(-1), Scalar::all(-1),  
  108.         vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );  
  109.   
  110.     imshow("去除误匹配点后;",Homgimg_matches);  
  111.   
  112.   
  113.     //从待测图片中获取角点  
  114.     vector<Point2f> obj_corners(4);  
  115.     obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( srcImage1.cols, 0 );  
  116.     obj_corners[2] = cvPoint( srcImage1.cols, srcImage1.rows ); obj_corners[3] = cvPoint( 0, srcImage1.rows );  
  117.     vector<Point2f> scene_corners(4);  
  118.   
  119.     //进行透视变换  
  120.     perspectiveTransform( obj_corners, scene_corners, H);  
  121.   
  122.     //绘制出角点之间的直线  
  123.     line( img_matches, scene_corners[0] + Point2f( static_cast<float>(srcImage1.cols), 0), scene_corners[1] + Point2f( static_cast<float>(srcImage1.cols), 0), Scalar(255, 0, 123), 4 );  
  124.     line( img_matches, scene_corners[1] + Point2f( static_cast<float>(srcImage1.cols), 0), scene_corners[2] + Point2f( static_cast<float>(srcImage1.cols), 0), Scalar( 255, 0, 123), 4 );  
  125.     line( img_matches, scene_corners[2] + Point2f( static_cast<float>(srcImage1.cols), 0), scene_corners[3] + Point2f( static_cast<float>(srcImage1.cols), 0), Scalar( 255, 0, 123), 4 );  
  126.     line( img_matches, scene_corners[3] + Point2f( static_cast<float>(srcImage1.cols), 0), scene_corners[0] + Point2f( static_cast<float>(srcImage1.cols), 0), Scalar( 255, 0, 123), 4 );  
  127.   
  128.     //显示最终结果  
  129.     imshow( "效果图", img_matches );  
  130.   
  131.     waitKey(0);  
  132.     return 0;  
  133. }  


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/327195
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号