目标

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

使用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种

方法=TM_SQDIFF

\[R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2\]
方法=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}}\]
方法=TM_CCORR

\[R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y'))\]
方法=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}}\]
方法=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}\]
方法=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种匹配方法中的任何一种。用户可以通过在轨迹条中选择来选择方法。如果提供了掩膜，它将仅用于支持掩膜的方法
- 标准化匹配过程的输出
- 定位匹配概率较高的位置
- 在最高匹配区域周围绘制一个矩形

可下载代码：点击此处
代码速览

#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| | 打印帮助信息. }"

"{ @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 );

return;

}

bool empty() const
如果数组没有元素，则返回 true。
int64_t int64

cv::Mat
n 维密集数组类
定义 mat.hpp:830

cv::Mat::copyTo
void copyTo(OutputArray m) const
将矩阵复制到另一个矩阵。

cv::Mat::create
void create(int rows, int cols, int type)
如果需要，分配新的数组数据。

cv::Mat::cols
int cols
定义 mat.hpp:2165

定义 interface.h:61
cv::getTickFrequency
double getTickFrequency()

cv::Mat::rows
int rows
行数和列数，如果矩阵维度超过2，则为(-1, -1)
定义 mat.hpp:2165

cv::Point_< int >

cv::Point_::y
_Tp y
点的 y 坐标
定义 types.hpp:202

cv::Point_::x
_Tp x
点的 x 坐标
定义 types.hpp:201

cv::normalize
void normalize(InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
对数组的范数或值范围进行归一化。

cv::minMaxLoc
void minMaxLoc(InputArray src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, InputArray mask=noArray())
查找数组中的全局最小值和最大值。

cv::String
std::string String
定义 cvstd.hpp:151

CV_32FC1
#define CV_32FC1
定义 interface.h:118

cv::imshow
void imshow(const String &winname, InputArray mat)
在指定窗口中显示图像。

cv::rectangle
void rectangle(InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
绘制一个简单、粗或填充的矩形。

cv::matchTemplate
void matchTemplate(InputArray image, InputArray templ, OutputArray result, int method, InputArray mask=noArray())
将模板与重叠图像区域进行比较。

highgui.hpp

main
int main(int argc, char *argv[])
定义 highgui_qt.cpp:3

imgcodecs.hpp

imgproc.hpp

cv
定义 core.hpp:107

std
STL 命名空间。

可下载代码：点击此处
代码速览
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("Not enough parameters");

System.out.println("Program arguments:\n<image_name> <template_name> [<mask_name>]");

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("Can't read one of the images");

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

Point matchLoc;

Core.MinMaxLocResult mmr = Core.minMaxLoc(result);

if (match_method == Imgproc.TM_SQDIFF || match_method == Imgproc.TM_SQDIFF_NORMED) {

matchLoc = mmr.minLoc;

} else {

matchLoc = mmr.maxLoc;

}

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 = new ImageIcon(tmpImg);

imgDisplay.setIcon(icon);

result.convertTo(result, CvType.CV_8UC1, 255.0);

tmpImg = HighGui.toBufferedImage(result);

icon = new ImageIcon(tmpImg);

resultDisplay.setIcon(icon);

}

@Override

public void stateChanged(ChangeEvent e) {

JSlider source = (JSlider) e.getSource();

if (!source.getValueIsAdjusting()) {

match_method = source.getValue();

matchingMethod();

}

}

private void createJFrame() {

String title = "Source image; Control; Result image";

JFrame frame = new JFrame(title);

frame.setLayout(new GridLayout(2, 2));

frame.add(imgDisplay);

int min = 0, max = 5;

JSlider slider = new JSlider(JSlider.VERTICAL, min, max, match_method);

slider.setPaintTicks(true);

slider.setPaintLabels(true);

// Set the spacing for the minor tick mark

slider.setMinorTickSpacing(1);

// Customizing the labels

Hashtable<Integer, JLabel> labelTable = new Hashtable<>();

labelTable.put(new Integer(0), new JLabel("0 - SQDIFF"));

labelTable.put(new Integer(1), new JLabel("1 - SQDIFF NORMED"));

labelTable.put(new Integer(2), new JLabel("2 - TM CCORR"));

labelTable.put(new Integer(3), new JLabel("3 - TM CCORR NORMED"));

labelTable.put(new Integer(4), new JLabel("4 - TM COEFF"));

labelTable.put(new Integer(5), new JLabel("5 - TM COEFF NORMED : (Method)"));

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

// load the native OpenCV library

System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

// run code

new MatchTemplateDemoRun().run(args);

}

}

typedef Point_< double >
Point2i Point
Definition types.hpp:209

cv::Scalar
Scalar_< double > Scalar
定义 types.hpp:709

可下载代码：点击此处
代码速览
from __future__ import print_function

import sys

import cv2 as cv

use_mask = False

img = None

templ = None

mask = None

image_window = "Source Image"

result_window = "Result window"

match_method = 0

max_Trackbar = 5

def main(argv)

if (len(sys.argv) < 3)

print('Not enough parameters')

print('Usage:\nmatch_template_demo.py <image_name> <template_name> [<mask_name>]')

return -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('Can\'t read one of the images')

return -1

cv.namedWindow( image_window, cv.WINDOW_AUTOSIZE )

cv.namedWindow( result_window, cv.WINDOW_AUTOSIZE )

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'

cv.createTrackbar( trackbar_label, image_window, match_method, max_Trackbar, MatchingMethod )

MatchingMethod(match_method)

cv.waitKey(0)

return 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[1], matchLoc[1] + templ.shape[0]), (0,0,0), 2, 8, 0 )

cv.rectangle(result, matchLoc, (matchLoc[0] + templ.shape[1], matchLoc[1] + templ.shape[0]), (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:])

cv::waitKey
int waitKey(int delay=0)
等待按键按下。

cv::namedWindow
void namedWindow(const String &winname, int flags=WINDOW_AUTOSIZE)
创建窗口。

cv::createTrackbar
int createTrackbar(const String &trackbarname, const String &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0)
创建滑动条并将其附加到指定窗口。

cv::imread
CV_EXPORTS_W Mat imread(const String &filename, int flags=IMREAD_COLOR_BGR)
从文件加载图像。

解释

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

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 = "Source Image"

result_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('Can\'t read one of the images')

return -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 slider = new JSlider(JSlider.VERTICAL, min, max, match_method);

Python

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'

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 和匹配方法（由轨迹条给出），以及可选的掩膜图像 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

Point matchLoc;

Core.MinMaxLocResult mmr = Core.minMaxLoc(result);

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

if (match_method == Imgproc.TM_SQDIFF || match_method == 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 = new ImageIcon(tmpImg);

imgDisplay.setIcon(icon);

result.convertTo(result, CvType.CV_8UC1, 255.0);

tmpImg = HighGui.toBufferedImage(result);

icon = new ImageIcon(tmpImg);

resultDisplay.setIcon(icon);

Python

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

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

cv.imshow(image_window, img_display)

cv.imshow(result_window, result)