使用 FLANN 進行特徵匹配

目錄

• 目標
• 理論
• 程式碼
• 解釋
• 結果

上一個教程: 特徵描述
下一個教程: Features2D + 單應性查詢已知物件

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

目標

在本教程中，您將學習如何

• 使用 cv::FlannBasedMatcher 介面，透過使用 多維空間中的聚類和搜尋 模組來執行快速有效的匹配。

警告

你需要 OpenCV contrib modules 才能使用 SURF 特徵（替代方案包括 ORB、KAZE 等特徵）。

理論

經典的特徵描述符（SIFT、SURF 等）通常使用歐幾里德距離（或 L2 範數）進行比較和匹配。由於 SIFT 和 SURF 描述符表示鄰域中定向梯度的直方圖（SURF 的 Haar 小波響應），因此歐幾里德距離的替代方案是基於直方圖的度量（\( \chi^{2} \)，Earth Mover’s Distance (EMD) 等）。

Arandjelovic 等人在 [14] 中提出了擴充套件到 RootSIFT 描述符

使用平方根 (Hellinger) 核代替標準歐幾里德距離來測量 SIFT 描述符之間的相似性，可以顯著提高管道所有階段的效能。

二進位制描述符（ORB、BRISK 等）使用 漢明距離 進行匹配。此距離等效於計算二進位制字串的不同元素的數量（應用 XOR 運算後的總體計數）

\[ d_{hamming} \left ( a,b \right ) = \sum_{i=0}^{n-1} \left ( a_i \oplus b_i \right ) \]

為了過濾匹配，Lowe 在 [176] 中提出使用距離比率測試來嘗試消除錯誤匹配。計算所考慮的關鍵點的兩個最近匹配項之間的距離比率，當此值低於閾值時，它是一個好的匹配。實際上，該比率有助於區分模糊匹配（兩個最近鄰居之間的距離比率接近 1）和良好區分的匹配。下圖來自 SIFT 論文，說明了基於最近鄰距離比率測試的匹配正確的機率。

替代或附加的過濾測試是

• 交叉檢查測試（如果特徵 \( f_b \) 是 \( I_b \) 中 \( f_a \) 的最佳匹配，並且特徵 \( f_a \) 是 \( I_a \) 中 \( f_b \) 的最佳匹配，則好匹配 \( \left( f_a, f_b \right) \)）
• 幾何測試（消除不適合幾何模型的匹配，例如 RANSAC 或用於平面物件的魯棒單應性）

程式碼

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 | | Print help message. }"
    "{ 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 << "Could not open or find the image!\n" << endl;
parser.printMessage();
        return -1;
    }
 
    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
    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 );
 
    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
    // 由於 SURF 是浮點描述符，因此使用 NORM_L2
    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
std::vector< std::vector<DMatch> > knn_matches;
matcher->knnMatch( descriptors1, descriptors2, knn_matches, 2 );
 
    //-- Filter matches using the Lowe's ratio test
    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("Good Matches", img_matches );
 
cv::Mat::empty
    return 0;
}
#else
int main()
{
std::cout << "This tutorial code needs the xfeatures2d contrib module to be run." << std::endl;
    return 0;
}
#endif

Java

此教程的程式碼如下所示。你也可以從 這裡 下載

import java.util.ArrayList;
import java.util.List;
 
import org.opencv.core.Core;
import org.opencv.core.DMatch;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfDMatch;
import org.opencv.core.MatOfKeyPoint;
import org.opencv.core.Scalar;
import org.opencv.features2d.DescriptorMatcher;
import org.opencv.features2d.Features2d;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.xfeatures2d.SURF;
 
class SURFFLANNMatching {
    public void run(String[] args) {
String filename1 = args.length > 1 ? args[0] : "../data/box.png";
String 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);
        if (img1.empty() || img2.empty()) {
System.err.println("Cannot read images!");
System.exit(0);
        }
 
        //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
        double hessianThreshold = 400;
        int nOctaves = 4, nOctaveLayers = 3;
        boolean extended = false, upright = false;
SURF detector = SURF.create(hessianThreshold, nOctaves, nOctaveLayers, extended, upright);
MatOfKeyPoint keypoints1 = new MatOfKeyPoint(), keypoints2 = new MatOfKeyPoint();
Mat descriptors1 = new Mat(), descriptors2 = new Mat();
detector.detectAndCompute(img1, new Mat(), keypoints1, descriptors1);
detector.detectAndCompute(img2, new Mat(), keypoints2, descriptors2);
 
        //-- Step 2: Matching descriptor vectors with a FLANN based matcher
        // 由於 SURF 是浮點描述符，因此使用 NORM_L2
DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
List<MatOfDMatch> knnMatches = new ArrayList<>();
matcher.knnMatch(descriptors1, descriptors2, knnMatches, 2);
 
        //-- Filter matches using the Lowe's ratio test
        float ratioThresh = 0.7f;
List<DMatch> listOfGoodMatches = new ArrayList<>();
        for (int i = 0; i < knnMatches.size(); i++) {
            if (knnMatches.get(i).rows() > 1) {
DMatch[] matches = knnMatches.get(i).toArray();
                if (matches[0].distance < ratioThresh * matches[1].distance) {
listOfGoodMatches.add(matches[0]);
                }
            }
        }
MatOfDMatch goodMatches = new MatOfDMatch();
goodMatches.fromList(listOfGoodMatches);
 
        //-- 繪製匹配項
Mat imgMatches = new Mat();
Features2d.drawMatches(img1, keypoints1, img2, keypoints2, goodMatches, imgMatches, Scalar.all(-1),
                Scalar.all(-1), new MatOfByte(), Features2d.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS);
 
        //-- 顯示檢測到的匹配項
HighGui.imshow("Good Matches", imgMatches);
HighGui.waitKey(0);
 
System.exit(0);
    }
}
 
public class SURFFLANNMatchingDemo {
    public static void main(String[] args) {
        // 載入本地 OpenCV 庫
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        new SURFFLANNMatching().run(args);
    }
}

Python

此教程的程式碼如下所示。你也可以從 這裡 下載

from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
 
parser = argparse.ArgumentParser(description='Code for Feature Matching with FLANN tutorial.')
parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
parser.add_argument('--input2', help='Path to input image 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)
if img1 is None or img2 is None
print('Could not open or find the images!')
exit(0)
 
#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
minHessian = 400
detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
keypoints1, descriptors1 = detector.detectAndCompute(img1, None)
keypoints2, descriptors2 = detector.detectAndCompute(img2, None)
 
#-- Step 2: Matching descriptor vectors with a FLANN based matcher
# 由於 SURF 是浮點描述符，因此使用 NORM_L2
matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
knn_matches = matcher.knnMatch(descriptors1, descriptors2, 2)
 
#-- Filter matches using the Lowe's ratio test
ratio_thresh = 0.7
good_matches = []
for m,n in knn_matches
    if 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('Good Matches', img_matches)
 
cv.waitKey()

解釋

結果

• 這是使用距離比率測試進行 SURF 特徵匹配的結果