首页 > 其他分享 >浅谈OpenCV的多对象匹配图像的实现，以及如何匹配透明控件，不规则图像

浅谈OpenCV的多对象匹配图像的实现，以及如何匹配透明控件，不规则图像

时间：2023-06-24 17:36:47浏览次数：70  
标签：std 控件 匹配 img src 图像 const cv size

浅谈OpenCV的多对象匹配透明图像的实现，以及如何匹配半透明控件

引子

  1. OpenCV提供的templateMatch只负责将（相关性等）计算出来，并不会直接提供目标的对应坐标，一般来说我们直接遍历最高的相关度，就可以得到匹配度最高的坐标。但是这样一般只能得到一个坐标。
  2. 在实际操作中，我们可能需要匹配一个不规则的图像，把这个不规则的图像放进矩形Mat里，会出现很多不应该参与匹配的地方参与结果的计算，导致识别率下降。
  3. 有时候面对半透明控件，其后的背景完全不一样，传统的匹配方法直接歇菜了，怎么办？

解决方法

1. 解决多对象匹配的问题

通过templateMatch算法，可以得到目标与原图像中等大子图像对应归一化的相关系数，这个归一化的相关系数可以看作是对于的概率（其实不是这样），可以设定一个阈值，把大于这个阈值的坐标都筛选出来。但是这样在一个成功匹配的坐标附近也会存在许多相关性稍小的坐标也大于这个阈值，我们无法区分这些坐标对于的图像是原来的图像还是其他的图像，这样就把这个问题转化为了怎么把这些副产物给去除。有cv经验的应该很快会想到[nms算法](非极大值抑制(NMS)算法讲解|理论+代码 - 知乎 (zhihu.com))。想了解的同学可以点进去看看。下面就只提供代码实现。

2. 解决不规则图像匹配问题

OpenCV的templateMatch中提供了一个可选的参数mask，这个mask是和目标等大的一张图，可以是U8C1也可以是FP32，其中U8C1对于每个点的含义是为0则放弃匹配该点，非0就会匹配，FP32是会将这个点像素在计算相关性时赋予对于的权重。要求比较简单，只需要不匹配不规则图像中的空白部分就好了，可以在mask中把这里涂黑，要匹配的地方涂白就好了（绿幕抠像？）。

3. 解决半透明控件的匹配问题

对于半透明控件，某个坐标对应的像素值就是会随着背景变化而变化的。templateMatch这种通过计算字节上相似度的算法会因为背景变化而导致整个图像的像素发生整体性的大规模变化而受到影响。但是即便整个图像的像素发生变化，寻找目标颜色与坐标的相对关系是基本不变的（目标具有某种特征，这也就是人为什么可以对这种控件进行识别）。可以用特征匹配的方法，利用这个特性对透明控件进行匹配。

需要注意的是部分算法来自于nonfree的xfeature，使用时请注意避免纠纷，当然也需要使用者手动打开这个编译开关，相关代码Fork自OpenCV: Features2D + Homography to find a known object

最终代码实现

libmatch.h

#ifdef LIBMATCH_EXPORTS
#define LIBMATCH_API extern "C" __declspec(dllexport)
struct objectEx
{
    cv::Rect_<float> rect;
    float prob;
};

struct objectEx2
{
    cv::Point2f dots[4];
};

static void qsort_descent_inplace(std::vector<objectEx>& objects)
{
    if (objects.empty())
        return;

    std::sort(objects.begin(), objects.end(), [](const objectEx& a, const objectEx& b) {return a.prob > b.prob; });
}

static inline float intersection_area(const objectEx& a, const objectEx& b)
{
    cv::Rect_<float> inter = a.rect & b.rect;
    return inter.area();
}

static void nms_sorted_bboxes(const std::vector<objectEx>& faceobjects, std::vector<int>& picked, float nms_threshold)
{
    picked.clear();

    const int n = faceobjects.size();

    std::vector<float> areas(n);
    for (int i = 0; i < n; i++)
    {
        areas[i] = faceobjects[i].rect.area();
    }

    for (int i = 0; i < n; i++)
    {
        const objectEx& a = faceobjects[i];

        int keep = 1;
        for (int j = 0; j < (int)picked.size(); j++)
        {
            const objectEx& b = faceobjects[picked[j]];


            // intersection over union
            float inter_area = intersection_area(a, b);
            float union_area = areas[i] + areas[picked[j]] - inter_area;
            // float IoU = inter_area / union_area
            if (inter_area / union_area > nms_threshold)
                keep = 0;
        }

        if (keep)
            picked.push_back(i);
    }
}

const int version = 230622;

#else
#define LIBMATCH_API extern "C" __declspec(dllimport)
struct objectEx
{
    struct Rect{
        float x, y, width, height;
    } rect;
    float prob;
};
struct objectEx2
{
    struct
    {
        float x, y;
    }dots[4];
};

#endif

LIBMATCH_API int match_get_version();

LIBMATCH_API size_t match_scan(
    uint8_t* src_img_data,
    const size_t src_img_size,
    uint8_t* target_img_data,
    const size_t target_img_size,
    const float prob_threshold,
    const float nms_threshold,
    objectEx* RetObejectArr,
    const size_t maxRetCount,
    const uint32_t MaskColor //Just For BGR,if high 2bit isn`t zero,mask will be disabled
);

LIBMATCH_API bool match_feat(
    uint8_t* src_img_data,
    const size_t src_img_size,
    uint8_t* target_img_data,
    const size_t target_img_size,
    objectEx2 &result
);

libmatch.cpp

// libmatch.cpp : 定义 DLL 的导出函数。
//

#include "pch.h"
#include "framework.h"
#include "libmatch.h"

LIBMATCH_API int match_get_version()
{
	return version;
}

LIBMATCH_API size_t match_scan(
    uint8_t* src_img_data,
    const size_t src_img_size,
    uint8_t* target_img_data,
    const size_t target_img_size,
    const float prob_threshold,
    const float nms_threshold,
    objectEx* RetObejectArr,
    const size_t maxRetCount,
    const uint32_t MaskColor //Just For BGR,if high 2bit isn`t zero,mask will be disabled
)
{
    //Read and Process img Start

    cv::_InputArray src_img_arr(src_img_data, src_img_size);
    cv::Mat src_mat = cv::imdecode(src_img_arr, cv::IMREAD_GRAYSCALE);

    if (src_mat.empty())
    {
        std::cout << "[Match] Err Can`t Read src_img" << std::endl;
        return -1;
    }

    cv::_InputArray target_img_arr(target_img_data, target_img_size);
    cv::Mat target_mat = cv::imdecode(target_img_arr, cv::IMREAD_GRAYSCALE);

    if (target_mat.empty())
    {
        std::cout << "[Match] Err Can`t Read target_img" << std::endl;
        return -1;
    }

    if (target_mat.cols > src_mat.cols || target_mat.rows > src_mat.rows)
    {
        std::cout << "[Match]ERR Target is too large" << std::endl;
        return false;
    }

    //Read Over

    //Template Match Start
    cv::Mat result(src_mat.cols - target_mat.cols + 1, src_mat.rows - target_mat.rows + 1, CV_32FC1);

    if ((MaskColor & 0xff000000) != 0)
    {
        cv::matchTemplate(src_mat, target_mat, result, cv::TM_CCOEFF_NORMED);
    }
    else
    {
        cv::Mat temp_target_mat = cv::imdecode(target_img_arr, cv::IMREAD_COLOR);
        cv::Mat maks_mat = cv::Mat::zeros(target_mat.rows, target_mat.cols, CV_8U);
        //Replace MaskColor

        for (int i = 0; i < temp_target_mat.rows; i++)
            for (int j = 0; j < temp_target_mat.cols; j++) {
                cv::Vec3b temp_color=temp_target_mat.at<cv::Vec3b>(cv::Point(j, i));
                if (((temp_color[0] << 16) | (temp_color[1] << 8) | temp_color[2]) != MaskColor) {
//                    std::cout << ((temp_color[0] << 16) | (temp_color[1] << 8) | temp_color[2]) << std::endl;
                    maks_mat.at<uint8_t>(cv::Point(j, i)) = 255;
                }
            }
//      cv::imshow("result", maks_mat);
//      cv::waitKey();
        cv::matchTemplate(src_mat, target_mat, result, cv::TM_CCOEFF_NORMED, maks_mat);
    }
    //Template Match Over

    //BackEnd Process
    std::vector <objectEx> proposals;

    for (int i = 0; i < result.rows; ++i)
        for (int j = 0; j < result.cols; ++j)
        {
            if (result.at<float>(cv::Point(j, i)) >= prob_threshold)
            {
                objectEx buf;
                buf.prob = result.at<float>(cv::Point(j, i));
                buf.rect.x = j;
                buf.rect.y = i;
                buf.rect.height = target_mat.rows;
                buf.rect.width = target_mat.cols;
                proposals.push_back(buf);
            }
        }
    std::vector<int> picked;
    qsort_descent_inplace(proposals);
    nms_sorted_bboxes(proposals, picked, nms_threshold);

    std::vector <objectEx> objects;

    for (auto x : picked)
        objects.emplace_back(proposals[x]);
    //BackEnd Over

    memcpy(RetObejectArr, objects.data(), sizeof(objectEx) * std::min(objects.size(), maxRetCount));

    return objects.size();
}

LIBMATCH_API bool match_feat(
    uint8_t* src_img_data,
    const size_t src_img_size,
    uint8_t* target_img_data,
    const size_t target_img_size,
    objectEx2 &result
) 
{
    //Read and Process img Start

    cv::_InputArray src_img_arr(src_img_data, src_img_size);
    cv::Mat src_mat = cv::imdecode(src_img_arr, cv::IMREAD_GRAYSCALE);

    if (src_mat.empty())
    {
        std::cout << "[Match] Err Can`t Read src_img" << std::endl;
        return false;
    }

    cv::_InputArray target_img_arr(target_img_data, target_img_size);
    cv::Mat target_mat = cv::imdecode(target_img_arr, cv::IMREAD_GRAYSCALE);

    if (target_mat.empty())
    {
        std::cout << "[Match] Err Can`t Read target_img" << std::endl;
        return false;
    }

    //Read Over
    //-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
    int minHessian = 400;
    cv::Ptr<cv::xfeatures2d::SURF> detector = cv::xfeatures2d::SURF::create(minHessian);
    std::vector<cv::KeyPoint> keypoints_object, keypoints_scene;
    cv::Mat descriptors_object, descriptors_scene;
    detector->detectAndCompute(target_mat, cv::noArray(), keypoints_object, descriptors_object);
    detector->detectAndCompute(src_mat,cv::noArray(), keypoints_scene, descriptors_scene);
    //-- Step 2: Matching descriptor vectors with a FLANN based matcher
    // Since SURF is a floating-point descriptor NORM_L2 is used
    cv::Ptr<cv::DescriptorMatcher> matcher = cv::DescriptorMatcher::create(cv::DescriptorMatcher::FLANNBASED);
    std::vector< std::vector<cv::DMatch> > knn_matches;
    matcher->knnMatch(descriptors_object, descriptors_scene, knn_matches, 2);
    //-- Filter matches using the Lowe's ratio test
    const float ratio_thresh = 0.75f;
    std::vector<cv::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]);
        }
    }
    if (good_matches.size() == 0)
        return false;
    //-- Draw matches
    //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);
    //-- Localize the object
    std::vector<cv::Point2f> obj;
    std::vector<cv::Point2f> scene;
    for (size_t i = 0; i < good_matches.size(); i++)
    {
        //-- Get the keypoints from the good matches
        obj.push_back(keypoints_object[good_matches[i].queryIdx].pt);
        scene.push_back(keypoints_scene[good_matches[i].trainIdx].pt);
    }
    cv::Mat H = findHomography(obj, scene, cv::RANSAC);
    //-- Get the corners from the image_1 ( the object to be "detected" )
    std::vector<cv::Point2f> obj_corners(4);
    obj_corners[0] = cv::Point2f(0, 0);
    obj_corners[1] = cv::Point2f((float)target_mat.cols, 0);
    obj_corners[2] = cv::Point2f((float)target_mat.cols, (float)target_mat.rows);
    obj_corners[3] = cv::Point2f(0, (float)target_mat.rows);

    std::vector<cv::Point2f> buf_corners(4);
    cv::perspectiveTransform(obj_corners, buf_corners, H);
    memcpy(result.dots, buf_corners.data(), buf_corners.size() * sizeof(cv::Point2f));
    return true;
}

实现效果

多对象匹配+不规则匹配

效果演示

半透明控件匹配

效果演示

后记

紧张而刺激的高考在本月落下了帷幕，结束了长达12年的通识教育，笔者终于能够潜下心来研究这些东西背后的数学原理。由于笔者的能力有限，本文存在不严谨的部分，希望读者可以谅解。

算法交流群：904511841，143858000

标签：std,控件,匹配,img,src,图像,const,cv,size
From： https://www.cnblogs.com/Icys/p/Match.html

相关文章

  • 反向解析，有名无名分组，路由匹配
    django请求生命周期流程图(必会)#必须会画这个图是你们后期复习django最好的一个梳理方式路由匹配#路由匹配url(r'test',views.test),url(r'testadd',views.testadd)"""url方法第一个参数是正则表达式只要第一个参数正则表达式能够匹配到内容那么就会立刻停止......
  • chart控件
    Chart控件五大核心“图表属性”——它们均是“集合” 均是集合属性。其中中间的三个属性ChartAreas、Series、Legends是最为核心的三个，1、ChartAreas属性ChartAreas可以理解为是一个图表的绘图区，例如，你想在一幅图上呈现两个不同属性的内容，一个是用户流量，另一个则是......
  • StyleGAN图像风格转换相关经典论文、项目、数据集等资源整理分享
        StyleGAN是NVIDIA继ProGAN之后提出的新的生成网络，其主要通过分别修改每一层级的输入，在不影响其他层级的情况下，来控制该层级所表示的视觉特征。这些特征可以是粗的特征（如姿势、脸型等），也可以是一些细节特征（如瞳色、发色等）。StyleGAN，提出了一个新的generatorarchitecture，号......
  • 深度学习/图像处理历史最全最细-网络、技巧、迭代-论文整理分享
        本资源整理了深度学习/图像处理技术发展过程中的所有模型、优化技巧、网络结构优化、迭代过程中所有经典论文，并进行了详细的分类，按重要程度进行了仔细的划分，对于想要了解深度学习模型迭代朋友来说非常值得参考。     本资源整理自网络，源地址：https://github.com/xw-hu/......
  • 历史最全图像/视频去模糊化精选论文整理分享
        本资源整理了图像/视频图模糊化相关的经典论文、相关的数据集。涉及基于深度学习技术的单图像盲运动去模糊化，非深度学习单图像盲运动去模糊化，非盲去模糊化，多图像/视频运动去模糊化等方面，分享给需要的朋友。     资源整理自网络，源地址:https://github.com/subeeshvasu/......
  • 基于DCT变换和ZigZag的图像压缩算法matlab性能仿真,仿真输出不同压缩率与图像质量的关
    1.算法仿真效果matlab2022a仿真结果如下：2.算法涉及理论知识概要图像压缩是一种广泛应用的技术，它能够在不影响图像质量的前提下，减少图像所占用的存储空间。本文将介绍一种基于离散余弦变换（DiscreteCosineTransform，简称DCT）和ZigZag扫描的图像压缩算法，并探讨不同压缩率与图像质......
  • 基于DCT变换和ZigZag的图像压缩算法matlab性能仿真,仿真输出不同压缩率与图像质量的关
    1.算法仿真效果matlab2022a仿真结果如下： 2.算法涉及理论知识概要       图像压缩是一种广泛应用的技术，它能够在不影响图像质量的前提下，减少图像所占用的存储空间。本文将介绍一种基于离散余弦变换（DiscreteCosineTransform，简称DCT）和ZigZag扫描的图像压缩算法，并探讨......
  • ScrollView下面固定一个控件
    <?xmlversion="1.0"encoding="utf-8"?><RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"android:layout_width="fill_parent"android:layout_height="fill_parent"android:......
  • 正则表达式几个匹配例子
    匹配手机号1.由1开头的数字^12.第二位数字一般是3,4,5,7,8中的一个数字[34578]3.接下来9位都是0到9的数字\d{9}4.为了严谨，结尾加上$，表示：是以9个数字结束^1[34578]\d{9}$在字符串中匹配多个：1[34578]\d{9}QQ号匹配：^[1-9]\d{5,11}$QQ号第一位：[1-9]QQ号一般5-12位，剩下的位数......
  • 基于神经网络的大模型在图像识别中的应用
    目录1.引言2.技术原理及概念3.实现步骤与流程4.示例与应用5.优化与改进6.结论与展望随着深度学习技术的不断发展，特别是在计算机视觉领域，基于神经网络的大模型在图像识别中的应用越来越广泛。这些模型能够在处理大量图像数据的同时，准确地识别出各种物体和场景，取得了令人瞩目的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99