使用FLANN进行特征匹配

目录

• 目标
• 理论
• 代码
• 解释
• 结果

上一教程： 特征描述
下一教程： Features2D + 单应性查找已知物体

原作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中，您将学习如何：

• 使用 cv::FlannBasedMatcher 接口，通过使用 多维空间中的聚类和搜索 模块来执行快速高效的匹配

警告

您需要 OpenCV contrib 模块 才能使用 SURF 特征（替代方案是 ORB、KAZE 等特征）。

理论

经典的特征描述符（SIFT、SURF 等）通常使用欧几里得距离（或 L2 范数）进行比较和匹配。由于 SIFT 和 SURF 描述符表示邻域中定向梯度的直方图（对于 SURF 来说是 Haar 小波响应），因此欧几里得距离的替代方案是基于直方图的度量（${\chi }^2$、Earth Mover’s Distance (EMD) 等）。

Arandjelovic 等人在 [13] 中提出扩展到 RootSIFT 描述符

使用平方根（Hellinger）核代替标准欧几里得距离来测量 SIFT 描述符之间的相似性，这会导致管道所有阶段的性能大幅提升。

二进制描述符（ORB、BRISK 等）使用 汉明距离 进行匹配。此距离等效于计算二进制字符串中不同元素的数量（应用 XOR 运算后的总体计数）

$$d_{hamming}(a,b)=\sum _{i=0}^{n-1}(a_i\oplus b_i)$$

为了过滤匹配项，Lowe 在 [173] 中提出使用距离比率测试来尝试消除错误匹配。计算考虑的关键点的两个最近匹配之间的距离比率，当此值低于阈值时，它是一个良好的匹配。实际上，该比率有助于区分模糊匹配（两个最近邻之间的距离比率接近于 1）和良好区分的匹配。下图来自 SIFT 论文，它说明了基于最近邻距离比率测试的匹配正确的概率。

替代或附加的过滤测试是

• 交叉检验测试（如果特征 $f_b$ 是 $I_b$ 中 $f_a$ 的最佳匹配，而特征 $f_a$ 是 $I_a$ 中 $f_b$ 的最佳匹配，则为良好匹配 $(f_a,f_b)$）
• 几何测试（消除不符合几何模型的匹配，例如，用于平面物体的 RANSAC 或鲁棒单应性）

代码

C++JavaPython

C++

本教程代码如下所示。您也可以从 此处 下载。

#include <iostream>
#include "opencv2/core.hpp"
#ifdef HAVE_OPENCV_XFEATURES2D
#include "opencv2/highgui.hpp"
#include "opencv2/features2d.hpp"
#include "opencv2/xfeatures2d.hpp"
 
using namespace cv;
using namespace cv::xfeatures2d;
using std::cout;
using std::endl;
 
const char* keys =
    "{ help h | | 打印帮助信息。 }"
    "{ input1 | box.png | 输入图像1的路径。 }"
    "{ input2 | box_in_scene.png | 输入图像2的路径。 }";
 
int main( int argc, char* argv[] )
{
    CommandLineParser parser( argc, argv, keys );
    Mat img1 = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
    Mat img2 = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
    if ( img1.empty() || img2.empty() )
    {
cout << "无法打开或找到图像！\n" << endl;
parser.printMessage();
        return -1;
    }
 
    //-- 步骤1：使用SURF检测器检测关键点，计算描述符
    int minHessian = 400;
    Ptr<SURF> detector = SURF::create( minHessian );
std::vector<KeyPoint> keypoints1, keypoints2;
    Mat descriptors1, descriptors2;
detector->detectAndCompute( img1, noArray(), keypoints1, descriptors1 );
detector->detectAndCompute( img2, noArray(), keypoints2, descriptors2 );
 
    //-- 步骤2：使用基于FLANN的匹配器匹配描述符向量
    // 由于SURF是浮点描述符，因此使用NORM_L2
    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
std::vector< std::vector<DMatch> > knn_matches;
matcher->knnMatch( descriptors1, descriptors2, knn_matches, 2 );
 
    //-- 使用Lowe比率测试过滤匹配项
    const float ratio_thresh = 0.7f;
std::vector<DMatch> good_matches;
    for (size_t i = 0; i < knn_matches.size(); i++)
    {
        if (knn_matches[i][0].distance < ratio_thresh * knn_matches[i][1].distance)
        {
good_matches.push_back(knn_matches[i][0]);
        }
    }
 
    //-- 绘制匹配项
    Mat img_matches;
drawMatches( img1, keypoints1, img2, keypoints2, good_matches, img_matches, Scalar::all(-1),
Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
 
    //-- 显示检测到的匹配项
imshow("良好匹配", img_matches );
 
waitKey();
    return 0;
}
#else
int main()
{
std::cout << "此教程代码需要运行 xfeatures2d contrib 模块。" << std::endl;
    return 0;
}
#endif

Java

本教程代码如下所示。您也可以从 此处 下载。

import java.util.ArrayList;
import java.util.List;
 
import org.opencv.core.Core;
import org.opencv.core.DMatch;
导入 org.opencv.core.Mat;
导入 org.opencv.core.MatOfByte;
导入 org.opencv.core.MatOfDMatch;
导入 org.opencv.core.MatOfKeyPoint;
导入 org.opencv.core.Scalar;
导入 org.opencv.features2d.DescriptorMatcher;
导入 org.opencv.features2d.Features2d;
导入 org.opencv.highgui.HighGui;
导入 org.opencv.imgcodecs.Imgcodecs;
导入 org.opencv.xfeatures2d.SURF;
 
类 SURFFLANNMatching {
    公共无效运行(字符串[] args) {
字符串 filename1 = args.length > 1 ? args[0] : "../data/box.png";
字符串 filename2 = args.length > 1 ? args[1] : "../data/box_in_scene.png";
Mat img1 = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_GRAYSCALE);
Mat img2 = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_GRAYSCALE);
        如果 (img1.empty() || img2.empty()) {
System.err.println("无法读取图像！");
System.exit(0);
        }
 
        //-- 步骤1：使用SURF检测器检测关键点，计算描述符
        双精度 hessianThreshold = 400;
        整数 nOctaves = 4, nOctaveLayers = 3;
        布尔 extended = 假, upright = 假;
SURF detector = SURF.create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
MatOfKeyPoint keypoints1 = 新 MatOfKeyPoint(), keypoints2 = 新 MatOfKeyPoint();
Mat descriptors1 = 新 Mat(), descriptors2 = 新 Mat();
detector.detectAndCompute(img1, 新 Mat(), keypoints1, descriptors1);
detector.detectAndCompute(img2, 新 Mat(), keypoints2, descriptors2);
 
        //-- 步骤2：使用基于FLANN的匹配器匹配描述符向量
        // 由于SURF是浮点描述符，因此使用NORM_L2
DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
列表<MatOfDMatch> knnMatches = 新 ArrayList<>();
matcher.knnMatch(descriptors1, descriptors2, knnMatches, 2);
 
        //-- 使用Lowe比率测试过滤匹配项
        浮点数 ratioThresh = 0.7f;
列表<DMatch> listOfGoodMatches = 新 ArrayList<>();
        对于 (整数 i = 0; i < knnMatches.size(); i++) {
            如果 (knnMatches.get(i).rows() > 1) {
DMatch[] matches = knnMatches.get(i).toArray();
                如果 (matches[0].distance < ratioThresh * matches[1].distance) {
listOfGoodMatches.add(matches[0]);
                }
            }
        }
MatOfDMatch goodMatches = 新 MatOfDMatch();
goodMatches.fromList(listOfGoodMatches);
 
        //-- 绘制匹配项
Mat imgMatches = 新 Mat();
Features2d.drawMatches(img1, keypoints1, img2, keypoints2, goodMatches, imgMatches, Scalar.all(-1),
                Scalar.all(-1), 新 MatOfByte(), Features2d.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS);
 
        //-- 显示检测到的匹配项
HighGui.imshow("良好匹配", imgMatches);
HighGui.waitKey(0);
 
System.exit(0);
    }
}
 
公共类 SURFFLANNMatchingDemo {
    公共静态无效主函数(字符串[] args) {
        // 加载原生 OpenCV 库
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        新 SURFFLANNMatching().run(args);
    }
}

Python

此教程代码的代码如下所示。您也可以从这里下载

从 __future__ 导入 print_function
导入 cv2 为 cv
导入 numpy 为 np
导入 argparse
 
parser = argparse.ArgumentParser(description='使用 FLANN 进行特征匹配的代码教程。')
parser.add_argument('--input1', help='输入图像 1 的路径。', default='box.png')
parser.add_argument('--input2', help='输入图像 2 的路径。', default='box_in_scene.png')
args = parser.parse_args()
 
img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
如果 img1 为 None 或 img2 为 None
打印('无法打开或找到图像！')
退出(0)
 
#-- 步骤 1：使用 SURF 检测器检测关键点，计算描述符
minHessian = 400
detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
keypoints1, descriptors1 = detector.detectAndCompute(img1, None)
keypoints2, descriptors2 = detector.detectAndCompute(img2, None)
 
#-- 步骤 2：使用基于 FLANN 的匹配器匹配描述符向量
# 由于 SURF 是浮点描述符，因此使用 NORM_L2
matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
knn_matches = matcher.knnMatch(descriptors1, descriptors2, 2)
 
#-- 使用 Lowe's 比率测试过滤匹配项
ratio_thresh = 0.7
good_matches = []
对于 m,n in knn_matches
    如果 m.distance < ratio_thresh * n.distance
good_matches.append(m)
 
#-- 绘制匹配项
img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
cv.drawMatches(img1, keypoints1, img2, keypoints2, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
 
#-- 显示检测到的匹配项
cv.imshow('良好匹配', img_matches)
 
cv.waitKey()

说明

结果

• 以下是使用距离比率测试的SURF特征匹配结果