opencv,模板匹配源码
opencv模板匹配6种方法 总结
opencv模板匹配6种方法总结
OpenCV中的模板匹配是一种常见的图像处理技术，用于在图像中查找与
给定模板相匹配的区域。
以下是OpenCV中模板匹配的6种方法：
1. ()：这是最基本的方法，它使用滑动窗口在源图像中查找与模板相匹配的区域。
它返回一个包含每个匹配区域位置和相似度的二维数组。
2. _CCOEFF：这是使用余弦相似度作为匹配度量的一种方法。
它计算模板
和源图像之间的余弦相似度，并返回与模板匹配的区域位置和相似度。
3. _CCOEFF_NORMED：这是使用归一化余弦相似度作为匹配度量的一种
方法。
它计算模板和源图像之间的归一化余弦相似度，并返回与模板匹配的区域位置和相似度。
4. _CCORR：这是使用相关系数作为匹配度量的一种方法。
它计算模板和源图像之间的相关系数，并返回与模板匹配的区域位置和相似度。
5. _CCORR_NORMED：这是使用归一化相关系数作为匹配度量的一种方法。
它计算模板和源图像之间的归一化相关系数，并返回与模板匹配的区域位置和相似度。
6. _SQDIFF：这是使用平方差异作为匹配度量的一种方法。
它计算模板和源图像之间的平方差异，并返回与模板匹配的区域位置和差异值。
总结来说，这6种方法都使用了不同的相似度度量来在源图像中查找与模板相匹配的区域。
其中，()是最基本的方法，而其他方法则提供了不同的相似度度量选项。
选择哪种方法取决于具体的应用场景和需求。
1.4利用Opencv进行模板匹配（templatematching）-在图片中查找图片
1.4利⽤Opencv进⾏模板匹配（templatematching）-在图⽚中查找图⽚原理：利⽤相关匹配的算法（cv2.TM_COEFF_NORMED）, 简单讲就是⽤此算法把模板计算出来，再计算出图⽚的值，从图⽚中查找出最相近的位置。
import cv2import numpy as npimport imutilsdef template_matching(image_full_path, tmpl_full_path, min_confidence=0.93, ):""":param image_full_path: 输⼊图⽚路径，在该图⽚中查找模板图像:param tmpl_full_path: 模板图⽚，在输⼊图⽚中查找此模板:param min_confidence: 最⼩信⼼度，该⽅法返回⼤于此信⼼度的结果:return: 返回result_dic ==> {信⼼度：（坐标Tuple）}, sorted(confidence_list,reverse=True)==>信⼼度降序排列列表"""img = cv2.imread(image_full_path) # 读取输⼊图⽚gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 转换为灰度图，采⽤CV_BGR2GRAY,转换公式Gray = 0.1140*B + 0.5870*G + 0.2989*R# template = cv2.imread(tmpl_full_path, cv2.IMREAD_GRAYSCALE) # 读取模板图⽚的灰度图template = cv2.imread(tmpl_full_path) # 为保证输⼊图⽚与模板⼀致性，两张图⽚⽤相同⽅法读取灰度图⽚template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)# w, h = template.shape[::-1] # 获取模板的宽和⾼(绘图时使⽤，本函数内⽆意义）res = cv2.matchTemplate(gray_img, template, cv2.TM_CCOEFF_NORMED) # TM_CCOEFF_NORMED 标准相关匹配loc = np.where(res >= min_confidence) # 在结果中筛选⼤于最⼩信⼼度的结果result_dic = {}confidence_list = []for pt in zip(*loc[::-1]):result_dic[res[pt[1]][pt[0]]] = ptconfidence_list.append(res[pt[1]][pt[0]])# cv2.rectangle(img, pt, (pt[0] + w, pt[1] + h), (0, 0, 255), 3) # 在⽬标位置绘制⼀个红⾊矩形框，边宽3pxreturn result_dic, sorted(confidence_list, reverse=True)def diff_size_template_matching(image_full_path, tmpl_full_path, min_confidence=0.95, ):""":param image_full_path: 输⼊图⽚路径，在该图⽚中查找模板图像:param tmpl_full_path: 模板图⽚，在输⼊图⽚中查找此模板:param min_confidence: 最⼩信⼼度，该⽅法返回⼤于此信⼼度的结果:return: 返回result_dic ==> {信⼼度：（坐标Tuple）}, sorted(confidence_list,reverse=True)==>信⼼度降序排列列表"""template = cv2.imread(tmpl_full_path)template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY) # 获得灰度模板image = cv2.imread(image_full_path)gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # 获得灰度图⽚result_dic = {}confidence_list = []for scale in np.linspace(0.2, 1.0, 100)[::-1]: # 1倍到0.2倍分100级变化(级数越⾼，可能获得的匹配精度越⾼，处理越慢)resized = imutils.resize(template, width=int(template.shape[1] * scale)) # 以scale 为倍数改变模板⼤⼩# (w, h) = resized.shape[::-1] # 求改变后的模板宽⾼result = cv2.matchTemplate(gray_img, resized, cv2.TM_CCOEFF_NORMED) # 每次改变都进⾏⼀次匹配loc = np.where(result >= min_confidence) # 在结果中筛选⼤于最⼩信⼼度的结果for pt in zip(*loc[::-1]):result_dic[result[pt[1]][pt[0]]] = ptconfidence_list.append(result[pt[1]][pt[0]])# cv2.rectangle(image, pt, (pt[0] + w, pt[1] + h), (0, 0, 255), 3)return result_dic, sorted(confidence_list, reverse=True)if__name__ == '__main__':pass。
opencv-matchTemplate模板匹配（大图中寻找小图）
opencv-matchTemplate模板匹配（⼤图中寻找⼩图）单个匹配11.png12.png#include<opencv2/opencv.hpp>#include<iostream>int main(int argc, char** argv) {cv::Mat src = cv::imread("D:/bb/tu/11.png");cv::Mat templ = cv::imread("D:/bb/tu/12.png");cv::Mat ftmp;cv::matchTemplate(src, templ, ftmp,5); //模板匹配/*参数1:src⽤于搜索的输⼊图像, 8U 或 32F, ⼤⼩ W-H参数2:⽤于匹配的模板，和src类型相同，⼤⼩ w-h参数3:匹配结果图像, 类型 32F, ⼤⼩ (W-w+1)-(H-h+1)参数4:⽤于⽐较的⽅法(有六种)cv::TM_SQDIFF=0 该⽅法使⽤平⽅差进⾏匹配，因此最佳的匹配结果在结果为0处，值越⼤匹配结果越差cv::TM_SQDIFF_NORMED=1：该⽅法使⽤归⼀化的平⽅差进⾏匹配，最佳匹配也在结果为0处cv::TM_CCORR=2：相关性匹配⽅法，该⽅法使⽤源图像与模板图像的卷积结果进⾏匹配，因此，最佳匹配位置在值最⼤处，值越⼩匹配结果越差【个⼈测试：匹配性很差】cv::TM_CCORR_NORMED=3：归⼀化的相关性匹配⽅法，与相关性匹配⽅法类似，最佳匹配位置也是在值最⼤处cv::TM_CCOEFF=4：相关性系数匹配⽅法，该⽅法使⽤源图像与其均值的差、模板与其均值的差⼆者之间的相关性进⾏匹配，最佳匹配结果在值等于1处，最差匹配结果在值等于-1处，值等于0直接表⽰⼆者不相关cv::TM_CCOEFF_NORMED=5：归⼀化的相关性系数匹配⽅法，正值表⽰匹配的结果较好，负值则表⽰匹配的效果较差，也是值越⼤，匹配效果也好*/std::cerr << cv::TM_CCOEFF_NORMED << std::endl;normalize(ftmp, ftmp, 1, 0, cv::NORM_MINMAX);//可以不归⼀化double minVal; double maxVal;cv::Point minLoc;cv::Point maxLoc;minMaxLoc(ftmp, &minVal, &maxVal, &minLoc, &maxLoc); //找到最佳匹配点//从匹配结果图像中找出最佳匹配点rectangle(src, cv::Rect(maxLoc.x, maxLoc.y, templ.cols, templ.rows), cv::Scalar(0, 0, 255), 2, 8);//画出匹配到的矩形框//注意：与⽅法有关，有的是最⼩值是最佳匹配；有的是最⼤值是最佳匹配cv::imshow("src", src);cv::waitKey();return0;}多个匹配13.png14.png#include<opencv2/opencv.hpp>#include<iostream>int main(int argc, char** argv) {cv::Mat src = cv::imread("D:/bb/tu/13.png");cv::Mat tem = cv::imread("D:/bb/tu/14.png");cv::Mat resultImage;matchTemplate(src, tem, resultImage, 5);//模板匹配/*我寻找多个匹配的思路：matchTemplate之后，resultImage中保存了匹配相似度匹配⽅法是cv::TM_CCOEFF_NORMED=5，值越⼤，相似度越⾼相似度⼤于0.97，我就认为匹配⾮常好，所以我要遍历出相似度⼤于0.97的坐标*/std::vector<cv::Point> point;for (int i = 0; i < resultImage.rows; i++) { //i是⾏号for (int j = 0; j < resultImage.cols; j++) { //j是列号float t = resultImage.at<float>(i, j); //返回指点坐标的数据if (t > 0.97) {point.insert(point.end(), cv::Point(j,i));}}}//画出多个匹配for (int i = 0; i < point.size(); i++){rectangle(src, cv::Rect(point[i].x, point[i].y, tem.cols, tem.rows), cv::Scalar(0, 0, 255), 2, 8); }cv::imshow("src", src);cv::waitKey();return0;}。
opencv——matchTemplate模板匹配
opencv——matchTemplate 模板匹配模板匹配的概念和原理模板匹配就是在⼀幅图像中寻找与模板图像最匹配（相似）部分。
具体步骤为从左到右，从上向下计算模板图像与图像覆盖区域的匹配度，匹配程度越⼤，两者相同的可能性越⼤。
实现模板匹配：matchTemplate 函数void matchTemplate(InputArray image, InputArray temp1, OutputArray result, int method);image ，待搜索的图像，且需为 8 位或 32 位浮点型图像。
temp1，搜索模板，需要和原图⽚有⼀样的数据类型，且尺⼨不能⼤于源图像。
result ，⽐较结果的映射图像，其必须为单通道、32 位浮点型图像，⼤⼩为 （image.cols - temp1.cols +1）×（image.rows - temp1.rows +1）method ，匹配⽅法，有 6 种选项：匹配⽅法计算公式平⽅差匹配法TM_SQDIFF归⼀化平⽅差匹配法TM_SQDIFF_NORMED相关匹配法TM_CCORR归⼀化相关匹配法TM_CCORR_NORMED系数匹配法TM_CCOEFF其中化相关系数匹配法TM_CCOEFF_NORMED代码⽰例：#include<opencv.hpp>#include<iostream>#include<string>using namespace std;using namespace cv;Mat src, temp;int method = 0;void ChangeMethod(int, void*) {switch (method){case0:method = TM_SQDIFF;break;case1:method = TM_SQDIFF_NORMED;break;case2:method = TM_CCORR;break;case3:method = TM_CCORR_NORMED;break;case4:method = TM_CCOEFF;break;case5:method = TM_CCOEFF_NORMED;break;}Mat result;matchTemplate(src, temp, result, method);imshow("result", result);Mat dst = src.clone();double mxValue, mnValue;Point mxPoint, mnPoint;minMaxLoc(result, &mnValue, &mxValue, &mnPoint, &mxPoint);//if (method == TM_SQDIFF || method == TM_SQDIFF_NORMED) {rectangle(dst, mnPoint, Point(mnPoint.x + temp.cols, mnPoint.y + temp.rows), Scalar(0, 0, 255)); }else{rectangle(dst, mxPoint, Point(mxPoint.x + temp.cols, mxPoint.y + temp.rows), Scalar(0, 0, 255)); }imshow("dst", dst);}int main() {src = imread("C:/Users/齐明洋/Desktop/1.jpg");temp = imread("C:/Users/齐明洋/Desktop/a.jpg");imshow("src", src);imshow("temp", temp);namedWindow("dst");createTrackbar("method", "dst", &method, 5, ChangeMethod);ChangeMethod(0, 0);waitKey(0);}效果演⽰：原图和模板：TM_SQDIFF ⽅法TM_SQDIFF_NORMED ⽅法TM_CCORR ⽅法TM_CCORR_NORMED ⽅法TM_CCOEFF ⽅法TM_CCOEFF_NORMED ⽅法。
OpenCV实战（1）——图像相似度算法（比对像素方差，感知哈希算法，模板匹配（OCR数字。。。
OpenCV实战（1）——图像相似度算法（⽐对像素⽅差，感知哈希算法，模板匹配（OCR数字。
如果需要处理的原图及代码，请移步⼩编的GitHub地址 传送门： 如果点击有误：https:///LeBron-Jian/ComputerVisionPractice 最近⼀段时间学习并做的都是对图像进⾏处理，其实⾃⼰也是新⼿，各种尝试，所以我这个门外汉想总结⼀下⾃⼰学习的东西，图像处理的流程。
但是动起笔来想总结，⼀下却不知道⾃⼰要写什么，那就把⾃⼰做过的相似图⽚搜索的流程整理⼀下，想到什么说什么吧。
⼀：图⽚相似度算法（对像素求⽅差并⽐对）的学习1.1 算法逻辑1.1.1 缩放图⽚ 将需要处理的图⽚所放到指定尺⼨，缩放后图⽚⼤⼩由图⽚的信息量和复杂度决定。
譬如，⼀些简单的图标之类图像包含的信息量少，复杂度低，可以缩放⼩⼀点。
风景等复杂场景信息量⼤，复杂度⾼就不能缩放太⼩，容易丢失重要信息。
根据⾃⼰需求，弹性的缩放。
在效率和准确度之间维持平衡。
1.1.2 灰度处理 通常对⽐图像相似度和颜⾊关系不是很⼤，所以处理为灰度图，减少后期计算的复杂度。
如果有特殊需求则保留图像⾊彩。
1.1.3 计算平均值 此处开始，与传统的哈希算法不同：分别依次计算图像每⾏像素点的平均值，记录每⾏像素点的平均值。
每⼀个平均值对应着⼀⾏的特征。
1.1.4 计算⽅差 对得到的所有平均值进⾏计算⽅差，得到的⽅差就是图像的特征值。
⽅差可以很好的反应每⾏像素特征的波动，既记录了图⽚的主要信息。
1.1.5 ⽐较⽅差 经过上⾯的计算之后，每张图都会⽣成⼀个特征值（⽅差）。
到此，⽐较图像相似度就是⽐较图像⽣成⽅差的接近成程度。
⼀组数据⽅差的⼤⼩可以判断稳定性，多组数据⽅差的接近程度可以反应数据波动的接近程度。
我们不关注⽅差的⼤⼩，只关注两个⽅差的差值的⼤⼩。
⽅差差值越⼩图像越相似！1.2 代码：import cv2import matplotlib.pyplot as plt#计算⽅差def getss(list):#计算平均值avg=sum(list)/len(list)#定义⽅差变量ss，初值为0ss=0#计算⽅差for l in list:ss+=(l-avg)*(l-avg)/len(list)#返回⽅差return ss#获取每⾏像素平均值def getdiff(img):#定义边长Sidelength=30#缩放图像img=cv2.resize(img,(Sidelength,Sidelength),interpolation=cv2.INTER_CUBIC)#灰度处理gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)#avglist列表保存每⾏像素平均值avglist=[]#计算每⾏均值，保存到avglist列表for i in range(Sidelength):avg=sum(gray[i])/len(gray[i])avglist.append(avg)#返回avglist平均值return avglist#读取测试图⽚img1=cv2.imread("james.jpg")diff1=getdiff(img1)print('img1:',getss(diff1))#读取测试图⽚img11=cv2.imread("durant.jpg")diff11=getdiff(img11)print('img11:',getss(diff11))ss1=getss(diff1)ss2=getss(diff11)print("两张照⽚的⽅差为：%s"%(abs(ss1-ss2))) x=range(30)plt.figure("avg")plt.plot(x,diff1,marker="*",label="$jiames$") plt.plot(x,diff11,marker="*",label="$durant$") plt.title("avg")plt.legend()plt.show()cv2.waitKey(0)cv2.destroyAllWindows() 两张原图： 图像结果如下：img1: 357.03162469135805img11: 202.56193703703704两张照⽚的⽅差为：154.469687654321 实验环境开始设置了图⽚像素值，⽽且进⾏灰度化处理，此⽅法⽐对图像相似对不同的图⽚⽅差很⼤，结果很明显，但是对⽐⽐较相似，特别相似的图⽚不适应。
python opencv模板匹配参数详解
python opencv模板匹配参数详解在使用pythonopencv进行模板匹配时，需要了解一些参数的含义和作用，以便得到更好的匹配效果。
1. 模板匹配方法opencv中提供了多种模板匹配方法，包括cv2.TM_CCOEFF、cv2.TM_CCOEFF_NORMED、cv2.TM_CCORR、cv2.TM_CCORR_NORMED、cv2.TM_SQDIFF、cv2.TM_SQDIFF_NORMED。
其中，TM_CCOEFF、TM_CCORR、TM_SQDIFF分别表示相关系数匹配法、相关性匹配法、平方差匹配法；NORMED表示对结果进行归一化处理。
2. 模板和待匹配图像的大小模板和待匹配图像的大小对匹配效果有很大影响。
如果模板大小和待匹配图像大小相差较大，会导致匹配不准确。
因此，在进行模板匹配时，应该根据实际情况选择合适的模板大小和待匹配图像大小。
3. 匹配结果的阈值在进行模板匹配时，需要设置一个阈值来确定匹配程度。
如果设置的阈值过高，则可能导致无法匹配；如果设置的阈值过低，则可能导致误匹配。
因此，在设置匹配阈值时，应该根据实际情况进行调整。
4. 匹配结果的位置模板匹配后，会返回匹配结果的位置。
通常情况下，匹配结果的位置是模板在待匹配图像中的左上角顶点坐标。
如果需要得到匹配结果的中心坐标，则可以根据模板的大小进行计算。
5. 匹配结果的可靠性在进行模板匹配时，可能会出现多个匹配结果的情况。
为了提高匹配结果的可靠性，可以采用多个模板进行匹配，或者对匹配结果进行滤波处理。
总之，了解模板匹配的各种参数和方法，能够帮助我们得到更好的匹配效果。
同时，也需要根据实际情况进行调整，以达到最优的匹配结果。
python opencv模板匹配参数详解
python opencv模板匹配参数详解Python OpenCV模板匹配参数详解在图像处理和计算机视觉中，模板匹配是一种常用的算法。
它用于在一幅图像中查找特定的目标。
在Python OpenCV中，模板匹配是通过cv2.matchTemplate()函数实现的。
该函数接受两个参数：输入图像和模板图像。
它返回一个结果数组，该数组指示了每个像素处的匹配分值。
在进行模板匹配时，参数的选择至关重要。
错误的参数选择可能会导致结果不准确。
因此，本文将详细介绍Python OpenCV模板匹配的参数，帮助您获取更准确的匹配结果。
参数介绍在Python OpenCV中，cv2.matchTemplate()函数的参数如下所示：cv2.matchTemplate(img,template,method,result=No ne,mask=None)其中，img是指用于查找目标的输入图像，template 是指将在img上查找的模板图像。
method是指使用的匹配方法，result是可选的输出数组，mask是可选的掩码图像。
在这些参数中，method是最关键的参数。
它决定了匹配算法的选择。
以下是常用的匹配方法：1. TM_SQDIFF这是平方差匹配法。
它在模板和输入图像之间计算像素值差的平方，并返回最佳匹配的位置。
它的数学表达式如下：R(x,y)=∑(i,j)(T(i,j)−I(x+i,y+j))^2其中，I是输入图像，T是模板图像。
R(x,y)是在点(x,y)处的匹配分值。
2. TM_SQDIFF_NORMED这是归一化的平方差匹配法。
它使用像素值差的平方来计算匹配分值，并将分值标准化为0到1之间的范围。
3. TM_CCORR这是相关性匹配法。
它计算模板和输入图像之间的互相关，并返回最佳匹配的位置。
4. TM_CCORR_NORMED这是归一化的相关性匹配法。
与TM_CCORR相似，但将分值标准化为0到1之间的范围。
OpenCV模板匹配算法详解
OpenCV模板匹配算法详解1 理论介绍模板匹配是在⼀幅图像中寻找⼀个特定⽬标的⽅法之⼀，这种⽅法的原理⾮常简单，遍历图像中的每⼀个可能的位置，⽐较各处与模板是否“相似”，当相似度⾜够⾼时，就认为找到了我们的⽬标。
OpenCV提供了6种模板匹配算法：1. 平⽅差匹配法CV_TM_SQDIFF2. 归⼀化平⽅差匹配法CV_TM_SQDIFF_NORMED3. 相关匹配法CV_TM_CCORR4. 归⼀化相关匹配法CV_TM_CCORR_NORMED5. 相关系数匹配法CV_TM_CCOEFF6. 归⼀化相关系数匹配法CV_TM_CCOEFF_NORMED⽤T表⽰模板图像，I表⽰待匹配图像，切模板图像的宽为w⾼为h，⽤R表⽰匹配结果，匹配过程如下图所⽰：上述6中匹配⽅法可⽤以下公式进⾏描述：2 ⽰例代码下⾯给出⽅法6的python代码1import numpy as np2import cv234def EM(pModel, width, height):5 sum = np.double(0.0)6for i in range(0,height):7for j in range(0,width):8 sum += pModel[i][j]9return sum1011def EM2(pModel, width, height):12 sum = np.double(0.0)13for i in range(0,height):14for j in range(0,width):15 sum += pModel[i][j]*1.0*pModel[i][j]16return sum1718def EI(pToSearch, l, h, u, v, pModel, width, height):19 sum = np.double(0.0)20 roi = pToSearch[v:v+height, u:u+width]21for i in range(0,height):22for j in range(0,width):23 sum += roi[i][j]24return sum2526def EI2(pToSearch, l, h, u, v, pModel, width, height):27 sum = np.double(0.0)28 roi = pToSearch[v:v+height, u:u+width]29for i in range(0,height):30for j in range(0,width):31 sum += roi[i][j]*1.0*roi[i][j]32return sum3334def EIM(pToSearch, l, h, u, v, pModel, width, height):35 sum = np.double(0.0)36 roi = pToSearch[v:v+height, u:u+width]37for i in range(0,height):38for j in range(0,width):39 sum += pModel[i][j]*1.0*roi[i][j]40return sum4142def Match(pToSearch, l, h, pModel, width, height):43 uMax = l-width44 vMax = h-height45 N = width*height46 len = (uMax+1)*(vMax+1)47 MatchRec = [0.0 for x in range(0, len)]48 k = 04950 M = EM(pModel,width,height)51 M2 = EM2(pModel,width,height)52for p in range(0, uMax+1):53for q in range(0, vMax+1):54 I = EI(pToSearch,l,h,p,q,pModel,width,height)55 I2 = EI2(pToSearch,l,h,p,q,pModel,width,height)56 IM = EIM(pToSearch,l,h,p,q,pModel,width,height)5758 numerator=(N*IM-I*M)*(N*IM-I*M)59 denominator=(N*I2-I*I)*(N*M2-M*M)6061 ret = numerator/denominator62 MatchRec[k]=ret63 k+=16465 val = 066 k = 067 x = y = 068for p in range(0, uMax+1):69for q in range(0, vMax+1):70if MatchRec[k] > val:71 val = MatchRec[k]72 x = p73 y = q74 k+=175print"val: %f"%val76return (x, y)7778def main():79 img = cv2.imread('niu.jpg', cv2.IMREAD_GRAYSCALE)80 temp = cv2.imread('temp.png', cv2.IMREAD_GRAYSCALE)8182print temp.shape83 imgHt, imgWd = img.shape84 tempHt, tempWd = temp.shape85#print EM(temp, tempWd, tempHt)86 (x, y) = Match(img, imgWd, imgHt, temp, tempWd, tempHt)87 cv2.rectangle(img, (x, y), (x+tempWd, y+tempHt), (0,0,0), 2)88 cv2.imshow("temp", temp)89 cv2.imshow("result", img)90 cv2.waitKey(0)91 cv2.destroyAllWindows()9293if__name__ == '__main__':94 main()归⼀化相关系数匹配法代码58⾏中的N就是公式(6)中的w*h，由于python代码运⾏速度⽐较慢，代码的58、59⾏相当于对公式(6)的分⼦分母都进⾏了平⽅操作，并且分⼦分母都乘以了N⽅，以减⼩计算量，所以代码61⾏的ret相当于公式(6)中的R(x,y)的平⽅，为了更快的进⾏算法验证，⽤上述代码进⾏验证时请尽量选⽤较⼩的匹配图像及模板图像，下图显⽰了我的匹配结果（待匹配图像295x184模板69x46⽤了⼗⼏分钟）：3 OpenCV源码较新版本的OpenCV库中的模板匹配已经进⾏了较多的算法改进，直接看新版本中的算法需要了解很多相关理论知识，所以我们结合OpenCV0.9.5的源码进⾏讲解，该版本的源码基本上是C风格代码更容易进⾏理解（如果要对OpenCV源码进⾏研究，建议⽤该版本进⾏⼊门），仍以归⼀化相关系数匹配法为例进⾏分析。
OpenCV---模板匹配matchTemplate
OpenCV---模板匹配matchTemplate作⽤有局限性，必须在指定的环境下，才能匹配成功，是受到很多因素的影响，所以有⼀定的适应性模板匹配是⼀种最原始、最基本的模式识别⽅法，研究某⼀特定对象物的图案位于图像的什么地⽅，进⽽识别对象物，这就是⼀个匹配问题。
它是图像处理中最基本、最常⽤的匹配⽅法。
模板匹配具有⾃⾝的局限性，主要表现在它只能进⾏平⾏移动，若原图像中的匹配⽬标发⽣旋转或⼤⼩变化，该算法⽆效。
模板匹配就是在整个图像区域发现与给定⼦图像匹配的⼩块区域⼯作原理：在待检测图像上，从左到右，从上向下计算模板图像与重叠⼦图像的匹配度，匹配程度越⼤，两者相同的可能性越⼤。
代码实现：import cv2 as cvimport numpy as npdef template_demo():tpl = cv.imread("./temp.png")target = cv.imread("./1.png")cv.imshow("template image",tpl)cv.imshow("target image",target)methods = [cv.TM_SQDIFF_NORMED,cv.TM_CCORR_NORMED,cv.TM_CCOEFF_NORMED] #各种匹配算法th,tw = tpl.shape[:2] #获取模板图像的⾼宽for md in methods:result = cv.matchTemplate(target,tpl,md)# result是我们各种算法下匹配后的图像# cv.imshow("%s"%md,result)#获取的是每种公式中计算出来的值，每个像素点都对应⼀个值min_val,max_val,min_loc,max_loc = cv.minMaxLoc(result)if md == cv.TM_SQDIFF_NORMED:tl = min_loc #tl是左上⾓点else:tl = max_locbr = (tl[0]+tw,tl[1]+th) #右下点cv.rectangle(target,tl,br,(0,0,255),2) #画矩形cv.imshow("match-%s"%md,target)src = cv.imread("./1.png") #读取图⽚dWindow("input image",cv.WINDOW_AUTOSIZE) #创建GUI窗⼝,形式为⾃适应cv.imshow("input image",src) #通过名字将图像和窗⼝联系template_demo()cv.waitKey(0) #等待⽤户操作，⾥⾯等待参数是毫秒，我们填写0，代表是永远，等待⽤户操作cv.destroyAllWindows() #销毁所有窗⼝补充：1.⼏种常见的模板匹配算法①TM_SQDIFF是平⽅差匹配；TM_SQDIFF_NORMED是标准平⽅差匹配。
python基于OpenCV模板匹配识别图片中的数字
python基于OpenCV模板匹配识别图⽚中的数字⽬录前⾔程序⽬标思路讲解代码讲解完整代码总结前⾔本博客主要实现利⽤OpenCV的模板匹配识别图像中的数字，然后把识别出来的数字输出到txt⽂件中，如果识别失败则输出“读取失败”。
操作环境：OpenCV - 4.1.0Python 3.8.1程序⽬标单个数字模板：（这些单个模板是我⾃⼰直接从图⽚上截取下来的）要处理的图⽚：终端输出：⽂本输出：思路讲解代码讲解⾸先定义两个会⽤到的函数第⼀个是显⽰图⽚的函数，这样的话在显⽰图⽚的时候就⽐较⽅便了def cv_show(name, img):cv2.imshow(name, img)cv2.waitKey(0)cv2.destroyAllWindows()第⼆个是图⽚缩放的函数def resize(image, width=None, height=None, inter=cv2.INTER_AREA):dim = None(h, w) = image.shape[:2]if width is None and height is None:return imageif width is None:r = height / float(h)dim = (int(w * r), height)else:r = width / float(w)dim = (width, int(h * r))resized = cv2.resize(image, dim, interpolation=inter)return resized先把这个代码贴出来，⽅便后⾯单个函数代码的理解。
if __name__ == "__main__":# 存放数字模板列表digits = []# 当前运⾏⽬录now_dir = os.getcwd()print("当前运⾏⽬录：" + now_dir)numbers_address = now_dir + "\\numbers"load_digits()times = input("请输⼊程序运⾏次数：")for i in range(1, int(times) + 1):demo(i)print("输出成功，请检查本地temp.txt⽂件")while True:if input("输⼊⼩写‘q'并回车退出") == 'q':break接下来是第⼀个主要函数，功能是加载数字模板并进⾏处理。
使用Python+OpenCV进行图像模板匹配（MatchTemplate）
使⽤Python+OpenCV进⾏图像模板匹配（MatchTemplate）2017年9⽉22⽇ BY本篇⽂章介绍使⽤Python和OpenCV对图像进⾏模板匹配和识别。
模板匹配是在图像中寻找和识别模板的⼀种简单的⽅法。
以下是具体的步骤及代码。
⾸先导⼊所需库⽂件，numpy和cv2。
#导⼊所需库⽂件import cv2import numpy as np然后加载原始图像和要搜索的图像模板。
OpenCV对原始图像进⾏处理，创建⼀个灰度版本，在灰度图像⾥进⾏处理和查找匹配。
然后使⽤相同的坐标在原始图像中进⾏还原并输出。
#加载原始RGB图像img_rgb = cv2.imread("photo.jpg")#创建⼀个原始图像的灰度版本，所有操作在灰度版本中处理，然后在RGB图像中使⽤相同坐标还原img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)#加载将要搜索的图像模板template = cv2.imread('face.jpg',0)#记录图像模板的尺⼨w, h = template.shape[::-1]这⾥我们分别输出并查看原始图像，原始图像的灰度版本，以及图像模板。
#查看三组图像(图像标签名称，⽂件名称)cv2.imshow('rgb',img_rgb)cv2.imshow('gray',img_gray)cv2.imshow('template',template)cv2.waitKey(0)cv2.destroyAllWindows()使⽤matchTemplate在原始图像中查找并匹配图像模板中的内容，并设置阈值。
#使⽤matchTemplate对原始灰度图像和图像模板进⾏匹配res = cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED)#设定阈值threshold = 0.7#res⼤于70%loc = np.where( res >= threshold)匹配完成后在原始图像中使⽤灰度图像的坐标对原始图像进⾏标记。
opencv模板匹配案例
opencv模板匹配案例OpenCV模板匹配是一种常见的图像处理技术，它通过将图像模板与目标图像进行匹配，来找到图像中的特定区域。
下面是一个使用Python和OpenCV实现模板匹配的案例。
首先，我们需要准备两个图像：一个目标图像和一个模板图像。
目标图像是我们想要搜索的图像，而模板图像是我们想要在目标图像中查找的子图像。
```pythonimport cv2import numpy as np# 加载目标图像和模板图像target_image = cv2.imread('target.jpg', cv2.IMREAD_GRAYSCALE)template = cv2.imread('template.jpg', cv2.IMREAD_GRAYSCALE)# 将模板图像转换为灰度图像template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)# 执行模板匹配result = cv2.matchTemplate(target_image, template, cv2.TM_CCOEFF_NORMED)# 找到匹配区域loc = np.where(result >= 0.8)# 在目标图像上绘制匹配区域for pt in zip(*loc[::-1]):cv2.rectangle(target_image, pt, (pt[0] + template.shape[1], pt[1] + template.shape[0]), (0,0,255), 2)# 显示结果cv2.imshow('Result', target_image)cv2.waitKey(0)cv2.destroyAllWindows()```在上面的代码中，我们首先加载目标图像和模板图像，并将模板图像转换为灰度图像。
然后，我们使用`cv2.matchTemplate()`函数执行模板匹配，并将结果保存在一个NumPy数组中。
opencv 模板匹配方法
opencv 模板匹配方法
OpenCV提供了几种常用的模板匹配方法，包括：
1. TM_SQDIFF：平方差匹配法。
计算模板和图像窗口的差的平方，并选取最小值作为匹配度。
2. TM_SQDIFF_NORMED：归一化平方差匹配法。
将平方差匹配法得到的结果进行归一化处理，最小值即为匹配度。
3. TM_CCORR：相关性匹配法。
计算模板和图像窗口的乘积的相关性，并选取最大值作为匹配度。
4. TM_CCORR_NORMED：归一化相关性匹配法。
将相关性匹配法得到的结果进行归一化处理，最大值即为匹配度。
5. TM_CCOEFF：相关系数匹配法。
计算模板和图像窗口的相关系数，并选取最大值作为匹配度。
6. TM_CCOEFF_NORMED：归一化相关系数匹配法。
将相关系数匹配法得到的结果进行归一化处理，最大值即为匹配度。
这些方法可以通过OpenCV中的`cv2.matchTemplate()`函数进行调用。
函数的参数包括源图像、模板图像和匹配方法，返回匹配结果的heatmap。
可以使用`cv2.minMaxLoc()`函数来获取最大或最小值的位置。
opencv模板匹配与滑动窗口（单匹配）（多匹配）
opencv模板匹配与滑动窗⼝（单匹配）（多匹配）1单匹配：测试图⽚：code：#include <opencv\cv.h>#include <opencv\highgui.h>#include <opencv\cxcore.h>#include <stdlib.h>#include <stdio.h>/*模板匹配法 --图⽚查找滑动窗⼝的原理⽤等⼤⼩的模板窗⼝在范围中进⾏滑动然后查找匹配*/int main(int argc, char* argv[]){IplImage*src,*templat,*result,*show;int srcW,templatW,srcH,templatH,resultW,resultH;//加载源图像src = cvLoadImage("C:\\Users\\zxl\\Desktop\\4.png" , CV_LOAD_IMAGE_GRAYSCALE);//⽤于显⽰结果show = cvLoadImage("C:\\Users\\zxl\\Desktop\\4.png");//加载模板图像templat = cvLoadImage("C:\\Users\\zxl\\Desktop\\1.png" , CV_LOAD_IMAGE_GRAYSCALE);if(!src || !templat){printf("打开图⽚失败");return 0;}srcW = src->width;srcH = src->height;templatW = templat->width;templatH = templat->height;if(srcW<templatW || srcH<templatH){printf("模板不能⽐原图⼩");return 0;}//计算结果矩阵的⼤⼩resultW = srcW - templatW + 1;resultH = srcH - templatH + 1;//创建存放结果的空间result = cvCreateImage(cvSize(resultW,resultH),32,1);double minVal,maxVal;CvPoint minLoc,maxLoc;//调⽤模板匹配函数cvMatchTemplate(src,templat,result,CV_TM_SQDIFF);//查找最相似的值及其所在坐标cvMinMaxLoc(result,&minVal,&maxVal,&minLoc,&maxLoc,NULL);printf("minVal %f maxVal %f\n ",minVal,maxVal);//绘制结果cvRectangle(show,minLoc,cvPoint(minLoc.x+templat->width,minLoc.y+templat->height),CV_RGB(0,255,0),1);//显⽰结果cvNamedWindow("show");cvNamedWindow("tem");cvShowImage("show",show);cvShowImage("tem" , templat);cvWaitKey(0);return 0;}2多匹配：code：#include <opencv\cv.h>#include <opencv\highgui.h>#include <opencv\cxcore.h>#include <stdlib.h>#include <stdio.h>/*模板匹配法 --图⽚查找滑动窗⼝的原理⽤等⼤⼩的模板窗⼝在范围中进⾏滑动然后查找匹配*/CvPoint getNextMinLoc(IplImage* result , int templatWidth,int templatHeight,double maxValIn , CvPoint lastLoc){ int y,x;int startY,startX,endY,endX;//计算⼤矩形的左上⾓坐标startY = lastLoc.y - templatHeight;startX = lastLoc.x - templatWidth;//计算⼤矩形的右下⾓的坐标⼤矩形的定义可以看视频的演⽰endY = lastLoc.y + templatHeight;endX = lastLoc.x + templatWidth;//不允许矩形越界startY = startY < 0 ? 0 : startY;startX = startX < 0 ? 0 : startX;endY = endY > result->height-1 ? result->height-1 : endY;endX = endX > result->width - 1 ? result->width - 1 : endX;//将⼤矩形内部赋值为最⼤值使得以后找的最⼩值不会位于该区域避免找到重叠的⽬标for(y=startY;y<endY;y++){for(x=startX;x<endX;x++){cvSetReal2D(result,y,x,maxValIn);}}double minVal,maxVal;CvPoint minLoc,maxLoc;//查找result中的最⼩值及其所在坐标cvMinMaxLoc(result,&minVal,&maxVal,&minLoc,&maxLoc,NULL);return minLoc;}int main(int argc, char* argv[]){IplImage*src,*templat,*result,*show;int srcW,templatW,srcH,templatH,resultW,resultH;//加载源图像src = cvLoadImage("C:\\Users\\zxl\\Desktop\\4.png" , CV_LOAD_IMAGE_GRAYSCALE);//加载⽤于显⽰结果的图像show = cvLoadImage("C:\\Users\\zxl\\Desktop\\4.png");//加载模板图像templat = cvLoadImage("C:\\Users\\zxl\\Desktop\\1.png" , CV_LOAD_IMAGE_GRAYSCALE);if(!src || !templat){printf("打开图⽚失败");return 0;}srcW = src->width;srcH = src->height;templatW = templat->width;templatH = templat->height;if(srcW<templatW || srcH<templatH){printf("模板不能⽐原图⼩");return 0;}//计算结果矩阵的宽度和⾼度resultW = srcW - templatW + 1;resultH = srcH - templatH + 1;//创建存放结果的空间result = cvCreateImage(cvSize(resultW,resultH),32,1);double minVal,maxVal;CvPoint minLoc,maxLoc;//进⾏模板匹配cvMatchTemplate(src,templat,result,CV_TM_SQDIFF);//第⼀次查找最⼩值即找到第⼀个最像的⽬标cvMinMaxLoc(result,&minVal,&maxVal,&minLoc,&maxLoc,NULL);//绘制第⼀个查找结果到图像上cvRectangle(show,minLoc,cvPoint(minLoc.x+templat->width,minLoc.y+templat->height),CV_RGB(0,255,0),1); //查找第⼆个结果minLoc = getNextMinLoc( result , templat->width,templat->height, maxVal , minLoc);//绘制第⼆个结果cvRectangle(show,minLoc,cvPoint(minLoc.x+templat->width,minLoc.y+templat->height),CV_RGB(0,255,0),1); //显⽰结果cvNamedWindow("show");cvShowImage("show",show);cvWaitKey(0);return 0;}。
opencv4学习17模板匹配算法
opencv4学习17模板匹配算法算法步骤：1. 加载原始图像2. 加载模板图像3. 使⽤模板图像作为滑动窗⼝与原始图像相应patch计算相似度。
#include <opencv2/imgcodecs.hpp>#include <opencv2/highgui.hpp>#include <opencv2/imgproc.hpp>#include <iostream>using namespace cv;using namespace std;bool use_mask = false;Mat img, templ, mask, result;const char* image_window = "Source Image";const char* result_window = "Result window";int match_method;int max_Trackbar = 5;void matchingMethod(int, void*){Mat img_display;img.copyTo(img_display);int result_cols = img.cols - templ.cols + 1;int result_rows = img.rows - templ.rows + 1;result.create(result_rows, result_cols, CV_32FC1);bool method_accepts_mask = (TM_SQDIFF == match_method || match_method == TM_CCORR_NORMED);if(use_mask && method_accepts_mask){matchTemplate(img, templ, result, match_method, mask);}else{matchTemplate(img, templ, result, match_method);}normalize(result, result, 0, 1, NORM_MINMAX, -1, Mat());double minVal, maxVal;Point minLoc, maxLoc;Point matchLoc;minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc, Mat());if(match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED){matchLoc = minLoc;}else{matchLoc = maxLoc;}rectangle(img_display, matchLoc, Point(matchLoc.x + templ.cols, matchLoc.y + templ.rows), Scalar::all(0), 2, 8, 0);rectangle(result, matchLoc, Point(matchLoc.x + templ.cols, matchLoc.y + templ.rows), Scalar::all(0), 2, 8, 0);imshow(image_window, img_display);imshow(result_window, result);return;}int main(int argc, char* argv[]){img = imread("./Template_Matching_Original_Image.jpg", IMREAD_COLOR);templ = imread("./Template_Matching_Template_Image.jpg", IMREAD_COLOR);if(use_mask) mask = imread("mask.jpg", IMREAD_COLOR);namedWindow(image_window, WINDOW_AUTOSIZE);namedWindow(result_window, WINDOW_AUTOSIZE);const char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF_NORMED \n 2: TM_CCORR \n 3: TM_CCORR_NORMED \n " "4: TM_COEFF \n 5: TM_COEFF_NORMED";createTrackbar(trackbar_label, image_window, &match_method, max_Trackbar, matchingMethod);matchingMethod(0,0);waitKey(0);return 0;}。
opencv单目标模板匹配（只适用于模板与目标尺度相同）
opencv单⽬标模板匹配（只适⽤于模板与⽬标尺度相同）#include <iostream>#include "opencv/cv.h"#include "opencv/cxcore.h"#include "opencv/highgui.h"using namespace std;#pragma comment ( lib,"opencv_highgui244.lib" )#pragma comment ( lib,"opencv_core244.lib" )#pragma comment ( lib,"opencv_imgproc244.lib" )int main(){IplImage *src = cvLoadImage("src.jpg", 0);IplImage *srcResult = cvLoadImage("src.jpg", 3); //⽤来显⽰IplImage *templat = cvLoadImage("template1.png", 0);IplImage *result;if(!src || !templat){cout << "打开图像失败"<< endl;return 0;}int srcW, srcH, templatW, templatH, resultH, resultW;srcW = src->width;srcH = src->height;templatW = templat->width;templatH = templat->height;if(srcW < templatW || srcH < templatH){cout <<"原图不能⽐模板⼩" << endl;return 0;}resultW = srcW - templatW + 1;resultH = srcH - templatH + 1;result = cvCreateImage(cvSize(resultW, resultH), 32, 1);//the 3rd parametercvMatchTemplate(src, templat, result, CV_TM_SQDIFF);double minValue, maxValue;CvPoint minLoc, maxLoc;cvMinMaxLoc(result, &minValue, &maxValue, &minLoc, &maxLoc);cvRectangle(srcResult, minLoc, cvPoint(minLoc.x + templatW, minLoc.y+ templatH), cvScalar(0,0,255));cvNamedWindow("srcResult", 0);cvNamedWindow("templat", 0);cvShowImage("srcResult", srcResult);cvShowImage("templat", templat);cvWaitKey(0);cvReleaseImage(&result);cvReleaseImage(&templat);cvReleaseImage(&srcResult);cvReleaseImage(&src);return 0;}。
opencv的模板匹配方法
opencv的模板匹配⽅法模板匹配在o p e n c v中进⾏模板匹配使⽤c v2.ma tc h T e mp l a te函数，简单使⽤如下：i m p o r t c v2i m p o r t n u m p y a s n pi m g=c v2.i m r e a d('l a n d s c a p e.j p g',c v2.I M R E A D_G R A Y S C A L E)t p l=c v2.i m r e a d('t e m p l a t e.j p g',c v2.I M R E A D_G R A Y S C A L E)r e s u l t=c v2.m a t c h T e m p l a t e(i m g,t p l,c v2.T M_C C O R R_N O R M E D)#返回的m a x_l o c是按照O p e n c v的坐标(x,y)，不是n u m p y的(r o w,c o l)(_,m a x_v a l,_,m a x_l o c)=c v2.m i n M a x L o c(r e s u l t)#利⽤最⼤值*0.99作为阈值，阈值可根据情况设置t h r e s h o l d=m a x_v a l* 0.99#l o c=[[r o w1,r o w2,r o w3...],[c o l1,c o l2,c o l3]]注意和o p e n c v的x y转换l o c=n p.w h e r e(r e s u l t>=t h r e s h o l d)t r=i m g.c o p y()f o r p t i n z i p(*l o c[::-1]):c v2.r e c t a n g l e(t r,p t,(p t[0]+t w,p t[1]+t h),(0,0,255),1)其中r e s u l t=c v2.m a t c h T e m p l a t e(i m g,t p l,c v2.T M_C C O R R_N O R M E D)假设l a n d s c a p e图⽚⼤⼩为5120x9760，读取进来的i mg矩阵⼤⼩为9760*5120，te mp l a te图⽚⼤⼩为366x533，读⼊tp l的⼤⼩为533x366。
OpenCV-Python实现多模板匹配
OpenCV-Python实现多模板匹配⽬录多模板匹配获取匹配位置的集合循环在循环中使⽤zip()替换坐标实战多模板匹配实例：基于opencv的多⽬标模板匹配模板匹配的作⽤在图像识别领域作⽤可⼤了。
那什么是模板匹配？模板匹配，就是在⼀幅图像中寻找另⼀幅模板图像最匹配（也就是最相似）的部分的技术。
多模板匹配在上⼀篇的实战中，我们通过⼈物眼睛的⼦图，找出了其在图像中出现位置。
但是，有些情况下，并不仅仅只有⼀次，⽐如我们讲解傅⾥叶变换时，曾介绍⼀张草原的狮⼦图。
如果匹配某个草，可能单个图像内会有很多，这个时候就要找出多个匹配结果。
⽽函数cv2.minMaxLoc()仅仅能找出最值，⽆法给出所有匹配区域的位置信息。
所以，要想匹配多个结果，就需要进⾏如下4个步骤：获取匹配位置的集合⾸先，Numpy库中的函数where()能够获取模板匹配位置的集合。
对于不同的输⼊，其返回值是不同的。
当输⼊是⼀维数组时，返回值是⼀维索引，只是⼀组索引数组。
当输⼊是⼆维数组时，返回的是匹配值的位置索引，因此会有两组索引数组表⽰返回值的位置。
⽐如，我们的灰度图像⼀般都是⼆维数组。
下⾯，我们来查找⼀个⼆维数组中，值⼤于8的元素索引：import numpy as npimg = np.array([[2, 4, 6, 8, 10], [9, 60, 10, 30, 4], [55, 21, 11, 7, 5]])result = np.where(img > 5)print(result)运⾏之后，控制台会输出如下内容：如果你对Numpy不是很了解的化。
下⾯博主在将数据转换以下，基本上都能看懂了。
转换之后，格式如下：第⼀⾏为⼤于5的值的X坐标，第⼆⾏为⼤于5的值的Y坐标。
那么上⾯⼤于5的数组索引为：[0,2]，[0,3]，[0,4]，[1,0]，[1,1]，[1,2]，[1,3]，[2,0]，[2,1]，[2,2]，[2,3]。
cv2的标准平方差模板匹配
cv2的标准平方差模板匹配OpenCV中的标准平方差模板匹配是一种用于在图像中寻找匹配模板的方法。
它通过计算模板与图像中每个位置的像素值之间的平方差来衡量匹配程度。
具体步骤如下：1. 导入OpenCV库：首先需要导入OpenCV库，使用以下代码：```pythonimport cv2```2. 读取图像和模板：使用`cv2.imread()`函数读取待匹配的图像和模板图像，例如：```pythonimage = cv2.imread('image.jpg')template = cv2.imread('template.jpg')```3. 执行模板匹配：使用`cv2.matchTemplate()`函数执行模板匹配，并指定匹配方法为`cv2.TM_SQDIFF`，例如：```pythonresult = cv2.matchTemplate(image, template, cv2.TM_SQDIFF)```4. 寻找最佳匹配位置：通过`cv2.minMaxLoc()`函数找到最佳匹配位置的坐标，例如：```pythonmin_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)best_match_loc = min_loc```这里的`best_match_loc`即为最佳匹配位置的坐标。
5. 绘制匹配结果：可以使用`cv2.rectangle()`函数在原始图像上绘制矩形框来标识匹配位置，例如：```pythonw, h = template.shape[:-1]cv2.rectangle(image, best_match_loc, (best_match_loc[0] + w,best_match_loc[1] + h), (0, 255, 0), 2)```这里的`(0, 255, 0)`表示矩形框的颜色，`2`表示矩形框的线宽。
点集模板匹配
点集模板匹配篇一：模板匹配opencv学习_11 (模板匹配(包括单模板和多模板))分类：Opencv学习笔记2013-11-08 21:167663人阅读评论(6)收藏举报模板匹配源码opencv模板匹配——在一幅图像中匹配与模板相似的单个或者多个目标(1)目标匹配函数：cvMatchT emplate( const CvArr* image, constCvArr* templ,CvArr* result,int method );Image 待搜索图像T empl 模板图像Result 匹配结果用来存放通过以下方法计算出滑动窗口与模板的相似值Method 计算匹配程度的方法关于匹配方法，使用不同的方法产生的结果的意义可能不太一样，有些返回的值越大表示匹配程度越好，而有些方法返回的值越小表示匹配程度越好关于参数method：CV_TM_SQDIFF平方差匹配法：该方法采用平方差来进行匹配；最好的匹配值为0；匹配越差，匹配值越大。
CV_TM_CCORR相关匹配法：该方法采用乘法操作；数值越大表明匹配程度越好。
CV_TM_CCOEFF相关系数匹配法：1表示完美的匹配；-1表示最差的匹配。
CV_TM_SQDIFF_NORMED归一化平方差匹配法CV_TM_CCORR_NORMED归一化相关匹配法CV_TM_CCOEFF_NORMED归一化相关系数匹配法(2)：接着就是要找最值以及最值对应的坐标cvMinMaxLoc()寻找一个矩阵中最大最小值以及相应的坐标cvMinMaxLoc( constCvArr* arr, double* min_val, double* max_val,CvPoint* min_locCV_DEFAULT(NULL),CvPoint* max_locCV_DEFAULT(NULL),const CvArr* mask CV_DEFAULT(NULL) );单目标匹配结果：代码：[cpp] view plaincopyprint?1. #include <iostream2. #include cv.h3. #include cxcore.h4. #include highgui.h5. using namespace std;6. int main()7. {8. IplImage *src =cvLoadImage(E:\\study_opencv_video\\lesson16_1\\images\\s rc.jpg, 0);9. IplImage *srcResult =cvLoadImage(E:\\study_opencv_video\\lesson16_1\\images\\s rc.jpg, 3); //用来显示10. IplImage *templat =cvLoadImage(E:\\study_opencv_video\\lesson16_1\\images\\t emplate.png, 0);11. IplImage *result;12. if(!src || !templat)13. {14. cout << 打开图像失败<< endl;15. return 0;16. }17. int srcW, srcH, templatW, templatH, resultH, resultW;18. srcW = src-width;19. srcH = src-height;20. templatW = templat-width;21. templatH = templat-height;22. if(srcW < templatW || srcH < templatH)23. {24. cout <<模板不能比原图像小<< endl;25. return 0;26. }27. resultW = srcW - templatW + 1;28. resultH = srcH - templatH + 1;29. result = cvCreateImage(cvSize(resultW, resultH), 32, 1);30. cvMatchT emplate(src, templat, result, CV_TM_SQDIFF);31. double minValue, maxValue;32. CvPoint minLoc, maxLoc;33. cvMinMaxLoc(result, &minValue, &maxValue, &minLoc, &maxLoc);34. cvRectangle(srcResult, minLoc, cvPoint(minLoc.x + templatW, minLoc.y+templatH), cvScalar(0,0,255));35. cvNamedWindow(srcResult, 0);36. cvNamedWindow(templat, 0);37. cvShowImage(srcResult, srcResult);38. cvShowImage(templat, templat);39. cvWaitKey(0);40. cvReleaseImage(&result);41. cvReleaseImage(&templat);42. cvReleaseImage(&srcResult);43. cvReleaseImage(&src);44. return 0;45. }(3)多目标匹配：结果：代码：[cpp] view plaincopyprint?1. #include <iostream2. #include cv.h3. #include cxcore.h4. #include highgui.h5. using namespace std;6.7. CvPoint getNextMinLoc(IplImage *result, CvPoint minLoc, int maxVaule, inttemplatW, int templatH)8. {9.10. // 先将第一个最小值点附近两倍模板宽度和高度的都设置为最大值防止产生干扰11. int startX = minLoc.x - templatW;12. int startY = minLoc.y - templatH;13. int endX = minLoc.x + templatW;14. int endY = minLoc.y + templatH;15. if(startX < 0 || startY < 0)16. {17. startX = 0;18. startY = 0;19. }20. if(endX result-width - 1 || endY result-height - 1)21. {22. endX = result-width - 1;23. endY = result-height - 1;24. }25. int y, x;26. for(y = startY; y < endY; y++)27. {28. for(x = startX; x < endX; x++)29. {30. cvSetReal2D(result, y, x, maxVaule);31. }32. }33. // 然后得到下一个最小值并且返回34. double new_minVaule, new_maxValue;35. CvPoint new_minLoc, new_maxLoc;36. cvMinMaxLoc(result, &new_minVaule, &new_maxValue, &new_minLoc,&new_maxLoc);37. return new_minLoc;38.39. }40. int main()41. {42. IplImage *src =cvLoadImage(E:\\study_opencv_video\\lesson16_1\\images\\s rc.jpg, 0);43. IplImage *srcResult =cvLoadImage(E:\\study_opencv_video\\lesson16_1\\images\\s rc.jpg, 3); //用来显示篇二：模板匹配方法总结很早就想总结一下前段时间学习HALCON的心得，但由于其他的事情总是抽不出时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
竭诚为您提供优质文档/双击可除opencv,模板匹配源码
篇一：opencv模板匹配
opencv模板匹配
V1.0
zhbrain
1、2、1）2）3、1）2）
opencv模板匹配原理--没有金字塔................................................. ..........................4模板匹配—使用金字塔................................................. ...............................................5主要函数简介................................................. ................................................... ........5程序流程.................................................
................................................... ................5验证和结果................................................. ................................................... ...............5实验环境................................................. ................................................... ................5实验结果................................................. ................................................... . (5)
opencv模板匹配
1、opencv模板匹配原理--没有金字塔
函数：
cvmatchtemplate(source,target,result,method);说明：source：源图像，一般我们使用灰度图像；如果source 为Rgb图像，使用函数cvcvtcolor(source,dst,cV_Rgb2gRay)这里，dst为转换后的灰度图像。
target：模板图像。
Result：匹配后的矩阵，width=s_width–t_taget+1，height=s_height–t_height+1使用函数
iplimage*result=cvcreateimage(resultsize,ipl_depth_ 32F,1)获得。
method:cV_tm_sqdiFF:
cV_tm_sqdiFF_noRmed
cV_tm_ccoRR
cV_tm_ccoRR_noRmed
cV_tm_ccoeFF
cV_tm_ccoeFF_noRmed
一般的，使用cV_tm_ccoRR_noRmed，存在的问题是没有使用去均值，可能对亮度变化比较敏感。
程序流程：读入模板和源图像建立result图像模板匹配使用cvminmaxloc找到最大（最小）值输出结果
2、模板匹配—使用金字塔
cvpyrdown(src，dst，filter)
src：源图像，尺寸为width×height
dst：经过一次下采样得到的图像，尺寸为width/2×height/2filter：卷积滤波器，目前仅支持cV_gaussian_5×5
cvsetimageRoi(image,rect)
image：源图像，经过这个函数后，图像大小变为rect （长方形）rect：（x，y，width，height）（x，y）为长方形的左上角坐标，width，height为长方形的宽和高。
1）主要函数简介
2）程序流程
读入模板和源图像cypyrdown（假设只有一次）得到源
图像和模板下采样图像设置这里的匹配result图像模板匹配使用cvminmaxloc找到最大值以这个最大值为中心（x1，y1），将源图像裁剪为width=w_template+7，
height=h_template+7图像，rect左上角坐标为
x2=x1-w_template/2-3y2=y1-h_template/2-3再次建立result1图像模板匹配使用cvminmaxloc找到最大值
3、验证和结果
corei52410mthinkpadx220主机ubuntu10.04–gcc
源图像大小360×360，模板大小140×140采用一级金字塔
验证方法：源图像s、模板t，分别采用加噪声和更改亮度
1）实验环境
2
模板匹配程序耗时约10ms。
篇二：模板匹配
opencv学习_11(模板匹配(包括单模板和多模板))
分类：opencv学习笔记20xx-11-0821:1676(opencv,模板匹配源码)63人阅读评论(6)收藏举报
模板匹配源码opencv
模板匹配——在一幅图像中匹配与模板相似的单个或
者多个目标
(1)目标匹配函数：
cvmatchtemplate(constcvarr*image,constcvarr*templ, cvarr*result,intmethod);
image待搜索图像
templ模板图像
Result匹配结果用来存放通过以下方法计算出滑动窗口与模板的相似值
method计算匹配程度的方法
关于匹配方法，使用不同的方法产生的结果的意义可能不太一样，有些返回的值越大表示匹配程度越好，而有些方法返回的值越小表示匹配程度越好
关于参数method：
cV_tm_sqdiFF平方差匹配法：该方法采用平方差来进行匹配；最好的匹配值为0；匹配越差，匹配值越大。
cV_tm_ccoRR相关匹配法：该方法采用乘法操作；数值越大表明匹配程度越好。
cV_tm_ccoeFF相关系数匹配法：1表示完美的匹配；-1表示最差的匹配。
cV_tm_sqdiFF_noRmed 归一化平方差匹配法
cV_tm_ccoRR_noRmed归一化相关匹配法
cV_tm_ccoeFF_noRmed归一化相关系数匹配法
(2)：接着就是要找最值以及最值对应的坐标。