AKAZE 區域性特徵匹配

目錄

• 簡介
• Data
  • 原始碼
  • 解釋
• 結果
  • 找到的匹配

上一個教程： 平面物體檢測
下一個教程： AKAZE 和 ORB 平面跟蹤

原始作者	Fedor Morozov
相容性	OpenCV >= 3.0

介紹

在本教程中，我們將學習如何使用 AKAZE [11] 區域性特徵來檢測和匹配兩幅影像上的關鍵點。我們將在給定單應矩陣的兩幅影像上查詢關鍵點，進行匹配，並計算內點（即符合給定單應性的匹配）的數量。

你可以在這裡找到此示例的擴充套件版本： https://github.com/pablofdezalc/test_kaze_akaze_opencv

資料

我們將使用 牛津資料集中 Graffiti 序列的影像 1 和 3。

單應性由一個 3x3 矩陣給出

7.6285898e-01 -2.9922929e-01 2.2567123e+02
3.3443473e-01 1.0143901e+00 -7.6999973e+01
3.4663091e-04 -1.4364524e-05 1.0000000e+00

你可以在 opencv/samples/data/ 中找到影像 (graf1.png, graf3.png) 和單應性矩陣 (H1to3p.xml)。

原始碼

C++

• 可下載程式碼：點選 此處
• 程式碼速覽

  #include <opencv2/features2d.hpp>
  #include <opencv2/imgproc.hpp>
  #include <opencv2/highgui.hpp>
  #include <iostream>
   
  using namespace std;
  using namespace cv;
   
  const float inlier_threshold = 2.5f; // 識別內點的距離閾值，透過單應性檢查
  const float nn_match_ratio = 0.8f; // 最近鄰匹配比率
   
  int main(int argc, char* argv[])
  {
      CommandLineParser parser(argc, argv,
                               "{@img1 | graf1.png | input image 1}"
                               "{@img2 | graf3.png | input image 2}"
                               "{@homography | H1to3p.xml | homography matrix}");
      Mat img1 = imread( samples::findFile( parser.get<String>("@img1") ), IMREAD_GRAYSCALE);
      Mat img2 = imread( samples::findFile( parser.get<String>("@img2") ), IMREAD_GRAYSCALE);
   
      Mat homography;
      FileStorage fs( samples::findFile( parser.get<String>("@homography") ), FileStorage::READ);
  fs.getFirstTopLevelNode() >> homography;
   
  vector<KeyPoint> kpts1, kpts2;
      Mat desc1, desc2;
   
      Ptr<AKAZE> akaze = AKAZE::create();
  akaze->detectAndCompute(img1, noArray(), kpts1, desc1);
  akaze->detectAndCompute(img2, noArray(), kpts2, desc2);
   
      BFMatcher matcher(NORM_HAMMING);
  vector< vector<DMatch> > nn_matches;
  matcher.knnMatch(desc1, desc2, nn_matches, 2);
   
  vector<KeyPoint> matched1, matched2;
      for(size_t i = 0; i < nn_matches.size(); i++) {
          DMatch first = nn_matches[i][0];
          float dist1 = nn_matches[i][0].distance;
          float dist2 = nn_matches[i][1].distance;
   
          if(dist1 < nn_match_ratio * dist2) {
  matched1.push_back(kpts1[first.queryIdx]);
  matched2.push_back(kpts2[first.trainIdx]);
          }
      }
   
  vector<DMatch> good_matches;
  vector<KeyPoint> inliers1, inliers2;
      for(size_t i = 0; i < matched1.size(); i++) {
          Mat col = Mat::ones(3, 1, CV_64F);
  col.at<double>(0) = matched1[i].pt.x;
  col.at<double>(1) = matched1[i].pt.y;
   
  col = homography * col;
  col /= col.at<double>(2);
          double dist = sqrt( pow(col.at<double>(0) - matched2[i].pt.x, 2) +
  pow(col.at<double>(1) - matched2[i].pt.y, 2));
   
          if(dist < inlier_threshold) {
              int new_i = static_cast<int>(inliers1.size());
  inliers1.push_back(matched1[i]);
  inliers2.push_back(matched2[i]);
  good_matches.push_back(DMatch(new_i, new_i, 0));
          }
      }
   
      Mat res;
      drawMatches(img1, inliers1, img2, inliers2, good_matches, res);
      imwrite("akaze_result.png", res);
   
      double inlier_ratio = inliers1.size() / (double) matched1.size();
  cout << "A-KAZE 匹配結果" << endl;
  cout << "*******************************" << endl;
  cout << "# 關鍵點 1: \t" << kpts1.size() << endl;
  cout << "# 關鍵點 2: \t" << kpts2.size() << endl;
  cout << "# 匹配數: \t" << matched1.size() << endl;
  cout << "# 內點數: \t" << inliers1.size() << endl;
  cout << "# 內點比率: \t" << inlier_ratio << endl;
  cout << endl;
   
      imshow("result", res);
      waitKey();
   
      return 0;
  }

Java

• 可下載程式碼：點選 此處
• 程式碼速覽

  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
   
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
   
  import org.opencv.core.Core;
  import org.opencv.core.CvType;
  import org.opencv.core.DMatch;
  import org.opencv.core.KeyPoint;
  import org.opencv.core.Mat;
  import org.opencv.core.MatOfDMatch;
  import org.opencv.core.MatOfKeyPoint;
  import org.opencv.core.Scalar;
  import org.opencv.features2d.AKAZE;
  import org.opencv.features2d.DescriptorMatcher;
  import org.opencv.features2d.Features2d;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgcodecs.Imgcodecs;
  import org.w3c.dom.Document;
  import org.xml.sax.SAXException;
   
  class AKAZEMatch {
      public void run(String[] args) {
  String filename1 = args.length > 2 ? args[0] : "../data/graf1.png";
  String filename2 = args.length > 2 ? args[1] : "../data/graf3.png";
  String filename3 = args.length > 2 ? args[2] : "../data/H1to3p.xml";
  Mat img1 = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_GRAYSCALE);
  Mat img2 = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_GRAYSCALE);
          if (img1.empty() || img2.empty()) {
  System.err.println("無法讀取影像！");
  System.exit(0);
          }
   
  File file = new File(filename3);
  DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
  DocumentBuilder documentBuilder;
  Document document;
  Mat homography = new Mat(3, 3, CvType.CV_64F);
          double[] homographyData = new double[(int) (homography.total()*homography.channels())];
          try {
  documentBuilder = documentBuilderFactory.newDocumentBuilder();
  document = documentBuilder.parse(file);
  String homographyStr = document.getElementsByTagName("data").item(0).getTextContent();
  String[] splited = homographyStr.split("\\s+");
              int idx = 0;
              for (String s : splited) {
                  if (!s.isEmpty()) {
  homographyData[idx] = Double.parseDouble(s);
  idx++;
                  }
              }
  } catch (ParserConfigurationException e) {
  e.printStackTrace();
  System.exit(0);
  } catch (SAXException e) {
  e.printStackTrace();
  System.exit(0);
  } catch (IOException e) {
  e.printStackTrace();
  System.exit(0);
          }
  homography.put(0, 0, homographyData);
   
  AKAZE akaze = AKAZE.create();
  MatOfKeyPoint kpts1 = new MatOfKeyPoint(), kpts2 = new MatOfKeyPoint();
  Mat desc1 = new Mat(), desc2 = new Mat();
  akaze.detectAndCompute(img1, new Mat(), kpts1, desc1);
  akaze.detectAndCompute(img2, new Mat(), kpts2, desc2);
   
  DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
  List<MatOfDMatch> knnMatches = new ArrayList<>();
  matcher.knnMatch(desc1, desc2, knnMatches, 2);
   
          float ratioThreshold = 0.8f; // 最近鄰匹配比率
  List<KeyPoint> listOfMatched1 = new ArrayList<>();
  List<KeyPoint> listOfMatched2 = new ArrayList<>();
  List<KeyPoint> listOfKeypoints1 = kpts1.toList();
  List<KeyPoint> listOfKeypoints2 = kpts2.toList();
          for (int i = 0; i < knnMatches.size(); i++) {
  DMatch[] matches = knnMatches.get(i).toArray();
              float dist1 = matches[0].distance;
              float dist2 = matches[1].distance;
              if (dist1 < ratioThreshold * dist2) {
  listOfMatched1.add(listOfKeypoints1.get(matches[0].queryIdx));
  listOfMatched2.add(listOfKeypoints2.get(matches[0].trainIdx));
              }
          }
   
          double inlierThreshold = 2.5; // 識別內點的距離閾值，透過單應性檢查
  List<KeyPoint> listOfInliers1 = new ArrayList<>();
  List<KeyPoint> listOfInliers2 = new ArrayList<>();
  List<DMatch> listOfGoodMatches = new ArrayList<>();
          for (int i = 0; i < listOfMatched1.size(); i++) {
  Mat col = new Mat(3, 1, CvType.CV_64F);
              double[] colData = new double[(int) (col.total() * col.channels())];
  colData[0] = listOfMatched1.get(i).pt.x;
  colData[1] = listOfMatched1.get(i).pt.y;
  colData[2] = 1.0;
  col.put(0, 0, colData);
   
  Mat colRes = new Mat();
  Core.gemm(homography, col, 1.0, new Mat(), 0.0, colRes);
  colRes.get(0, 0, colData);
  Core.multiply(colRes, new Scalar(1.0 / colData[2]), col);
  col.get(0, 0, colData);
   
              double dist = Math.sqrt(Math.pow(colData[0] - listOfMatched2.get(i).pt.x, 2) +
  Math.pow(colData[1] - listOfMatched2.get(i).pt.y, 2));
   
              if (dist < inlierThreshold) {
  listOfGoodMatches.add(new DMatch(listOfInliers1.size(), listOfInliers2.size(), 0));
  listOfInliers1.add(listOfMatched1.get(i));
  listOfInliers2.add(listOfMatched2.get(i));
              }
          }
   
  Mat res = new Mat();
  MatOfKeyPoint inliers1 = new MatOfKeyPoint(listOfInliers1.toArray(new KeyPoint[listOfInliers1.size()]));
  MatOfKeyPoint inliers2 = new MatOfKeyPoint(listOfInliers2.toArray(new KeyPoint[listOfInliers2.size()]));
  MatOfDMatch goodMatches = new MatOfDMatch(listOfGoodMatches.toArray(new DMatch[listOfGoodMatches.size()]));
  Features2d.drawMatches(img1, inliers1, img2, inliers2, goodMatches, res);
  Imgcodecs.imwrite("akaze_result.png", res);
   
          double inlierRatio = listOfInliers1.size() / (double) listOfMatched1.size();
  System.out.println("A-KAZE 匹配結果");
  System.out.println("*******************************");
  System.out.println("# 關鍵點 1: \t" + listOfKeypoints1.size());
  System.out.println("# 關鍵點 2: \t" + listOfKeypoints2.size());
  System.out.println("# 匹配數: \t" + listOfMatched1.size());
  System.out.println("# 內點數: \t" + listOfInliers1.size());
  System.out.println("# 內點比率: \t" + inlierRatio);
   
  HighGui.imshow("result", res);
  HighGui.waitKey();
   
  System.exit(0);
      }
  }
   
  public class AKAZEMatchDemo {
      public static void main(String[] args) {
          // 載入本地 OpenCV 庫
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
          new AKAZEMatch().run(args);
      }
  }

Python

• 可下載程式碼：點選 此處
• 程式碼速覽

  from __future__ import print_function
  import cv2 as cv
  import numpy as np
  import argparse
  from math import sqrt
   
   
  parser = argparse.ArgumentParser(description='AKAZE 區域性特徵匹配教程程式碼。')
  parser.add_argument('--input1', help='輸入影像 1 的路徑。', default='graf1.png')
  parser.add_argument('--input2', help='輸入影像 2 的路徑。', default='graf3.png')
  parser.add_argument('--homography', help='單應性矩陣的路徑。', default='H1to3p.xml')
  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('無法開啟或找到影像！')
  exit(0)
   
  fs = cv.FileStorage(cv.samples.findFile(args.homography), cv.FILE_STORAGE_READ)
  homography = fs.getFirstTopLevelNode().mat()
   
   
   
  akaze = cv.AKAZE_create()
  kpts1, desc1 = akaze.detectAndCompute(img1, None)
  kpts2, desc2 = akaze.detectAndCompute(img2, None)
   
   
   
  matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE_HAMMING)
  nn_matches = matcher.knnMatch(desc1, desc2, 2)
   
   
   
  matched1 = []
  matched2 = []
  nn_match_ratio = 0.8 # 最近鄰匹配比率
  for m, n in nn_matches
      if m.distance < nn_match_ratio * n.distance
  matched1.append(kpts1[m.queryIdx])
  matched2.append(kpts2[m.trainIdx])
   
   
   
  inliers1 = []
  inliers2 = []
  good_matches = []
  inlier_threshold = 2.5 # 識別內點的距離閾值，透過單應性檢查
  for i, m in enumerate(matched1)
  col = np.ones((3,1), dtype=np.float64)
  col[0:2,0] = m.pt
   
  col = np.dot(homography, col)
  col /= col[2,0]
  dist = sqrt(pow(col[0,0] - matched2[i].pt[0], 2) +\
  pow(col[1,0] - matched2[i].pt[1], 2))
   
      if dist < inlier_threshold
  good_matches.append(cv.DMatch(len(inliers1), len(inliers2), 0))
  inliers1.append(matched1[i])
  inliers2.append(matched2[i])
   
   
   
  res = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
  cv.drawMatches(img1, inliers1, img2, inliers2, good_matches, res)
  cv.imwrite("akaze_result.png", res);
   
  inlier_ratio = len(inliers1) / float(len(matched1))
  print('A-KAZE 匹配結果')
  print('*******************************')
  print('# 關鍵點 1: \t', len(kpts1))
  print('# 關鍵點 2: \t', len(kpts2))
  print('# 匹配數: \t', len(matched1))
  print('# 內點數: \t', len(inliers1))
  print('# 內點比率: \t', inlier_ratio)
   
  cv.imshow('result', res);
  cv.waitKey()
   

解釋

• 載入影像和單應性矩陣

C++

    CommandLineParser parser(argc, argv,
                             "{@img1 | graf1.png | input image 1}"
                             "{@img2 | graf3.png | input image 2}"
                             "{@homography | H1to3p.xml | homography matrix}");
    Mat img1 = imread( samples::findFile( parser.get<String>("@img1") ), IMREAD_GRAYSCALE);
    Mat img2 = imread( samples::findFile( parser.get<String>("@img2") ), IMREAD_GRAYSCALE);
 
    Mat homography;
    FileStorage fs( samples::findFile( parser.get<String>("@homography") ), FileStorage::READ);
fs.getFirstTopLevelNode() >> homography;

Java

        String filename1 = args.length > 2 ? args[0] : "../data/graf1.png";
        String filename2 = args.length > 2 ? args[1] : "../data/graf3.png";
        String filename3 = args.length > 2 ? args[2] : "../data/H1to3p.xml";
Mat img1 = Imgcodecs.imread(filename1, Imgcodecs.IMREAD_GRAYSCALE);
Mat img2 = Imgcodecs.imread(filename2, Imgcodecs.IMREAD_GRAYSCALE);
        if (img1.empty() || img2.empty()) {
System.err.println("無法讀取影像！");
System.exit(0);
        }
 
File file = new File(filename3);
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder documentBuilder;
Document document;
Mat homography = new Mat(3, 3, CvType.CV_64F);
        double[] homographyData = new double[(int) (homography.total()*homography.channels())];
        try {
documentBuilder = documentBuilderFactory.newDocumentBuilder();
document = documentBuilder.parse(file);
            String homographyStr = document.getElementsByTagName("data").item(0).getTextContent();
            String[] splited = homographyStr.split("\\s+");
            int idx = 0;
            for (String s : splited) {
                if (!s.isEmpty()) {
homographyData[idx] = Double.parseDouble(s);
idx++;
                }
            }
} catch (ParserConfigurationException e) {
e.printStackTrace();
System.exit(0);
} catch (SAXException e) {
e.printStackTrace();
System.exit(0);
} catch (IOException e) {
e.printStackTrace();
System.exit(0);
        }
homography.put(0, 0, homographyData);

Python

parser = argparse.ArgumentParser(description='AKAZE 區域性特徵匹配教程程式碼。')
parser.add_argument('--input1', help='輸入影像 1 的路徑。', default='graf1.png')
parser.add_argument('--input2', help='輸入影像 2 的路徑。', default='graf3.png')
parser.add_argument('--homography', help='單應性矩陣的路徑。', default='H1to3p.xml')
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('無法開啟或找到影像！')
exit(0)
 
fs = cv.FileStorage(cv.samples.findFile(args.homography), cv.FILE_STORAGE_READ)
homography = fs.getFirstTopLevelNode().mat()

我們在這裡載入灰度影像。單應性矩陣儲存在用 FileStorage 建立的 xml 檔案中。

• 使用 AKAZE 檢測關鍵點並計算描述符

C++

vector<KeyPoint> kpts1, kpts2;
    Mat desc1, desc2;
 
    Ptr<AKAZE> akaze = AKAZE::create();
akaze->detectAndCompute(img1, noArray(), kpts1, desc1);
akaze->detectAndCompute(img2, noArray(), kpts2, desc2);

Java

AKAZE akaze = AKAZE.create();
MatOfKeyPoint kpts1 = new MatOfKeyPoint(), kpts2 = new MatOfKeyPoint();
Mat desc1 = new Mat(), desc2 = new Mat();
akaze.detectAndCompute(img1, new Mat(), kpts1, desc1);
akaze.detectAndCompute(img2, new Mat(), kpts2, desc2);

Python

akaze = cv.AKAZE_create()
kpts1, desc1 = akaze.detectAndCompute(img1, None)
kpts2, desc2 = akaze.detectAndCompute(img2, None)

我們建立 AKAZE 並檢測和計算 AKAZE 關鍵點和描述符。由於我們不需要 mask 引數，因此使用了 noArray()。

• 使用暴力匹配器查詢 2-nn 匹配

C++

    BFMatcher matcher(NORM_HAMMING);
vector< vector<DMatch> > nn_matches;
matcher.knnMatch(desc1, desc2, nn_matches, 2);

Java

DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
List<MatOfDMatch> knnMatches = new ArrayList<>();
matcher.knnMatch(desc1, desc2, knnMatches, 2);

Python

matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE_HAMMING)
nn_matches = matcher.knnMatch(desc1, desc2, 2)

我們使用漢明距離，因為 AKAZE 預設使用二進位制描述符。

• 使用 2-nn 匹配和比率準則查詢正確的關鍵點匹配
  C++

  vector<KeyPoint> matched1, matched2;
      for(size_t i = 0; i < nn_matches.size(); i++) {
          DMatch first = nn_matches[i][0];
          float dist1 = nn_matches[i][0].distance;
          float dist2 = nn_matches[i][1].distance;
   
          if(dist1 < nn_match_ratio * dist2) {
  matched1.push_back(kpts1[first.queryIdx]);
  matched2.push_back(kpts2[first.trainIdx]);
          }
      }

Java

        float ratioThreshold = 0.8f; // 最近鄰匹配比率
List<KeyPoint> listOfMatched1 = new ArrayList<>();
List<KeyPoint> listOfMatched2 = new ArrayList<>();
List<KeyPoint> listOfKeypoints1 = kpts1.toList();
List<KeyPoint> listOfKeypoints2 = kpts2.toList();
        for (int i = 0; i < knnMatches.size(); i++) {
DMatch[] matches = knnMatches.get(i).toArray();
            float dist1 = matches[0].distance;
            float dist2 = matches[1].distance;
            if (dist1 < ratioThreshold * dist2) {
listOfMatched1.add(listOfKeypoints1.get(matches[0].queryIdx));
listOfMatched2.add(listOfKeypoints2.get(matches[0].trainIdx));
            }
        }

Python

matched1 = []
matched2 = []
nn_match_ratio = 0.8 # 最近鄰匹配比率
for m, n in nn_matches
    if m.distance < nn_match_ratio * n.distance
matched1.append(kpts1[m.queryIdx])
matched2.append(kpts2[m.trainIdx])

如果最近的匹配距離顯著低於次近的匹配距離，則該匹配是正確的（匹配不含糊）。

• 檢查我們的匹配是否符合單應性模型

C++

vector<DMatch> good_matches;
vector<KeyPoint> inliers1, inliers2;
    for(size_t i = 0; i < matched1.size(); i++) {
        Mat col = Mat::ones(3, 1, CV_64F);
col.at<double>(0) = matched1[i].pt.x;
col.at<double>(1) = matched1[i].pt.y;
 
col = homography * col;
col /= col.at<double>(2);
        double dist = sqrt( pow(col.at<double>(0) - matched2[i].pt.x, 2) +
pow(col.at<double>(1) - matched2[i].pt.y, 2));
 
        if(dist < inlier_threshold) {
            int new_i = static_cast<int>(inliers1.size());
inliers1.push_back(matched1[i]);
inliers2.push_back(matched2[i]);
good_matches.push_back(DMatch(new_i, new_i, 0));
        }
    }

Java

        double inlierThreshold = 2.5; // 識別內點的距離閾值，透過單應性檢查
List<KeyPoint> listOfInliers1 = new ArrayList<>();
List<KeyPoint> listOfInliers2 = new ArrayList<>();
List<DMatch> listOfGoodMatches = new ArrayList<>();
        for (int i = 0; i < listOfMatched1.size(); i++) {
Mat col = new Mat(3, 1, CvType.CV_64F);
            double[] colData = new double[(int) (col.total() * col.channels())];
colData[0] = listOfMatched1.get(i).pt.x;
colData[1] = listOfMatched1.get(i).pt.y;
colData[2] = 1.0;
col.put(0, 0, colData);
 
Mat colRes = new Mat();
Core.gemm(homography, col, 1.0, new Mat(), 0.0, colRes);
colRes.get(0, 0, colData);
Core.multiply(colRes, new Scalar(1.0 / colData[2]), col);
col.get(0, 0, colData);
 
            double dist = Math.sqrt(Math.pow(colData[0] - listOfMatched2.get(i).pt.x, 2) +
Math.pow(colData[1] - listOfMatched2.get(i).pt.y, 2));
 
            if (dist < inlierThreshold) {
listOfGoodMatches.add(new DMatch(listOfInliers1.size(), listOfInliers2.size(), 0));
listOfInliers1.add(listOfMatched1.get(i));
listOfInliers2.add(listOfMatched2.get(i));
            }
        }

Python

inliers1 = []
inliers2 = []
good_matches = []
inlier_threshold = 2.5 # 識別內點的距離閾值，透過單應性檢查
for i, m in enumerate(matched1)
col = np.ones((3,1), dtype=np.float64)
col[0:2,0] = m.pt
 
col = np.dot(homography, col)
col /= col[2,0]
dist = sqrt(pow(col[0,0] - matched2[i].pt[0], 2) +\
pow(col[1,0] - matched2[i].pt[1], 2))
 
    if dist < inlier_threshold
good_matches.append(cv.DMatch(len(inliers1), len(inliers2), 0))
inliers1.append(matched1[i])
inliers2.append(matched2[i])

如果第一個關鍵點的投影到第二個關鍵點的距離小於閾值，則它符合單應性模型。

我們為內點建立了一組新的匹配，因為繪圖函式需要它。

• 輸出結果

C++

    Mat res;
    drawMatches(img1, inliers1, img2, inliers2, good_matches, res);
    imwrite("akaze_result.png", res);
 
    double inlier_ratio = inliers1.size() / (double) matched1.size();
cout << "A-KAZE 匹配結果" << endl;
cout << "*******************************" << endl;
cout << "# 關鍵點 1: \t" << kpts1.size() << endl;
cout << "# 關鍵點 2: \t" << kpts2.size() << endl;
cout << "# 匹配數: \t" << matched1.size() << endl;
cout << "# 內點數: \t" << inliers1.size() << endl;
cout << "# 內點比率: \t" << inlier_ratio << endl;
cout << endl;
 
    imshow("result", res);
    waitKey();

Java

Mat res = new Mat();
MatOfKeyPoint inliers1 = new MatOfKeyPoint(listOfInliers1.toArray(new KeyPoint[listOfInliers1.size()]));
MatOfKeyPoint inliers2 = new MatOfKeyPoint(listOfInliers2.toArray(new KeyPoint[listOfInliers2.size()]));
MatOfDMatch goodMatches = new MatOfDMatch(listOfGoodMatches.toArray(new DMatch[listOfGoodMatches.size()]));
Features2d.drawMatches(img1, inliers1, img2, inliers2, goodMatches, res);
Imgcodecs.imwrite("akaze_result.png", res);
 
        double inlierRatio = listOfInliers1.size() / (double) listOfMatched1.size();
System.out.println("A-KAZE 匹配結果");
System.out.println("*******************************");
System.out.println("# 關鍵點 1: \t" + listOfKeypoints1.size());
System.out.println("# 關鍵點 2: \t" + listOfKeypoints2.size());
System.out.println("# 匹配數: \t" + listOfMatched1.size());
System.out.println("# 內點數: \t" + listOfInliers1.size());
System.out.println("# 內點比率: \t" + inlierRatio);
 
HighGui.imshow("result", res);
HighGui.waitKey();

Python

res = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
cv.drawMatches(img1, inliers1, img2, inliers2, good_matches, res)
cv.imwrite("akaze_result.png", res);
 
inlier_ratio = len(inliers1) / float(len(matched1))
print('A-KAZE 匹配結果')
print('*******************************')
print('# 關鍵點 1: \t', len(kpts1))
print('# 關鍵點 2: \t', len(kpts2))
print('# 匹配數: \t', len(matched1))
print('# 內點數: \t', len(inliers1))
print('# 內點比率: \t', inlier_ratio)
 
cv.imshow('result', res);
cv.waitKey()

在這裡，我們儲存結果影像並列印一些統計資料。

結果

找到的匹配

根據你的 OpenCV 版本，你應該獲得與以下結果一致的結果

關鍵點 1: 2943
關鍵點 2: 3511
匹配數: 447
內點數: 308
內點比率: 0.689038