• 图像处理模板匹配

    2019-06-02 17:07:23
    模板匹配是一种用于在源图像S中寻找定位给定目标图像T(即模板图像)的技术。其原理很简单,就是通过一些相似度准则来衡量两个图像块之间的相似度Similarity(S,T)。 模板匹配的工作方式 模板匹配的工作方式跟...

    模板匹配法

           模板匹配是一种用于在源图像S中寻找定位给定目标图像T(即模板图像)的技术。其原理很简单,就是通过一些相似度准则来衡量两个图像块之间的相似度Similarity(S,T)。

    模板匹配的工作方式

           模板匹配的工作方式跟直方图的反向投影基本一样,大致过程是这样的:通过在输入图像上滑动图像块对实际的图像块和输入图像进行匹配。假设我们有一张100x100的输入图像,有一张10x10的模板图像,查找的过程是这样的:

     (1)从输入图像的左上角(0,0)开始,切割一块(0,0)至(10,10)的临时图像;

     (2)用临时图像和模板图像进行对比,对比结果记为c;

     (3)对比结果c,就是结果图像(0,0)处的像素值;

     (4)切割输入图像从(0,1)至(10,11)的临时图像,对比,并记录到结果图像;

     (5)重复(1)~(4)步直到输入图像的右下角。

    模板匹配方法的优缺点:

           优点:简单、直接

           缺点:不具有旋转不变性、不具有尺度不变性

    	代码如下:  
    	int main()  
    	{  
    	    Mat img, templ, result;  
    	    img = imread("match_dst.jpg");  
    	    templ = imread("match_src.jpg");  
    	    /*img = imread("1.jpg"); 
    	    templ = imread("2.jpg");*/  
    	
            int result_cols = img.cols - templ.cols + 1;  
    	    int result_rows = img.rows - templ.rows + 1;  
    	    result.create(result_cols, result_rows, CV_32FC1);  
    	  
    	    //进行匹配和标准化  
    	    matchTemplate(img, templ, result, CV_TM_SQDIFF_NORMED);  
    	    normalize(result, result, 0, 1, NORM_MINMAX, -1, Mat());  
    	  
    	    double minVal;  //匹配最小值  
    	    double maxVal;  //匹配最大值  
    	    Point maxLoc;  //匹配最大值的位置坐标  
            Point minLoc;   //匹配最小值的位置坐标  
    	    Point matchLoc;    
    	  
    	    //通过函数minMaxLoc定位最匹配的位置  
    	    minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc, Mat());  
    	  
    	    cout << "匹配度:" << minVal << endl;  
    	    cout << "匹配度最小值的坐标" << minLoc.x << "," << minLoc.y << endl;  
    	  
    	    /*Mat H = findHomography(templ,img, CV_RANSAC); 
    	 
    	    Mat trans1; 
    	    perspectiveTransform(img, trans1, H); 
    	    imshow("trans1", trans1);*/  
    	  
    	    matchLoc = minLoc;  
    	    rectangle(img, matchLoc, Point(matchLoc.x + templ.cols, matchLoc.y + templ.rows), Scalar(0, 255, 0), 2, 8, 0);  
    	  
    	    imshow("img", img);  
    	    imshow("templ", templ);  
    	    //imshow("result", result);  
    
    	    waitKey(0);  	  
    	    return 0;  
    	}  
    

    效果如下:

           但是,在该方法中,最佳匹配点位于大图匹配位置的左上部分,且只能用矩形框选匹配位置。若小图视角变化,框选无效。

    Surf之图像匹配

           利用Surf算法进行图像匹配其一般流程为:检测物体特征点->计算特征点描述子->使用BurteForceMatcher或FLANN进行特征点匹配->匹配到的特征点进行透视变换findHomography()->透视矩阵变换perspectiveTransform()->绘制匹配物体轮廓。

    #include<opencv2\core\core.hpp>
    #include<opencv2\highgui\highgui.hpp>
    #include<opencv2\nonfree\features2d.hpp>
    #include <opencv2\imgproc\imgproc.hpp>
    #include<opencv2\calib3d\calib3d.hpp>
    #include<iostream>
    #include<stdio.h>
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
    	Mat image_object = imread("template.png", IMREAD_GRAYSCALE);
    	Mat image_scene = imread("image.png", IMREAD_GRAYSCALE);
    	
    	//检测特征点
    	const int minHessian = 400;
    	SurfFeatureDetector detector(minHessian);
    	vector<KeyPoint>keypoints_object, keypoints_scene;
    	detector.detect(image_object, keypoints_object);
    	detector.detect(image_scene, keypoints_scene);
    
    	//计算特征点描述子
    	SurfDescriptorExtractor extractor;
    	Mat descriptors_object, descriptors_scene;
    	extractor.compute(image_object, keypoints_object, descriptors_object);
    	extractor.compute(image_scene, keypoints_scene, descriptors_scene);
    
    	//使用FLANN进行特征点匹配
    	FlannBasedMatcher matcher;
    	vector<DMatch>matches;
    	matcher.match(descriptors_object, descriptors_scene, matches);
    
    	//计算匹配点之间的最大和最小距离
    	double max_dist = 0;
    	double min_dist = 100;
    	for (int i = 0; i < descriptors_object.rows; i++)
    	{
    		double dist = matches[i].distance;
    		if (dist < min_dist)
    		{
    			min_dist = dist;
    		}
    		else if (dist > max_dist)
    		{
    			max_dist = dist;
    		}
    	}
    	printf("Max dist: %f \n", max_dist);
    	printf("Min dist: %f \n", min_dist);
       //绘制好的匹配点
    	vector<DMatch>good_matches;
    	for (int i = 0; i < descriptors_object.rows; i++)
    	{
    		if (matches[i].distance<2 * min_dist)
    		{
    			good_matches.push_back(matches[i]);
    		}
    	}
    	Mat image_matches;
    	drawMatches(image_object, keypoints_object, image_scene, keypoints_scene, good_matches, image_matches,
    		Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    
    	//定位好的匹配点
    	vector<Point2f> obj;
    	vector<Point2f> scene;
    	for (int i = 0; i < good_matches.size(); i++)
    	{
    		//DMathch类型中queryIdx是指match中第一个数组的索引,keyPoint类型中pt指的是当前点坐标
    		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, CV_RANSAC);
    
    	vector<Point2f> obj_corners(4), scene_corners(4);
    	obj_corners[0] = cvPoint(0, 0);
    	obj_corners[1] = cvPoint(image_object.cols, 0);
    	obj_corners[2] = cvPoint(image_object.cols, image_object.rows);
    	obj_corners[3] = cvPoint(0, image_object.rows);
    
    	perspectiveTransform(obj_corners, scene_corners, H);
    
    	//绘制角点之间的直线
    	line(image_matches, scene_corners[0] + Point2f(image_object.cols, 0),
    		scene_corners[1] + Point2f(image_object.cols, 0), Scalar(0, 0, 255), 2);
    	line(image_matches, scene_corners[1] + Point2f(image_object.cols, 0),
    		scene_corners[2] + Point2f(image_object.cols, 0), Scalar(0, 0, 255), 2);
    	line(image_matches, scene_corners[2] + Point2f(image_object.cols, 0),
    		scene_corners[3] + Point2f(image_object.cols, 0), Scalar(0, 0, 255), 2);
    	line(image_matches, scene_corners[3] + Point2f(image_object.cols, 0),
    		scene_corners[0] + Point2f(image_object.cols, 0), Scalar(0, 0, 255), 2);
    
    	//输出图像
    	namedWindow("匹配图像", WINDOW_AUTOSIZE);
    	imshow("匹配图像", image_matches);
    	waitKey(0);
    
    	return 0;
    
    }

    程序说明:

           在定位匹配点中用到了DMatchqueryIdxtrainIdx成员变量和keyPoint的成员变量pt

    cv::DMatch::DMatch(int  queryIdx,  //在对描述子匹配时,第一组特征点的索引  
    int  trainIdx,  //在对描述子匹配时,第二组特征点的索引  
    int  imgIdx,    //多个图像中图像的索引  
    float   distance  //两个特征向量间的欧氏距离,越小表明匹配度越高 )  
    

           对于DrawMatch函数:

    void drawMatches( const Mat& img1, const vector<KeyPoint>& keypoints1,  
    	              const Mat& img2, const vector<KeyPoint>& keypoints2,  
    	              const vector<vector<DMatch> >& matches1to2, Mat& outImg,  
    	              const Scalar& matchColor=Scalar::all -1), 
    	              const Scalar& singlePointColor=Scalar::all(-1),  
    	              const vector<vector<char> >& matchesMask=vector<vector<char> >(), 
                      int flags=DrawMatchesFlags::DEFAULT );  
    
    /其中参数如下:  
    img1 – 源图像1  
    keypoints1 –源图像1的特征点.  
    img2 – 源图像2.  
    keypoints2 – 源图像2的特征点  
    matches1to2 – 源图像1的特征点匹配源图像2的特征点[matches[i]] .  
    outImg – 输出图像具体由flags决定.  
    matchColor – 匹配的颜色(特征点和连线),若matchColor==Scalar::all(-1),颜色随机.  
    singlePointColor – 单个点的颜色,即未配对的特征点,若matchColor==Scalar::all(-1),颜色随机.  
    matchesMask – Mask决定哪些点将被画出,若为空,则画出所有匹配点.  
    * flags – Fdefined by DrawMatchesFlags.  
    

    效果图:

     

    FAsT-Match

            FAsT-Match是在2D仿射变换下用于近似模板匹配的快速算法,其最小化绝对差分和(SAD)误差测量。 通过图像平滑度的密度对其进行采样。 对于每个可能的变换,使用次线性算法来近似SAD误差, 同时使用分支定界法进一步加速算法。 由于已知图像是分段平滑的,因此结果是具有近似保证的实际仿射模板匹配算法。

    算法流程:                                                                                                      

    代码地址

    结果如下:

     

    展开全文
  • 图像处理--模板匹配

    2018-10-31 09:57:54
    模板匹配   首先模板不是用来 ...  用ORB特征匹配,怎么确定匹配到的就是我的模板图像啊 ?   匹配后的区域进行相减或者算相似度。两图相减,注意两图的大小要一样,可现在大小就是不一样,所以我才用的ORB...

    模板匹配

      首先模板不是用来 精确定位的,只能用来粗定位。先粗定位,然后在你的当前图中扣取 和模板一样大小的区域,然后再进行精确定位。

    问题1

      对于有缩放和旋转的目标你们是怎么定位的呢?
      轮廓;匹配;模板匹配

    问题2

      用ORB特征匹配,怎么确定匹配到的就是我的模板图像啊 ?
      匹配后的区域进行相减或者算相似度。两图相减,注意两图的大小要一样,可现在大小就是不一样,所以我才用的ORB。

    展开全文
  • 图像处理 模板匹配算法分析和改进算法分析
  • 图像处理 模板匹配

    2019-07-18 01:30:44
    演示用局部图片匹配整张图片 VS2017 + OpenCV4.0.1编译 1 #include <iostream> 2 #include <opencv2/opencv.hpp> 3 #include <opencv2/core.hpp> 4 #include <opencv2/highgui.hpp&...

    演示用局部图片匹配整张图片

    VS2017 + OpenCV4.0.1编译

     1 #include <iostream>
     2 #include <opencv2/opencv.hpp>
     3 #include <opencv2/core.hpp>
     4 #include <opencv2/highgui.hpp>
     5 #include <opencv2/imgproc.hpp>
     6 using namespace std;
     7 using namespace cv;
     8 
     9 //定义全局变量
    10 Mat src, temp, res;
    11 
    12 //显示窗口名
    13 string img_window = "source image";
    14 string res_window = "result image";
    15 
    16 int match_method;
    17 int max_tracker = 5;
    18 
    19 //滑动条回调函数
    20 void match(int pos, void*)
    21 {
    22     Mat subImg;
    23     src.copyTo(subImg);//拷贝副本
    24     int res_row = src.rows - temp.rows + 1;
    25     int res_col = src.cols - temp.cols + 1;
    26     res.create(res_row, res_col, CV_32FC1);//创建结果矩阵
    27 
    28     //模板匹配
    29     matchTemplate(subImg, temp, res, match_method);
    30     normalize(res, res, 0, 1, NORM_MINMAX, -1, Mat());
    31 
    32     //定位
    33     double minVal, maxVal;
    34     Point minLoc, maxLoc, matchLoc;
    35     minMaxLoc(res, &minVal, &maxVal, &minLoc, &maxLoc, Mat());
    36 
    37     //分类讨论
    38     if (match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED)
    39         matchLoc = minLoc;
    40     else
    41         matchLoc = maxLoc;
    42 
    43     //矩形框显示匹配结果
    44     rectangle(subImg, matchLoc, Point(matchLoc.x + temp.cols, matchLoc.y + temp.rows), Scalar(0, 255, 0), 2);
    45     rectangle(res, matchLoc, Point(matchLoc.x + temp.cols, matchLoc.y + temp.rows), Scalar(0, 255, 0), 2);
    46     
    47     imshow(img_window, subImg);
    48     imshow(res_window, res);
    49 }
    50 
    51 int main()
    52 {
    53     //读入原图和模板图
    54     src = imread("D:\\trashBox\\testIMG\\memory.jpg");
    55     temp = imread("D:\\trashBox\\testIMG\\temp.png");
    56     imshow("模板", temp);
    57     
    58     //创建显示窗口
    59     namedWindow(img_window);
    60     namedWindow(res_window);
    61 
    62     //创建滑动条
    63     match(2, 0);
    64     createTrackbar("匹配方法", img_window, &match_method, max_tracker, match);
    65     
    66     waitKey(0);
    67     return 0;
    68 }

    参考资料

    【1】http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/imgproc/histograms/template_matching/template_matching.html#template-matching

    展开全文
  • 基于相关的模板匹配技术可直接用于在一幅图像中,寻找某种子图像模式。对于大小为MxN的图像f(x,y)和大小为JxK的子图像模式w(x,y),f与w的相关可表示为:其种,x=0,1,2,…N-K,y=0,1,2,…M-J。此处 的目的是寻找匹配而...

    一、理论基础

    • 基于相关的模板匹配技术可直接用于在一幅图像中,寻找某种子图像模式。对于大小为MxN的图像f(x,y)和大小为JxK的子图像模式w(x,y),f与w的相关可表示为:

    这里写图片描述

    • 其种,x=0,1,2,…N-K,y=0,1,2,…M-J。此处
      的目的是寻找匹配而不是对f(x,y)进行滤波操作,因此w的原点被设置在子图像的左上角,
      并且式(11-3) 给出的形式也完全适用于J和K 为偶数的情况。

    • 计算相关c(x,y)的过程就是在图像f(x,y)中逐点地移动子图像w(x,小),使w 的原点和点
      (x,y)重合,然后计算w与f中被w覆盖的图像区域对应像素的乘积之和,以此计算结果作
      为相关图像c(x,)在(x,y)点的响应。

    • 相关可用于在图像f(x,y)中找到与子图像w(x,y)匹配的所有位置。实际上,当w 按照上
      段中描述的过程移过整幅图像f之后,最大的响应点(xo,yo)即为最佳匹配的左上角点。我们
      也可以设定一个阈值T,认为响应值大于该阈值的点均是可能的匹配位置。

    • 相关的计算是通过将图像元素和子模式图像元素联系起来获得的,将相关元素相乘后累
      加。我们完全可以将子图像w视为一个按行或按列存储的向量这里写图片描述,将计算过程中被w覆盖的图像区域视为另一个按照同样的方式存储的向量这里写图片描述.这样一来,相关计算就- 成了向量之间的点积运算。

    两个向量的点积为:
    这里写图片描述

    • 其中,Θ 为向量这里写图片描述这里写图片描述之间的夹角。显然,当这里写图片描述这里写图片描述具有完全相同的方向(平行) 时,这里写图片描述,从而式(11-4) 取得其最大值这里写图片描述,这就意味着当图像的局部区域类似于子图像模式时,相关运算产生最大的响应。然而,式(11-4) 最终的取值还与向量这里写图片描述这里写图片描述自身的模有关,这将导致按照式(11-4) 计算的相关响应存在着对f和w 的灰度幅值比较敏感的缺陷。这样一来,在f的高灰度区域,可能尽管其内容与子图像w的内容并不相近,但由于这里写图片描述自身较大而同样产生一个很高的响应。可通过对向量以其模值来归一化解决这一问题,即通过来计算。
      这里写图片描述

    改进的用于匹配的相关计算公式如下:
    这里写图片描述

    二、代码部分

    • 看了脑疼的理论,下面看看让人愉快的代码吧。

    TemplateMatch.h

    #pragma once
    #include<opencv2\opencv.hpp>
    using namespace cv;
    typedef unsigned char BYTE;
    void TemplateMatch(Mat * pTo, Mat * pTemplate,Mat * src);
    

    TemplateMatch.cpp

     #include"TemplateMatch.h"
    
    void TemplateMatch(Mat * pTo, Mat * pTemplate, Mat * src)
    {
    
        //循环变量
        int i, j, m, n;
    
        double dSumT; //模板元素的平方和
        double dSumS; //图像子区域元素的平方和
        double dSumST; //图像子区域和模板的点积    
    
                       //响应值
        double R;
    
        //记录当前的最大响应
        double MaxR;
    
        //最大响应出现位置
        int nMaxX;
        int nMaxY;
    
        int nHeight = src->rows;
        int nWidth = src->cols;
        //模板的高、宽
        int nTplHeight = pTemplate->rows;
        int nTplWidth = pTemplate->cols;
    
        //计算 dSumT
        dSumT = 0;
        for (m = 0; m < nTplHeight; m++)
        {
            for (n = 0; n < nTplWidth; n++)
            {
                // 模板图像第m行,第n个象素的灰度值
                int nGray =*pTemplate->ptr(m, n);
    
                dSumT += (double)nGray*nGray;
            }
        }
    
        //找到图像中最大响应的出现位置
        MaxR = 0;
        for (i = 0; i < nHeight - nTplHeight + 1; i++)
        {
            for (j = 0; j < nWidth - nTplWidth + 1; j++)
            {
                dSumST = 0;
                dSumS = 0;
    
                for (m = 0; m < nTplHeight; m++)
                {
                    for (n = 0; n < nTplWidth; n++)
                    {
                        // 原图像第i+m行,第j+n列象素的灰度值
                        int nGraySrc = *src->ptr(i + m, j + n);
    
                        // 模板图像第m行,第n个象素的灰度值
                        int nGrayTpl = *pTemplate->ptr(m, n);
    
                        dSumS += (double)nGraySrc*nGraySrc;
                        dSumST += (double)nGraySrc*nGrayTpl;
                    }
                }
    
                R = dSumST / (sqrt(dSumS)*sqrt(dSumT));//计算相关响应
    
                //与最大相似性比较
                if (R > MaxR)
                {
                    MaxR = R;
                    nMaxX = j;
                    nMaxY = i;
                }
            }
        }
    
        //将找到的最佳匹配区域复制到目标图像
        for (m = 0; m < nTplHeight; m++)
        {
            for (n = 0; n < nTplWidth; n++)
            {
                int nGray = *src->ptr(nMaxY + m, nMaxX + n);
                //pTo->setTo(nMaxX + n, nMaxY + m, RGB(nGray, nGray, nGray));
                pTo->at<BYTE>(nMaxY + m, nMaxX + n) = nGray;
            }
        }
    
    }   

    测试代码

    #include"TemplateMatch.h"
    #include<iostream>
    
    using namespace std;
    int main()
    {
        Mat src = imread("./src.jpg", 0);
        Mat Template = imread("./template.jpg", 0);
        Mat pt=src;
        pt.data = new BYTE[src.cols*src.rows];
        memset(pt.data, 255, src.cols*src.rows);
        TemplateMatch(&pt, &Template, &src);
        imshow("S", src);
        imshow("T", Template);
        imshow("P", pt);
    
        imwrite("S.jpg", src);
        imwrite("T.jpg", Template);
        imwrite("P.jpg", pt);
        waitKey(0);
        return 0;
    }

    效果如下:
    这里写图片描述

        下面给出这个工程的百度云连接:链接:http://pan.baidu.com/s/1jIuuT3w 密码:veto
    

    写的不好的地方,还希望指正,O(∩_∩)O谢谢。
    在这我要强烈推荐一本书:《数字图像处理与机器视觉 Visual C 与Matlab实现》,这本书写的很基础,适合初学者和研究人员

    展开全文
  • 模板匹配就是按照一定的相似性规则,在一张图像中寻找与模板最相似的区域。 参考opencv官网:https://docs.opencv.org/3.4.1/de/da9/tutorial_template_matching.html 模板匹配的过程如下:  左上角小狗图像为...

    模板匹配就是按照一定的相似性规则,在一张图像中寻找与模板最相似的区域。

    参考opencv官网:https://docs.opencv.org/3.4.1/de/da9/tutorial_template_matching.html

    模板匹配的过程如下:

        左上角小狗图像为定义的模板,下面的图片为待匹配图像,匹配的过程就是按照从左到右,从上到下的顺序,依次遍历全图,通过定义的相似度评判准则,计算模板与当前位置图像块的相似度,进而得到最相似位置,实现目标定位。

        常见的相似度准则有:

        即:平方差、归一化平方差、相关系数、归一化相关系数、互相关五种。

        下面就是代码,这里只实现了两种:平方误差及绝对误差

    #include <opencv2/opencv.hpp>
    #include <math.h>
    #include <iostream>
    
    using namespace cv;
    using namespace std;
    
    #define SQDIFF 0
    #define SADIFF 1
    
    float templateMatch(const Mat & src, const Mat & temp, int & i_match, int & j_match, int Match_methold)
    {
    	int src_cols = src.cols;
    	int src_rows = src.rows;
    	int temp_cols = temp.cols;
    	int temp_rows = temp.rows;
    
    	int i_end = src_rows - temp.rows + 1;
    	int j_end = src.cols - temp.cols + 1;
    
    	float match_degree = FLT_MAX;
    
    	for (int i = 0; i < i_end; i++)
    	{
    		for (int j = 0; j < j_end; j++)
    		{
    			float match_ij = 0.0;
    
    			for (int m = 0; m < temp_rows; m++)
    			{
    				for (int n = 0; n < temp_cols; n++)
    				{
    					uchar val_s = src.at<uchar>(i + m, j + n);
    					uchar val_t = temp.at<uchar>(m, n);
    					if (Match_methold == SQDIFF)
    					{
    						match_ij += float((val_t - val_s) * (val_t - val_s));
    					}
    					else if (Match_methold == SADIFF)
    					{
    						match_ij += float(abs(val_t - val_s));
    					}
    				}
    			}
    			
    			//cout << match_ij << endl;
    			if (match_ij < match_degree)
    			{
    				match_degree = match_ij;
    				i_match = i;
    				j_match = j;
    			}
    		}
    	}
    	
    
    	return match_degree;
    
    }
    
    int main()
    {
    	Mat src = imread("messi5.jpg", CV_LOAD_IMAGE_GRAYSCALE);
    	Mat temp = imread("face.png", CV_LOAD_IMAGE_GRAYSCALE);
    	
    	float match_degree = 0;
    	int i_match = -1, j_match = -1;
    	match_degree = templateMatch(src, temp, i_match, j_match, SQDIFF);
    	
    	cout << i_match << j_match << match_degree << endl;
    
    	Mat src_color;
    	cvtColor(src, src_color, COLOR_GRAY2BGR);
    	rectangle(src_color, Rect(j_match, i_match, temp.cols, temp.rows), Scalar(255, 0, 0));
    	imshow("result", src_color);
    	waitKey(0);
    
    	return 0;
    }

    匹配结果:

    改进方法:

    1)增加步长

    2)随机抽样匹配

        增加步长就不多讨论了,随机抽样,利用的是目标所在矩形区域位置中,目标应该位于矩形区域中央,边界部分大部分为背景,因此考虑对模版进行随机采样,采样方法为:越靠近中心位置,生成越多的采样点,反之,越远离中心位置,生成较少的采样点,这里采用的随机生成函数为Gaussian函数。

    int main()
    {
    	Mat src = imread("messi5.jpg", CV_LOAD_IMAGE_GRAYSCALE);
    	Mat temp = imread("messi_face.jpg", CV_LOAD_IMAGE_GRAYSCALE);
    
    	float match_degree = 0;
    	int i_match = -1, j_match = -1;
    
    	
    	vector <Point2i> real_sample_points;
    	computeSamplePoints(real_sample_points, Rect(0, 0, temp.cols - 1, temp.rows - 1));
    
    	match_degree = templateMatch(src, temp, i_match, j_match, SQDIFF, real_sample_points);
    
    	cout << i_match << j_match << match_degree << endl;
    
    
    	Mat src_color;
    	cvtColor(src, src_color, COLOR_GRAY2BGR);
    	for (int i = 0; i < 1000; i++){
    		circle(src_color, Point(j_match, i_match) + real_sample_points[i], 1, Scalar(0, 255, 0));
    	}
    	rectangle(src_color, Rect(j_match, i_match, temp.cols, temp.rows), Scalar(255, 0, 0));
    	imshow("result", src_color);
    	waitKey(0);
    
    	return 0;
    
    }

    匹配结果如下:

    里面绿色点表示采样位置。

    参考资料:

    opencv 官网

    展开全文
  • 用vc++6.0编写的,用于实现图像处理模版匹配的功能,里面是一个完整的程序文件。
  • 模板匹配顾名思义就是给定一幅影像(模板)然后在另一幅 图像中寻找这个模板的操作。它是一种用来在一幅大图中 寻找模板图像位置的方法。在OpenCV中有cv2.matchTemplate() 函数供我们方便调用。它的工作原理与2D卷积...
  • 如果要在一幅图像中寻找已知物体,最常用且最简单的方法之一就是匹配。%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % 基于最小距离分类器的模板匹配 % 寻找图片中与已知模板匹配区域 % date:2016-4-...
  • 模板匹配的基本概念 模板就是一幅已知的小图像模板匹配就是在一幅大图像中搜寻目标,已知该图中 有要找的目标,且该目标同模板有相同的尺寸、方向和图像,通过一定的算法可以在图 中找到目标,确定其坐标位置...
  • 模板匹配(match template)1.基本概念 1.基本概念 模板匹配: 在整个图像区域中发现与给定子图像匹配的小块区域 要素: ①模板图像T ②待检图像S
  • 用matlab实现图像模板匹配,简单易用,有实例。
  • 今天阅读了一篇论文,里面提到的内容是用固定的模板对现实场景进行匹配,通过匹配得到的结果可以得知待匹配图像模板的角度差别,论文中提到了把待匹配图像转换到频域进行,个人不是很理解。假设已经提取了一个角...
  • HALCON中的模板匹配方法总结摘要1. Shape-Based matching的基本流程2. 基于形状匹配的参数关系与优化 摘要 德国MVTec公司开发的HALCON机器视觉开发软件,提供了许多的功能,在这里我主要学习和研究了其中的形状匹配...
  • 模板匹配就是在整个图像区域发现与给定子图像匹配的小块区域。 工作原理:在带检测图像上,从左到右,从上向下计算模板图像与重叠子图像匹配度,匹配程度越大,两者相同的可能性越大。 局限性:它只能进行平行...
  • 图像处理之图像匹配

    2019-08-07 22:19:52
    该说图像匹配了,图像匹配在图片处理中的作用举重若轻,今天就带大家入门图像匹配,简单介绍一下基础的图像匹配吧。 何为图像匹配呢?在原图片中扣出一块区域,然后通过这块区域的像素找到它在原始图片的位置,在...
  • Java OpenCV-4.0.0 图像处理22 图像模板匹配 参考链接:https://blog.csdn.net/qq_34814092/article/details/95813654 Java OpenCV-4.0.0 图像处理22 图像模板匹配 模板匹配就是在整个图像区域发现与给定子图像...
  • 应用背景:机器的模式识别所要解决的问题,就是用机器代替人去认识图像和找出一幅图像中人们感兴趣的目标物。如何找到目标物即图像的区域呢,这里介绍在空间域使用模板图像中寻找与模板匹配的区域。
1 2 3 4 5 ... 20
收藏数 24,071
精华内容 9,628