目标

在本教程中，您将学习如何进行以下操作

使用函数 cv::findHomography 查找匹配关键点之间的变换。
使用函数 cv::perspectiveTransform 映射点。

警告: 您需要 OpenCV contrib 模块才能使用 SURF 特征（替代方法是 ORB、KAZE、... 特征）。

理论

代码

本教程的代码显示在下面的行中。您还可以从此处下载代码。

#include <iostream>
#include "opencv2/core.hpp"
#ifdef HAVE_OPENCV_XFEATURES2D
#include "opencv2/calib3d.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.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 | Path to input image 1. }"
        "{ input2 | box_in_scene.png | Path to input image 2. }";
 
int main( int argc, char* argv[] )
{
    CommandLineParser parser( argc, argv, keys );
    Mat img_object = imread( samples::findFile( parser.get<String>("input1") ), IMREAD_GRAYSCALE );
    Mat img_scene = imread( samples::findFile( parser.get<String>("input2") ), IMREAD_GRAYSCALE );
    if ( img_object.empty() || img_scene.empty() )
    {
cout << "找不到或无法打开图像！\n" << endl;
parser.printMessage();
        return -1;
    }
 
    //-- 步骤 1：使用 SURF 检测器检测关键点，计算描述符
    int minHessian = 400;
    Ptr<SURF> detector = SURF::create( minHessian );
std::vector<KeyPoint> keypoints_object, keypoints_scene;
    Mat descriptors_object, descriptors_scene;
detector->detectAndCompute( img_object, noArray(), keypoints_object, descriptors_object );
detector->detectAndCompute( img_scene, noArray(), keypoints_scene, descriptors_scene );
 
    //-- 步骤 2：使用基于 FLANN 的匹配器匹配描述符向量
    // 由于 SURF 是浮点描述符，因此使用 NORM_L2
    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(DescriptorMatcher::FLANNBASED);
std::vector< std::vector<DMatch> > knn_matches;
matcher->knnMatch( descriptors_object, descriptors_scene, knn_matches, 2 );
 
    //-- 使用 Lowe's ratio 检验过滤匹配
    const float ratio_thresh = 0.75f;
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( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1),
Scalar::all(-1), std::vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
 
    //-- 定位物体
std::vector<Point2f> obj;
std::vector<Point2f> scene;
 
    for( size_t i = 0; i < good_matches.size(); i++ )
    {
        //-- 从良好的匹配中获取关键点
obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );
    }
 
    Mat H = findHomography( obj, scene, RANSAC );
 
    //-- 从 image_1（待“检测”的对象）获取角点
std::vector<Point2f> obj_corners(4);
obj_corners[0] = Point2f(0, 0);
obj_corners[1] = Point2f((<span class="keywordtype">float>)img_object.cols, 0 );
obj_corners[2] = Point2f((<span class="keywordtype">float>)img_object.cols, (<span class="keywordtype">float>)img_object.rows );
obj_corners[3] = Point2f( 0, (<span class="keywordtype">float>)img_object.rows );
std::vector<Point2f> scene_corners(4);
 
    perspectiveTransform( obj_corners, scene_corners, H);
 
    //-- 场景中绘制线段互为连接的角点（映射后的目标 - 图像 2 ）
    line( img_matches, scene_corners[0] + Point2f((<span class="keywordtype">float>)img_object.cols, 0),
scene_corners[1] + Point2f((<span class="keywordtype">float>)img_object.cols, 0), Scalar(0, 255, 0), 4 );
    line( img_matches, scene_corners[1] + Point2f((<span class="keywordtype">float>)img_object.cols, 0),
scene_corners[2] + Point2f((<span class="keywordtype">float>)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[2] + Point2f((<span class="keywordtype">float>)img_object.cols, 0),
scene_corners[3] + Point2f((<span class="keywordtype">float>)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
    line( img_matches, scene_corners[3] + Point2f((<span class="keywordtype">float>)img_object.cols, 0),
scene_corners[0] + Point2f((float)img_object.cols, 0), Scalar( 0, 255, 0), 4 );
 
    //-- 显示检测匹配
    imshow("好的匹配 & 对象检测", img_matches );
 
    waitKey();
    return 0;
}
#else
int main()
{
std::cout << "此教程代码需要 xfeatures2d 贡献模块才能运行。" << std::endl;
    return 0;
}
#endif

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

import java.util.ArrayList;
import java.util.List;
 
import org.opencv.calib3d.Calib3d;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.DMatch;
导入 org.opencv.core.KeyPoint;
导入 org.opencv.core.Mat;
导入 org.opencv.core.MatOfByte;
导入 org.opencv.core.MatOfDMatch;
导入 org.opencv.core.MatOfKeyPoint;
导入 org.opencv.core.MatOfPoint2f;
导入 org.opencv.core.Point;
导入 org.opencv.core.Scalar;
导入 org.opencv.features2d.DescriptorMatcher;
导入 org.opencv.features2d.Features2d;
导入 org.opencv.highgui.HighGui;
导入 org.opencv.imgcodecs.Imgcodecs;
导入 org.opencv.imgproc.Imgproc;
导入 org.opencv.xfeatures2d.SURF;
 
类 SURFFLANNMatchingHomography {
    公有 无效 run(String[] args) {
String filenameObject = args.length > 1 ? args[0] : "../data/box.png";
String filenameScene = args.length > 1 ? args[1] : "../data/box_in_scene.png";
Mat imgObject = Imgcodecs.imread(filenameObject, Imgcodecs.IMREAD_GRAYSCALE);
Mat imgScene = Imgcodecs.imread(filenameScene, Imgcodecs.IMREAD_GRAYSCALE);
        如果 (imgObject.empty() || imgScene.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 keypointsObject = 新 MatOfKeyPoint(), keypointsScene = 新 MatOfKeyPoint();
Mat descriptorsObject = 新 Mat(), descriptorsScene = 新 Mat();
detector.detectAndCompute(imgObject, 新 Mat(), keypointsObject, descriptorsObject);
detector.detectAndCompute(imgScene, 新 Mat(), keypointsScene, descriptorsScene);
 
        //-- 步骤 2：使用基于 FLANN 的匹配器匹配描述符向量
        // 由于 SURF 是浮点描述符，因此使用 NORM_L2
DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
List<MatOfDMatch> knnMatches = 新 ArrayList<>();
matcher.knnMatch(descriptorsObject, descriptorsScene, knnMatches, 2);
 
        //-- 使用 Lowe's ratio 检验过滤匹配
        浮点 ratioThresh = 0.75f;
List<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(imgObject, keypointsObject, imgScene, keypointsScene, goodMatches, imgMatches, 标量.全部(-1),
                标量.全部(-1), 新 MatOfByte(), Features2d.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS);
 
        //-- 定位物体
列表<点> obj = 新 ArrayList<>();
列表<点> scene = 新 ArrayList<>();
 
列表<关键点> listOfKeypointsObject = keypointsObject.toList();
列表<关键点> listOfKeypointsScene = keypointsScene.toList();
        对于 (整数 i = 0; i < listOfGoodMatches.size(); i++) {
            //-- 从良好的匹配中获取关键点
obj.add(listOfKeypointsObject.get(listOfGoodMatches.get(i).queryIdx).pt);
scene.add(listOfKeypointsScene.get(listOfGoodMatches.get(i).trainIdx).pt);
        }
 
MatOfPoint2f objMat = 新 MatOfPoint2f(), sceneMat = 新 MatOfPoint2f();
objMat.fromList(obj);
sceneMat.fromList(scene);
        双精度 ransacReprojThreshold = 3.0;
Mat H = Calib3d.findHomography( objMat, sceneMat, Calib3d.RANSAC, ransacReprojThreshold );
 
        //-- 从 image_1（待“检测”的对象）获取角点
Mat objCorners = 新 Mat(4, 1, CvType.CV_32FC2), sceneCorners = 新 Mat();
        浮点[] objCornersData = 新 浮点[(int) (objCorners.total() * objCorners.channels())];
objCorners.get(0, 0, objCornersData);
objCornersData[0] = 0;
objCornersData[1] = 0;
objCornersData[2] = imgObject.cols();
objCornersData[3] = 0;
objCornersData[4] = imgObject.cols();
objCornersData[5] = imgObject.rows();
objCornersData[6] = 0;
objCornersData[7] = imgObject.rows();
objCorners.put(0, 0, objCornersData);
 
Core.perspectiveTransform(objCorners, sceneCorners, H);
        浮点[] sceneCornersData = 新 浮点[(int) (sceneCorners.total() * sceneCorners.channels())];
sceneCorners.get(0, 0, sceneCornersData);
 
        //-- 场景中绘制线段互为连接的角点（映射后的目标 - 图像 2 ）
Imgproc.line(imgMatches, 新 点(sceneCornersData[0] + imgObject.cols(), sceneCornersData[1]),
                新 点(sceneCornersData[2] + imgObject.cols(), sceneCornersData[3]), 新 标量(0, 255, 0), 4);
Imgproc.line(imgMatches, 新 点(sceneCornersData[2] + imgObject.cols(), sceneCornersData[3]),
                新 点(sceneCornersData[4] + imgObject.cols(), sceneCornersData[5]), 新 标量(0, 255, 0), 4);
Imgproc.line(imgMatches, 新 点(sceneCornersData[4] + imgObject.cols(), sceneCornersData[5]),
                new Point(sceneCornersData[6] + imgObject.cols(), sceneCornersData[7]), new Scalar(0, 255, 0), 4);
Imgproc.line(imgMatches, new Point(sceneCornersData[6] + imgObject.cols(), sceneCornersData[7]),
                new Point(sceneCornersData[0] + imgObject.cols(), sceneCornersData[1]), new Scalar(0, 255, 0), 4);
 
        //-- 显示检测匹配
HighGui.imshow("Good Matches & Object detection", imgMatches);
HighGui.waitKey(0);
 
System.exit(0);
    }
}
 
public class SURFFLANNMatchingHomographyDemo {
    public static void main(String[] args) {
        // 加载本机 OpenCV 库
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        new SURFFLANNMatchingHomography().run(args);
    }
}

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

from __future__ import print_function
import cv2 as cv
import numpy as np
import 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()
 
img_object = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
img_scene = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
if img_object is None or img_scene is None
print('无法打开或找到图像！')
exit(0)
 
#-- 步骤 1：使用 SURF 检测器检测关键点，计算描述符
minHessian = 400
detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
keypoints_obj, descriptors_obj = detector.detectAndCompute(img_object, None)
keypoints_scene, descriptors_scene = detector.detectAndCompute(img_scene, None)
 
#-- 步骤 2：使用基于 FLANN 的匹配器匹配描述符向量
# 由于 SURF 是浮点描述符，因此使用 NORM_L2
matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
knn_matches = matcher.knnMatch(descriptors_obj, descriptors_scene, 2)
 
#-- 使用 Lowe 比值检验过滤匹配项
ratio_thresh = 0.75
good_matches = []
for m,n in knn_matches
    if m.distance < ratio_thresh * n.distance
good_matches.append(m)
 
#-- 绘制匹配项
img_matches = np.empty((max(img_object.shape[0], img_scene.shape[0]), img_object.shape[1]+img_scene.shape[1], 3), dtype=np.uint8)
cv.drawMatches(img_object, keypoints_obj, img_scene, keypoints_scene, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
 
#-- 定位对象
obj = np.empty((len(good_matches),2), dtype=np.float32)
scene = np.empty((len(good_matches),2), dtype=np.float32)
for i in range(len(good_matches))
    #-- 从优质匹配项获取关键点
obj[i,0] = keypoints_obj[good_matches[i].queryIdx].pt[0]
obj[i,1] = keypoints_obj[good_matches[i].queryIdx].pt[1]
scene[i,0] = keypoints_scene[good_matches[i].trainIdx].pt[0]
scene[i,1] = keypoints_scene[good_matches[i].trainIdx].pt[1]
 
H, _ = cv.findHomography(obj, scene, cv.RANSAC)
 
#-- 从 image_1（要“检测”的对象）获取角点
obj_corners = np.empty((4,1,2), dtype=np.float32)
obj_corners[0,0,0] = 0
obj_corners[0,0,1] = 0
obj_corners[1,0,0] = img_object.shape[1]
obj_corners[1,0,1] = 0
obj_corners[2,0,0] = img_object.shape[1]
obj_corners[2,0,1] = img_object.shape[0]
obj_corners[3,0,0] = 0
obj_corners[3,0,1] = img_object.shape[0]
 
scene_corners = cv.perspectiveTransform(obj_corners, H)
 
#-- 在各个角点之间（场景中映射的对象 - image_2）绘制线段
cv.line(img_matches, (int(scene_corners[0,0,0] + img_object.shape[1]), int(scene_corners[0,0,1])),\
(int(scene_corners[1,0,0] + img_object.shape[1]), int(scene_corners[1,0,1])), (0,255,0), 4)
cv.line(img_matches, (int(scene_corners[1,0,0] + img_object.shape[1]), int(scene_corners[1,0,1])),\
(int(scene_corners[2,0,0] + img_object.shape[1]), int(scene_corners[2,0,1])), (0,255,0), 4)
cv.line(img_matches, (int(scene_corners[2,0,0] + img_object.shape[1]), int(scene_corners[2,0,1])),\
(int(scene_corners[3,0,0] + img_object.shape[1]), int(scene_corners[3,0,1])), (0,255,0), 4)
cv.line(img_matches, (int(scene_corners[3,0,0] + img_object.shape[1]), int(scene_corners[3,0,1])),\
(int(scene_corners[0,0,0] + img_object.shape[1]), int(scene_corners[0,0,1])), (0,255,0), 4)
 
#-- 显示检测到的匹配项
cv.imshow('优良匹配和对象检测', img_matches)
 
cv.waitKey()

说明

结果

以下是检测到对象的结果（以绿色突出显示）。请注意，由于使用 RANSAC 方法估计单应性，因此检测到的错误匹配项不会影响单应性计算。


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

目录

目标

理论

代码

说明

结果