OpenCV__005_模板匹配（大图像中查找与给定小图像（模板）最相似区域）

 

运行环境：

vscode 1.112.0

编译环境：

Visual Studio Community 2026 Release - amd64_x86

 

 CMakelists.txt

cmake_minimum_required(VERSION 3.10.0)

project(opencvtest VERSION 0.1.0 LANGUAGES CXX)

include(CTest)
enable_testing()

find_package(OpenCV REQUIRED)

add_executable(opencvtest test04.cpp)

target_link_libraries(opencvtest ${OpenCV_LIBS})

set(CPACK_PROJECT_NAME ${PROJECT_NAME})

 

#include <opencv2/opencv.hpp>
#include <iostream>
void my_imshow(const std::string& name,cv::Mat& photo){

    cv::namedWindow(name,cv::WINDOW_NORMAL);
    cv::resizeWindow(name,600,400);
    cv::imshow(name,photo);
}
int main() {
    //  读取图像,转化为灰度图
    cv::Mat img_object = cv::imread("./photo/object.png");
    cv::Mat img_scene = cv::imread("./photo/scene.png");

    if (img_object.empty() || img_scene.empty()) {
        std::cout << "The camera cannot be opened!" << std::endl;
        return -1;
    }
        
    my_imshow("img_object",img_object);
    my_imshow("img_scene",img_scene);
    //灰度转换
    cv::Mat gray_object,gray_scene;
    cv::cvtColor(img_object,gray_object,cv::COLOR_BGR2GRAY);
    cv::cvtColor(img_scene,gray_scene,cv::COLOR_BGR2GRAY);

    my_imshow("gray_object",gray_object);
    my_imshow("gray_scene",gray_scene);

    //  ORB 特征检测 + 描述
    //Ptr是opencv提供的智能指针
    //ORB是ORB特征检测的具体类，
    //这个类里面包含了所有用于提取 FAST 角点、计算 BRIEF 描述子、构建图像金字塔的代码逻辑
    //而这些东西用于后续的检测和计算
    //opencv提供了工厂方法初始化ORB，而ORB的构造函数通常是private或protected
    //所以不允许使用new进行初始化
    //cv::ORB::create(1000)表示最多保留1000个特征点
    cv::Ptr<cv::ORB> orb = cv::ORB::create(3000);
    
    //创建存放坐标的向量变量
    std::vector<cv::KeyPoint> keypoints_obj, keypoints_scene;
    //Mat是opencv用于存储多维数组的通用容器
    cv::Mat descriptors_obj, descriptors_scene;

    // void detectAndCompute(
    // InputArray image,           // 输入图像 (通常是灰度图)
    // InputArray mask,            // 可选掩码 (指定哪些区域参与检测)
    // std::vector<KeyPoint>& keypoints, // 输出：检测到的关键点
    // OutputArray descriptors     // 输出：每个关键点对应的描述子
    // );
    //第二个参数，cv::noArray（）表示整个图像都参与检测
    //detectAndCompute是ORB内部的方法，类内部实现的函数叫做方法
    orb->detectAndCompute(gray_object, cv::noArray(), keypoints_obj, descriptors_obj);
    orb->detectAndCompute(gray_scene, cv::noArray(), keypoints_scene, descriptors_scene);

    //  OpenCV的KNN 特征匹配
    //这里是找出场景中最匹配的两个描述子，后续再跟目标物体的描述子进行比对，看哪个更匹配
    //定义使用汉明距离的暴力匹配器
    cv::BFMatcher matcher(cv::NORM_HAMMING);
    

    //存储描述子的结果，由于每个目标物体的描述子可能有2个最接近的匹配结果（这两个点来自场景图像），
    //                                                                  所以是创建二维数组
    std::vector<std::vector<cv::DMatch>> knn_matches;

    //void knnMatch(
    // InputArray  queryDescriptors,    // 查询描述子（目标物体）
    // InputArray  trainDescriptors,    // 训练描述子（场景图像）
    // std::vector<std::vector<DMatch>>& matches, // 输出：匹配结果
    // int k                            // 返回前 k 个最近邻
    // );
    matcher.knnMatch(descriptors_obj, descriptors_scene, knn_matches, 2);

    //  Lowe 比率测试（筛选匹配）
    //cv::DMatch用于存储特征点匹配结果的数据结构，它记录了两个图像中特征点之间的对应关系
    //struct DMatch {
    // // 成员变量
    // int queryIdx;   // 查询图像中特征点的索引
    // int trainIdx;   // 训练图像中特征点的索引  
    // int imgIdx;     // 训练图像的索引（用于多图像匹配）
    // float distance; // 特征点之间的距离（相似度）
    // };
    std::vector<cv::DMatch> good_matches;
    //设置阈值比
    const float ratio_thresh = 0.75f;

    for (size_t i = 0; i < knn_matches.size(); i++) {
        if (knn_matches[i].size() < 2) continue;

        const cv::DMatch& m = knn_matches[i][0];
        const cv::DMatch& n = knn_matches[i][1];
        
        //这个判断表达式的意思：如果最近邻明显优于次近邻（距离足够小），则接受该匹配
        if (m.distance < ratio_thresh * n.distance) {
            good_matches.push_back(m);
        }
    }
    std::cout << "Object keypoints: " << keypoints_obj.size() << std::endl;
    std::cout << "Scene keypoints: " << keypoints_scene.size() << std::endl;
    std::cout << "KNN matches: " << knn_matches.size() << std::endl;
    std::cout << "Good matches: " << good_matches.size() << std::endl;

    //  提取匹配点的坐标
    std::vector<cv::Point2f> obj_points;
    std::vector<cv::Point2f> scene_points;
    //good_matches[i].queryIdx，获取 匹配点的物体图像的秒速子索引，
    //keypoints_obj[good_matches[i].queryIdx]表示获取 匹配点的物体图像的秒速子索引 对应的坐标
    //keypoints_obj[].pt，pt是cv::Point2f的成员变量，存储的坐标
    for (size_t i = 0; i < good_matches.size(); i++) {
        obj_points.push_back(keypoints_obj[good_matches[i].queryIdx].pt);
        scene_points.push_back(keypoints_scene[good_matches[i].trainIdx].pt);
    }

    // 计算单应性矩阵（RANSAC）
    //单应性矩阵：是一个 3x3 的变换矩阵，描述两个平面之间的映射关系，如图：
    // ┌     ┐   ┌             ┐ ┌     ┐
    // | x'  |   | h11 h12 h13 | | x   |
    // | y'  | = | h21 h22 h23 | | y   |
    // | 1   |   | h31 h32 h33 | | 1   |
    // └     ┘   └             ┘ └     ┘

    // cv::Mat cv::findHomography(
    // InputArray srcPoints,    // （目标图像）
    // InputArray dstPoints,    // （场景图像）
    // int method = 0,          // 计算方法
    // double ransacReprojThreshold = 3,  // RANSAC 重投影误差阈值
    // OutputArray mask = noArray(),      // 输出掩码（可选）
    // const int maxIters = 2000,         // 最大迭代次数
    // const double confidence = 0.995    // 置信度
    // );
    cv::Mat H;
    if (obj_points.size() >= 4) {
        //cv::RANSAC：使用 RANSAC 算法，能有效剔除误匹配
        // 即使经过 Lowe 比率测试，匹配点中仍可能包含误匹配。RANSAC 可以：
        //     ①自动识别并剔除误匹配（外点）
        //     ②只使用正确匹配（内点）计算单应性矩阵
        H = cv::findHomography(obj_points, scene_points, cv::RANSAC);
    }

    //  绘制匹配结果
    //cv::drawMatches(img_object, keypoints_obj,    // 物体图像像及其特征点
    // img_scene, keypoints_scene,   // 场景图像及其特征点
    // good_matches,                 // 匹配点对
    // img_matches);                 // 输出图像
    //这里注意：最终输出图像是彩色的
    //这个函数自动将两个图像并排拼接成一个新图像
    cv::Mat img_matches;
    cv::drawMatches(img_object, keypoints_obj,
                img_scene, keypoints_scene,
                good_matches, img_matches);
    std::cout << "img_matches.channels() = " <<img_matches.channels() <<std::endl;
    my_imshow("img_matches",img_matches);

    //  目标定位（画框）
    if (!H.empty()) {
        std::cout << "H matrix:\n" << H << std::endl;
        std::vector<cv::Point2f> obj_corners(4);
        //获取四个顶点
        obj_corners[0] = cv::Point2f(0, 0);
        obj_corners[1] = cv::Point2f((float)img_object.cols, 0);
        obj_corners[2] = cv::Point2f((float)img_object.cols, (float)img_object.rows);
        obj_corners[3] = cv::Point2f(0, (float)img_object.rows);

        std::vector<cv::Point2f> scene_corners(4);
        //cv::perspectiveTransform，OpenCV 中用于执行透视变换的函数，
        //                      将一个点集从源平面映射到目标平面。
        //void cv::perspectiveTransform(
        // InputArray src,     // 源点集（输入）
        // OutputArray dst,    // 变换后的点集（输出）
        // InputArray m        // 3x3 透视变换矩阵
        // );
        cv::perspectiveTransform(obj_corners, scene_corners, H);
        
        //打印信息
        std::cout << "Scene image size: " << img_scene.cols << " x " << img_scene.rows << std::endl;
        std::cout << "Transformed corners (in scene coordinates):" << std::endl;
        for (int i = 0; i < 4; ++i) {
            std::cout << "  Corner " << i << ": (" 
                    << scene_corners[i].x << ", " << scene_corners[i].y << ")" << std::endl;
        }
        // 在匹配图上画框（注意偏移）
        //因为两个图像显示在一个窗口内，所以需要进行偏移计算，
        //①(float)img_object.cols，表示x方向发生改变
        //②0 表示y轴不移动
        cv::Point2f offset((float)img_object.cols, 0);
        
        //在拼接后的匹配图上绘制物体的边界框
        //cv::line(img_matches,             // 目标图像
        //  scene_corners[i] + offset,     // 线段起点
        //  scene_corners[(i + 1) % 4] + offset,  // 线段终点
        //  cv::Scalar(255, 0, 0),   // 颜色 (B, G, R) = 蓝色
        //  4);                      // 线宽4像素
        for (int i = 0; i < 4; i++) {
            cv::line(img_matches,
                 scene_corners[i] + offset,
                 scene_corners[(i + 1) % 4] + offset,
                 cv::Scalar(255, 0, 0), 4);
        }
    } else {
        std::cout << "Homography calculation failed (too few matching points)" << std::endl;
    }

    //  显示结果

    my_imshow("Good Matches & Object Detection", img_matches);

    cv::waitKey(0);
    return 0;
}