模板匹配

内容表

• 目标
• 理论
  • 什么是模板匹配？
  • 它如何工作？
  • 掩码如何工作？
  • 在 OpenCV 中可用的匹配方法有哪些？
• 代码
• 解释
• 结果

上一个教程： 反向投影
下一个教程： 在图像中寻找轮廓

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

目标

在本教程中，您将学习如何

• 使用 OpenCV 函数 matchTemplate() 来在图像块和输入图像之间搜索匹配
• 使用 OpenCV 函数 minMaxLoc() 来查找给定数组中的最大值和最小值（以及它们的位置）。

理论

什么是模板匹配？

模板匹配是一种技术，用于查找与模板图像（块）匹配（相似）的图像区域。

虽然块必须是一个矩形，但矩形可能并不总是相关的。对于这种情况，可以使用掩码来隔离应用于查找匹配的块部分。

它如何工作？

• 我们需要两个主要组件

  1. 原图像 (I)： 预期会找到与模板图像匹配的图像
  2. 模板图像 (T)： 将与原图像进行比较的块图像

  我们的目标是检测最高匹配区域

• 要识别匹配区域，我们必须通过滑动将其与原图像进行比较

• 滑动指一次一个像素地移动块（从左到右、从上到下）。在每个位置，计算一个度量，它表示在该位置匹配的“好”还是“坏”（即块与原图像的特定区域有多相似）。
• 对于T在I上的每个位置，将度量存储在结果矩阵R中。R中每个位置\((x,y)\)都包括匹配度量

上图是使用度量TM_CCORR_NORMED滑动块所得的R结果。最亮的位置表示最高匹配。正如您所见，标记为红色圆圈的位置可能是值最高的位置，因此该位置（以该点为角，且宽度和高度均等于块图像所形成的矩形）被认为是匹配。

• 实际上，我们使用函数 minMaxLoc() 在 R 矩阵中找到最高值（或最低值，取决于匹配方法的类型）。

遮掩的工作原理是什么？

• 如果匹配需要遮掩，需要三个组件
  1. 原图像 (I)： 预期会找到与模板图像匹配的图像
  2. 模板图像 (T)： 将与原图像进行比较的块图像
  3. 遮掩图像（M）：遮掩，一个遮掩模板的灰度图像
• 目前只有两种匹配方法接受遮掩：TM_SQDIFF 和 TM_CCORR_NORMED（请参阅下文以了解 opencv 中可用的所有匹配方法的解释）。
• 遮掩的尺寸必须与模板相同
• 遮掩应该具有 CV_8U 或 CV_32F 深度，并且其通道数与模板图像相同。在 CV_8U 情况下，遮掩值被视为二进制，即零和非零。在 CV_32F 情况下，值应在 [0..1] 范围内，模板像素将乘以相应的遮掩像素值。由于样本中的输入图像为 CV_8UC3 类型，因此遮掩也被读取为彩色图像。

OpenCV 中有哪些匹配方法？

好问题。OpenCV 在函数 matchTemplate() 中实现了模板匹配。共有 6 种可用方法

1. method=TM_SQDIFF

   \[R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2\]

2. method=TM_SQDIFF_NORMED

   \[R(x,y)= \frac{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\]

3. method=TM_CCORR

   \[R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y'))\]

4. method=TM_CCORR_NORMED

   \[R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y'))}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\]

5. method=TM_CCOEFF

   \[R(x,y)= \sum _{x',y'} (T'(x',y') \cdot I'(x+x',y+y'))\]

   其中

   \[\begin{array}{l} T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum _{x'',y''} T(x'',y'') \\ I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h) \cdot \sum _{x'',y''} I(x+x'',y+y'') \end{array}\]

6. method=TM_CCOEFF_NORMED

   \[R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }\]

代码

• 此程序的功能是什么？
  • 加载输入图像、图像补丁（模板）和可选的遮掩
  • 使用 OpenCV 函数 matchTemplate() 结合上述 6 种任意一种匹配方法进行模板匹配过程。用户可以通过在轨迹条中输入其选择来选择方法。如果提供了遮掩，它将仅用于支持遮掩的方法
  • 对匹配过程的输出进行归一化
  • 定位匹配概率较高的位置
  • 在对应于最高匹配的区域周围绘制一个矩形

C++

• 可下载的代码：点击 此处
• 一目了然的代码

   
  #include "opencv2/imgcodecs.hpp"
  #include "opencv2/highgui.hpp"
  #include "opencv2/imgproc.hpp"
  #include <iostream>
   
  using namespace std;
  using namespace cv;
   
  bool use_mask;
  Mat img; Mat templ; Mat mask; Mat result;
  const char* image_window = "Source Image";
  const char* result_window = "Result window";
   
  int match_method;
  int max_Trackbar = 5;
   
  void MatchingMethod( int, void* );
   
  const char* keys =
  "{ help h| | Print help message. }"
  "{ @input1 | Template_Matching_Original_Image.jpg | image_name }"
  "{ @input2 | Template_Matching_Template_Image.jpg | template_name }"
  "{ @input3 | | mask_name }";
   
  int main( int argc, char** argv )
  {
    CommandLineParser parser( argc, argv, keys );
  samples::addSamplesDataSearchSubDirectory( "doc/tutorials/imgproc/histograms/template_matching/images" );
   
  img = imread( samples::findFile( parser.get<String>("@input1") ) );
  templ = imread( samples::findFile( parser.get<String>("@input2") ), IMREAD_COLOR );
   
    if(argc > 3) {
  use_mask = true;
  mask = imread(samples::findFile( parser.get<String>("@input3") ), IMREAD_COLOR );
    }
   
    if(img.empty() || templ.empty() || (use_mask && mask.empty()))
    {
  cout << "Can't read one of the images" << endl;
      return EXIT_FAILURE;
    }
   
  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 EXIT_SUCCESS;
  }
   
  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; double maxVal; Point minLoc; Point 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 );
   
    返回;
  }

Java

• 可下载代码：点击这里
• 一目了然的代码

  import java.awt.GridLayout;
  import java.awt.Image;
  import java.util.Hashtable;
   
  import javax.swing.ImageIcon;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JSlider;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
   
  import org.opencv.core.Core;
  import org.opencv.core.CvType;
  import org.opencv.core.Mat;
  import org.opencv.core.Point;
  import org.opencv.core.Scalar;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgcodecs.Imgcodecs;
  import org.opencv.imgproc.Imgproc;
   
  class MatchTemplateDemoRun implements ChangeListener {
   
  Boolean use_mask = false;
  Mat img = new Mat(), templ = new Mat();
  Mat mask = new Mat();
   
      int match_method;
   
  JLabel imgDisplay = new JLabel(), resultDisplay = new JLabel();
   
      public void run(String[] args) {
          if (args.length < 2) {
  System.out.println("参数不够");
  System.out.println("程序参数：\n<图像名称> <模板名称> [<蒙版名称>]");
  System.exit(-1);
          }
   
  img = Imgcodecs.imread(args[0], Imgcodecs.IMREAD_COLOR);
  templ = Imgcodecs.imread(args[1], Imgcodecs.IMREAD_COLOR);
   
          if (args.length > 2) {
  use_mask = true;
  mask = Imgcodecs.imread(args[2], Imgcodecs.IMREAD_COLOR);
          }
   
          if (img.empty() || templ.empty() || (use_mask && mask.empty())) {
  System.out.println("无法读取其中一张图片");
  System.exit(-1);
          }
   
  matchingMethod();
  createJFrame();
      }
   
      private void matchingMethod() {
  Mat result = new Mat();
   
  Mat img_display = new Mat();
  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, CvType.CV_32FC1);
   
  Boolean method_accepts_mask = (Imgproc.TM_SQDIFF == match_method || match_method == Imgproc.TM_CCORR_NORMED);
          if (use_mask && method_accepts_mask) {
  Imgproc.matchTemplate(img, templ, result, match_method, mask);
  } else {
  Imgproc.matchTemplate(img, templ, result, match_method);
          }
   
  Core.normalize(result, result, 0, 1, Core.NORM_MINMAX, -1, new Mat());
   
          点matchLoc;
   
  Core.MinMaxLocResult mmr = Core.minMaxLoc(结果);
   
          如果（match _方法== Imgproc.TM_SQDIFF || match _方法== Imgproc.TM_SQDIFF_NORMED）{
  matchLoc = mmr.minLoc；
  } else {
  matchLoc = mmr.maxLoc;
          }
   
  Imgproc.rectangle(img_display, matchLoc，新的点（matchLoc.x + templ.cols()，matchLoc.y + templ.rows()），
                  新的 标量(0, 0, 0), 2, 8, 0)；
  Imgproc.rectangle(result, matchLoc, 新的 点(matchLoc.x + templ.cols(), matchLoc.y + templ.rows()),
                  新的 标量(0, 0, 0), 2, 8, 0)；
   
  Image tmpImg = HighGui.toBufferedImage(img_display)；
  ImageIcon icon = 新的 ImageIcon(tmpImg)；
  imgDisplay.setIcon(icon)；
   
  结果转换成(结果，CvType.CV_8UC1，255.0)；
  tmpImg = HighGui.toBufferedImage(结果)；
  icon = 新的 ImageIcon(tmpImg)；
  resultDisplay.setIcon(icon)；
      }
   
  @Override
      公共 无效状态变化(变更事件 e) {
  JSlider 源=（JSlider）e.getSource()；
          如果（！source.getValueIsAdjusting()）{
  match _方法= 来源.getValue()；
  matchingMethod();
          }
      }
   
      私有的 无效创建JFrame() {
          字符串标题= "源图像；控制；结果图像"；
  JFrame 框架= 新的 JFrame(标题)；
  框架.setLayout(新的网格布局(2, 2))；
  框架.添加(imgDisplay)；
   
          整数 min = 0, max = 5；
  JSlider 滑块= 新的 JSlider(JSlider.VERTICAL, min, max, match _方法)；
   
  滑块.setPaintTicks(真)；
  滑块.setPaintLabels(真)；
   
          // 设置次要刻度的间距
  滑块.setMinorTickSpacing(1)；
   
          // 自定义标签
  哈希表<整数，JLabel> 标签 表= 新的 哈希 表<>()；
  标签表.put(新的 Integer(0)，新的 JLabel("0 - SQDIFF"))；
  标签表.put(新的 Integer(1)，新的 JLabel("1 - SQDIFF NORMED"))；
  标签表.put(新的 Integer(2)，新的 JLabel("2 - TM CCORR"))；
  标签表.put(新的 Integer(3)，新的 JLabel("3 - TM CCORR NORMED"))；
  标签表.put(新的 Integer(4)，新的 JLabel("4 - TM COEFF"))；
  labelTable.put(new Integer(5), new JLabel("5 - TM COEFF NORMED : (方法)"));
  slider.setLabelTable(labelTable);
   
  slider.addChangeListener(this);
   
  frame.add(slider);
   
  frame.add(resultDisplay);
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  frame.pack();
  frame.setVisible(true);
      }
  }
   
  public class MatchTemplateDemo {
      public static void main(String[] args) {
          // 加载本机 OpenCV 库
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
          // 运行代码
          new MatchTemplateDemoRun().run(args);
      }
  }

Python

• 可下载的代码：点击 这里
• 一目了然的代码

  from __future__ import print_function
  import sys
  import cv2 as cv
   
   
  use_mask = False
  img = None
  templ = None
  mask = None
  image_window = "源图像"
  result_window = "结果窗口"
   
  match_method = 0
  max_Trackbar = 5
   
   
  def main(argv)
   
      if (len(sys.argv) < 3)
  print('参数不够')
  print('用法：\\nmatch_template_demo.py <image_name> <template_name> [<mask_name>]')
          返回 -1
   
      
      global img
      global templ
  img = cv.imread(sys.argv[1], cv.IMREAD_COLOR)
  templ = cv.imread(sys.argv[2], cv.IMREAD_COLOR)
   
      if (len(sys.argv) > 3)
          global use_mask
  use_mask = True
          global mask
  mask = cv.imread( sys.argv[3], cv.IMREAD_COLOR )
   
      if ((img is None) or (templ is None) or (use_mask and (mask is None)))
  print('图片不可读')
          返回 -1
      
   
      
      cv.namedWindow( image_window, cv.WINDOW_AUTOSIZE )
      cv.namedWindow( result_window, cv.WINDOW_AUTOSIZE )
      
   
      
  trackbar_label = '方法: \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'
      cv.createTrackbar( trackbar_label, image_window, match_method, max_Trackbar, MatchingMethod )
      
   
  MatchingMethod(match_method)
   
      
      cv.waitKey(0)
      返回 0
      
   
  def MatchingMethod(param)
   
      global match_method
  match_method = param
   
      
  img_display = img.copy()
      
  method_accepts_mask = (cv.TM_SQDIFF == match_method or match_method == cv.TM_CCORR_NORMED)
      if (use_mask and method_accepts_mask)
  result = cv.matchTemplate(img, templ, match_method, None, mask)
      else:
  result = cv.matchTemplate(img, templ, match_method)
      
   
      
      cv.normalize( result, result, 0, 1, cv.NORM_MINMAX, -1 )
      
  _minVal, _maxVal, minLoc, maxLoc = cv.minMaxLoc(result, None)
      
   
      
      if (match_method == cv.TM_SQDIFF or match_method == cv.TM_SQDIFF_NORMED)
  matchLoc = minLoc
      else:
  matchLoc = maxLoc
      
   
      
      cv.rectangle(img_display, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
      cv.rectangle(result, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
      cv.imshow(image_window, img_display)
      cv.imshow(result_window, result)
      
      pass
   
  if __name__ == "__main__"
      main(sys.argv[1:])

说明

• 声明一些全局变量，比如图像、模板和结果矩阵，以及匹配方法和窗口名称

  C++

   
  bool use_mask;
  Mat img; Mat templ; Mat mask; Mat result;
  const char* image_window = "Source Image";
  const char* result_window = "Result window";
   
  int match_method;
  int max_Trackbar = 5;

  Java

   
  Boolean use_mask = false;
  Mat img = new Mat(), templ = new Mat();
  Mat mask = new Mat();
   
      int match_method;
   
  JLabel imgDisplay = new JLabel(), resultDisplay = new JLabel();

  Python

  use_mask = False
  img = None
  templ = None
  mask = None
  image_window = "源图像"
  result_window = "结果窗口"
   
  match_method = 0
  max_Trackbar = 5

• 加载源图像、模板，以及选择性地加载掩模（如果匹配方法支持）

  C++

   
  img = imread( samples::findFile( parser.get<String>("@input1") ) );
  templ = imread( samples::findFile( parser.get<String>("@input2") ), IMREAD_COLOR );
   
    if(argc > 3) {
  use_mask = true;
  mask = imread(samples::findFile( parser.get<String>("@input3") ), IMREAD_COLOR );
    }
   
    if(img.empty() || templ.empty() || (use_mask && mask.empty()))
    {
  cout << "Can't read one of the images" << endl;
      return EXIT_FAILURE;
    }

  Java

   
  img = Imgcodecs.imread(args[0], Imgcodecs.IMREAD_COLOR);
  templ = Imgcodecs.imread(args[1], Imgcodecs.IMREAD_COLOR);

  Python

      global img
      global templ
  img = cv.imread(sys.argv[1], cv.IMREAD_COLOR)
  templ = cv.imread(sys.argv[2], cv.IMREAD_COLOR)
   
      if (len(sys.argv) > 3)
          global use_mask
  use_mask = True
          global mask
  mask = cv.imread( sys.argv[3], cv.IMREAD_COLOR )
   
      if ((img is None) or (templ is None) or (use_mask and (mask is None)))
  print('图片不可读')
          返回 -1

• 创建轨道栏以输入要使用的匹配方法类型。当检测到更改时，会调用回调函数。

  C++

   
    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 );

  Java

          int min = 0, max = 5;
  JSlider 滑块= 新的 JSlider(JSlider.VERTICAL, min, max, match _方法)；

  Python

  trackbar_label = '方法: \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'
      cv.createTrackbar( trackbar_label, image_window, match_method, max_Trackbar, MatchingMethod )

• 让我们检查一下回调函数。首先，它复制一份源图像

  C++

   
    Mat img_display;
  img.copyTo( img_display );

  Java

   
  Mat img_display = new Mat();
  img.copyTo(img_display);

  Python

  img_display = img.copy()

• 执行模板匹配操作。参数自然地是输入图像I、模板T、结果R和match_method（由轨道栏给出），以及选择性地输入掩模图像M。

  C++

   
    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); }

  Java

   
  Boolean method_accepts_mask = (Imgproc.TM_SQDIFF == match_method || match_method == Imgproc.TM_CCORR_NORMED);
          if (use_mask && method_accepts_mask) {
  Imgproc.matchTemplate(img, templ, result, match_method, mask);
  } else {
  Imgproc.matchTemplate(img, templ, result, match_method);
          }

  Python

  method_accepts_mask = (cv.TM_SQDIFF == match_method or match_method == cv.TM_CCORR_NORMED)
      if (use_mask and method_accepts_mask)
  result = cv.matchTemplate(img, templ, match_method, None, mask)
      else:
  result = cv.matchTemplate(img, templ, match_method)

• 我们对结果进行归一化

  C++

  normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );

  Java

  Core.normalize(result, result, 0, 1, Core.NORM_MINMAX, -1, new Mat());

  Python

      cv.normalize( result, result, 0, 1, cv.NORM_MINMAX, -1 )

• 我们通过使用minMaxLoc()定位结果矩阵R中的最小值和最大值。

  C++

   
    double minVal; double maxVal; Point minLoc; Point maxLoc;
    Point matchLoc;
   
  minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );

  Java

   
  点 matchLoc;
   
  Core.MinMaxLocResult mmr = Core.minMaxLoc(结果);

  Python

  _minVal, _maxVal, minLoc, maxLoc = cv.minMaxLoc(result, None)

• 对于前两种方法（ TM_SQDIFF 和 MT_SQDIFF_NORMED ）最佳匹配是最低值。对于所有其他方法，更高的值代表更好的匹配。因此，我们将相应的数值保存在matchLoc变量中

  C++

   
    if( match_method == TM_SQDIFF || match_method == TM_SQDIFF_NORMED )
  { matchLoc = minLoc; }
    else
  { matchLoc = maxLoc; }

  Java

   
          如果（match _方法== Imgproc.TM_SQDIFF || match _方法== Imgproc.TM_SQDIFF_NORMED）{
  matchLoc = mmr.minLoc；
  } else {
  matchLoc = mmr.maxLoc;
          }

  Python

      if (match_method == cv.TM_SQDIFF or match_method == cv.TM_SQDIFF_NORMED)
  matchLoc = minLoc
      else:
  matchLoc = maxLoc

• 显示源图像和结果矩阵。绘制一个矩形框覆盖最高可能的匹配区域

  C++

   
  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 );

  Java

   
  Imgproc.rectangle(img_display, matchLoc, new Point(matchLoc.x + templ.cols(), matchLoc.y + templ.rows()),
                  new Scalar(0, 0, 0), 2, 8, 0);
  Imgproc.rectangle(result, matchLoc, new Point(matchLoc.x + templ.cols(), matchLoc.y + templ.rows()),
                  new Scalar(0, 0, 0), 2, 8, 0);
   
  Image tmpImg = HighGui.toBufferedImage(img_display)；
  ImageIcon icon = 新的 ImageIcon(tmpImg)；
  imgDisplay.setIcon(icon)；
   
  结果转换成(结果，CvType.CV_8UC1，255.0)；
  tmpImg = HighGui.toBufferedImage(结果)；
  icon = 新的 ImageIcon(tmpImg)；
  resultDisplay.setIcon(icon)；

  Python

      cv.rectangle(img_display, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
      cv.rectangle(result, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
      cv.imshow(image_window, img_display)
      cv.imshow(result_window, result)

结果

1. 用一张这样的输入图像测试我们的程序

和一张模板图

1. 生成以下结果矩阵（第一行是标准方法 SQDIFF、CCORR 和 CCOEFF，第二行是这些方法的归一化版本）。在第一列中，深色表示匹配度越高，对于其他两列，越亮的区域表示匹配度越高。
2. 正确的匹配如下所示（右边的方框围绕着右边的这个人的面部）。请注意，CCORR 和 CCDEFF 给出了错误的最佳匹配，然而它们的归一化版本给出了正确的匹配，这可能是由于我们仅考虑“最高匹配”而不是其他可能的匹配所致。