基于NCC模板匹配识别

最新推荐文章于 2024-07-30 17:34:01 发布
最新推荐文章于 2024-07-30 17:34:01 发布
阅读量3.1k 收藏 7
点赞数
分类专栏： 图像处理+opencv


一：基本原理

NCC是一种基于统计学计算两组样本数据相关性的算法，其取值范围为[-1, 1]之间，而对图像来说，每个像素点都可以看出是RGB数值，这样整幅图像就可以看成是一个样本数据的集合，如果它有一个子集与另外一个样本数据相互匹配则它的ncc值为1，表示相关性很高，如果是-1则表示完全不相关，基于这个原理，实现图像基于模板匹配识别算法，其中第一步就是要归一化数据，数学公式如下：


二：实现步骤

（1）      获取模板像素并计算均值与标准方差、像素与均值diff数据样本

（2）      根据模板大小，在目标图像上从左到右，从上到下移动窗口，计

算每移动一个像素之后窗口内像素与模板像素的ncc值，与阈值比较，大于

阈值则记录位置

（3）      根据得到位置信息，使用红色矩形标记出模板匹配识别结果。

（4）      UI显示结果

 

三：编程实现

基于JAVA语言完成了整个算法编程实现与演示，其中第一步的代码如下：

[java] view plain copy print ?
  1. int tw = template.getWidth();  
  2. int th = template.getHeight();  
  3. int[] tpixels = new int[tw * th];  
  4. getRGB(template, 0, 0, tw, th, tpixels);  
  5. for(int i=0; i<tpixels.length; i++)  
  6. {  
  7.     tpixels[i] = (tpixels[i] >> 16) & 0xff;  
  8. }  
  9. double[] meansdev = getPixelsMeansAndDev(tpixels);  
  10. double[] tDiff = calculateDiff(tpixels, meansdev[0]);  
  11. int raidus_width = tw / 2;  
  12. int raidus_height = th / 2;  
		int tw = template.getWidth();
		int th = template.getHeight();
		int[] tpixels = new int[tw * th];
		getRGB(template, 0, 0, tw, th, tpixels);
		for(int i=0; i<tpixels.length; i++)
		{
			tpixels[i] = (tpixels[i] >> 16) & 0xff;
		}
		double[] meansdev = getPixelsMeansAndDev(tpixels);
		double[] tDiff = calculateDiff(tpixels, meansdev[0]);
		int raidus_width = tw / 2;
		int raidus_height = th / 2;

第二步的实现代码如下：

[java] view plain copy print ?
  1. int[] windowPixels = new int[tw * th];  
  2. Arrays.fill(windowPixels, 0);  
  3. for (int row = 0; row < height; row++) {  
  4.     for (int col = 0; col < width; col++) {  
  5.         // calculate the means and dev for each window  
  6.         if(row <  raidus_height || (row + raidus_height) >= height)  
  7.             continue;  
  8.         if(col < raidus_width || (col + raidus_width) >= width)   
  9.             continue;  
  10.         int wrow = 0;  
  11.         Arrays.fill(windowPixels, 0);  
  12.         for(int subrow = -raidus_height; subrow <= raidus_height; subrow++ )  
  13.         {  
  14.             int wcol = 0;  
  15.             for(int subcol = -raidus_width; subcol <= raidus_width; subcol++ )  
  16.             {  
  17.                 if(wrow >= th || wcol >= tw)  
  18.                 {  
  19.                     continue;  
  20.                 }  
  21.                 windowPixels[wrow * tw + wcol] = getPixelValue(width, col + subcol, row + subrow, inPixels);  
  22.                 wcol++;  
  23.             }  
  24.             wrow++;  
  25.         }  
  26.         // calculate the ncc  
  27.         double[] _meansDev = getPixelsMeansAndDev(windowPixels);  
  28.         double[] diff = calculateDiff(windowPixels, _meansDev[0]);  
  29.         double ncc = calculateNcc(tDiff, diff, _meansDev[1], meansdev[1]);  
  30.         if(ncc > threhold) {  
  31.             Point mpoint = new Point();  
  32.             mpoint.x = col;  
  33.             mpoint.y  = row;  
  34.             points.add(mpoint);  
  35.         }  
  36.     }  
  37. }  
		int[] windowPixels = new int[tw * th];
		Arrays.fill(windowPixels, 0);
		for (int row = 0; row < height; row++) {
			for (int col = 0; col < width; col++) {
				// calculate the means and dev for each window
				if(row <  raidus_height || (row + raidus_height) >= height)
					continue;
				if(col < raidus_width || (col + raidus_width) >= width) 
					continue;
				int wrow = 0;
				Arrays.fill(windowPixels, 0);
				for(int subrow = -raidus_height; subrow <= raidus_height; subrow++ )
				{
					int wcol = 0;
					for(int subcol = -raidus_width; subcol <= raidus_width; subcol++ )
					{
						if(wrow >= th || wcol >= tw)
						{
							continue;
						}
						windowPixels[wrow * tw + wcol] = getPixelValue(width, col + subcol, row + subrow, inPixels);
						wcol++;
					}
					wrow++;
				}
				// calculate the ncc
				double[] _meansDev = getPixelsMeansAndDev(windowPixels);
				double[] diff = calculateDiff(windowPixels, _meansDev[0]);
				double ncc = calculateNcc(tDiff, diff, _meansDev[1], meansdev[1]);
				if(ncc > threhold) {
					Point mpoint = new Point();
					mpoint.x = col;
					mpoint.y  = row;
					points.add(mpoint);
				}
			}
		}

第三步的实现代码如下：

[java] view plain copy print ?
  1. // draw matched template on target image according position  
  2. setRGB( dest, 0, 0, width, height, inPixels );  
  3. Graphics2D g2d = dest.createGraphics();  
  4. g2d.setPaint(Color.RED);  
  5. g2d.setStroke(new BasicStroke(4));  
  6. for(Point p : points)  
  7. {  
  8.     g2d.drawRect(p.x - raidus_width, p.y - raidus_height, tw, th);  
  9. }  
		// draw matched template on target image according position
		setRGB( dest, 0, 0, width, height, inPixels );
		Graphics2D g2d = dest.createGraphics();
		g2d.setPaint(Color.RED);
		g2d.setStroke(new BasicStroke(4));
		for(Point p : points)
		{
			g2d.drawRect(p.x - raidus_width, p.y - raidus_height, tw, th);
		}

其中第二步用到的计算NCC的方法实现如下：

[java] view plain copy print ?
  1. private double calculateNcc(double[] tDiff, double[] diff, double dev1, double dev2) {  
  2.     // TODO Auto-generated method stub  
  3.     double sum = 0.0d;  
  4.     double count = diff.length;  
  5.     for(int i=0; i<diff.length; i++)  
  6.     {  
  7.         sum += ((tDiff[i] * diff[i])/(dev1 * dev2));  
  8.     }  
  9.     return (sum / count);  
  10. }  
	private double calculateNcc(double[] tDiff, double[] diff, double dev1, double dev2) {
		// TODO Auto-generated method stub
		double sum = 0.0d;
		double count = diff.length;
		for(int i=0; i<diff.length; i++)
		{
			sum += ((tDiff[i] * diff[i])/(dev1 * dev2));
		}
		return (sum / count);
	}

UI部分完整源代码如下：

[java] view plain copy print ?
  1. package com.gloomyfish.image.templae.match;  
  2.   
  3. import java.awt.BorderLayout;  
  4. import java.awt.FlowLayout;  
  5. import java.awt.Graphics;  
  6. import java.awt.Graphics2D;  
  7. import java.awt.event.ActionEvent;  
  8. import java.awt.event.ActionListener;  
  9. import java.awt.image.BufferedImage;  
  10. import java.io.IOException;  
  11.   
  12. import javax.imageio.ImageIO;  
  13. import javax.swing.JButton;  
  14. import javax.swing.JComponent;  
  15. import javax.swing.JFrame;  
  16. import javax.swing.JPanel;  
  17.   
  18. public class DemoUI extends JComponent {  
  19.       
  20.     /** 
  21.      *  
  22.      */  
  23.     private static final long serialVersionUID = 1L;  
  24.     private BufferedImage targetImage;  
  25.     private BufferedImage template;  
  26.       
  27.     public DemoUI()  
  28.     {  
  29.         super();  
  30.         java.net.URL imageURL = this.getClass().getResource("words.png");  
  31.         java.net.URL templateURL = this.getClass().getResource("template.png");  
  32.           
  33.         try {  
  34.             template = ImageIO.read(templateURL);  
  35.             targetImage = ImageIO.read(imageURL);  
  36.         } catch (IOException e) {  
  37.             e.printStackTrace();  
  38.         }  
  39.     }  
  40.       
  41.     public void setTarget(BufferedImage target) {  
  42.         this.targetImage = target;  
  43.     }  
  44.   
  45.     @Override  
  46.     protected void paintComponent(Graphics g) {  
  47.         Graphics2D g2 = (Graphics2D) g;  
  48.         if(targetImage != null) {  
  49.             g2.drawImage(targetImage, 10, 10, targetImage.getWidth(), targetImage.getHeight(), null);  
  50.         }  
  51.         if(template != null) {  
  52.             g2.drawImage(template, 20+targetImage.getWidth(), 10, template.getWidth(), template.getHeight(), null);  
  53.         }  
  54.     }  
  55.       
  56.     public static void main(String[] args) {  
  57.         JFrame f = new JFrame("模板匹配与识别");  
  58.         JButton okBtn = new JButton("匹配");  
  59.         final DemoUI ui = new DemoUI();  
  60.         okBtn.addActionListener(new ActionListener() {  
  61.   
  62.             @Override  
  63.             public void actionPerformed(ActionEvent e) {  
  64.                   
  65.                 ui.process();  
  66.             }  
  67.         });  
  68.           
  69.         JPanel btnPanel = new JPanel();  
  70.         btnPanel.setLayout(new FlowLayout(FlowLayout.RIGHT));  
  71.         btnPanel.add(okBtn);  
  72.           
  73.         f.getContentPane().add(btnPanel, BorderLayout.SOUTH);  
  74.         f.getContentPane().add(ui, BorderLayout.CENTER);  
  75.         f.setSize(500, 500);  
  76.         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  77.         f.setVisible(true);  
  78.     }  
  79.   
  80.     protected void process() {  
  81.         NccTemplateMatchAlg algo = new NccTemplateMatchAlg(template);  
  82.         targetImage = algo.filter(targetImage, null);  
  83.         this.repaint();  
  84.     }  
  85.   
  86. }  
package com.gloomyfish.image.templae.match;

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class DemoUI extends JComponent {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private BufferedImage targetImage;
	private BufferedImage template;
	
	public DemoUI()
	{
		super();
		java.net.URL imageURL = this.getClass().getResource("words.png");
		java.net.URL templateURL = this.getClass().getResource("template.png");
		
		try {
			template = ImageIO.read(templateURL);
			targetImage = ImageIO.read(imageURL);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public void setTarget(BufferedImage target) {
		this.targetImage = target;
	}

	@Override
	protected void paintComponent(Graphics g) {
		Graphics2D g2 = (Graphics2D) g;
		if(targetImage != null) {
			g2.drawImage(targetImage, 10, 10, targetImage.getWidth(), targetImage.getHeight(), null);
		}
		if(template != null) {
			g2.drawImage(template, 20+targetImage.getWidth(), 10, template.getWidth(), template.getHeight(), null);
		}
	}
	
	public static void main(String[] args) {
		JFrame f = new JFrame("模板匹配与识别");
		JButton okBtn = new JButton("匹配");
		final DemoUI ui = new DemoUI();
		okBtn.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				
				ui.process();
			}
		});
		
		JPanel btnPanel = new JPanel();
		btnPanel.setLayout(new FlowLayout(FlowLayout.RIGHT));
		btnPanel.add(okBtn);
		
		f.getContentPane().add(btnPanel, BorderLayout.SOUTH);
		f.getContentPane().add(ui, BorderLayout.CENTER);
		f.setSize(500, 500);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setVisible(true);
	}

	protected void process() {
		NccTemplateMatchAlg algo = new NccTemplateMatchAlg(template);
		targetImage = algo.filter(targetImage, null);
		this.repaint();
	}

}

四：程序运行效果如下


其中左边是目标图像、右边为模板图像

Einstein_liu
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
OpenCV基于NCC多角度模板匹配
qq_42857680的博客
09-28 5518
OpenCV基于NCC多角度模板匹配
图像处理之基于NCC模板匹配识别
weixin_34208185的博客
10-02 4077
一：基本原理 NCC是一种基于统计学计算两组样本数据相关性的算法，其取值范围为[-1, 1]之间，而对图像来说，每个像素点都可以看出是RGB数值，这样整幅图像就可以看成是一个样本数据的集合，如果它有一个子集与另外一个样本数据相互匹配则它的ncc值为1，表示相关性很高，如果是-1则表示完全不相关，基于这个原理，实现图像基于模板匹配识别算法，其中第一步就是要...
NCC模板匹配
10-15
其中包含了5篇相关NCC模板匹配算法的论文文献，感觉很不错的，对理解NCC算法很有帮助。
图像处理 -- 图像模版匹配算法之NCC
最新发布
sz66cm 学习随笔
07-30 1431
NCC（Normalized Cross-Correlation，归一化互相关）是一种常用于图像处理中的模板匹配算法。其数学原理是计算模板图像与目标图像局部区域之间的相似度，通过最大化NCC值找到最匹配的位置。
基于相关性的模板匹配NCC
一位正在苦苦追求毕业的研究僧
10-08 2471
基于相关性模板匹配应用场合：搜索对象有轻微的变形，大量的纹理，图像模糊等场合，速度快，精度低。
halcon之NCC匹配
weixin_33928467的博客
03-18 1132
NCC匹配 基于Normalized cross correlation(NCC)用来比较两幅图像的相似程度已经是一个常见的图像处理手段。在工业生产环节检测、监控领域对对象检测与识别均有应用。NCC算法可以有效降低光照对图像比较结果的影响。而且NCC最终结果在0到1之间，所以特别容易量化比较结果，只要给出一个阈值就可以判断结果的好与坏。传统的NCC比较方法比较耗时，虽然可以通过调整窗口大小...
深入探讨C++实现模板匹配：基于NCC的模板匹配算法
qq_38334677的博客
06-10 842
模板匹配是一种利用模板图像在目标图像中进行搜索的算法，通过计算模板图像和目标图像各个位置的相似度，找到最匹配的区域。模板匹配的关键在于相似度的计算，常用的相似度度量方法包括互相关、归一化互相关和均方误差等。本文详细介绍了基于归一化互相关（NCC）的模板匹配算法，并通过具体的代码示例展示了如何在C++中实现这一算法。通过合理的设计和优化策略，我们可以高效地实现模板匹配，并将其应用于各种实际问题中。模板匹配作为一种重要的图像处理技术，具有广泛的应用前景。
opencv python实现NCC旋转匹配
03-10
本话题将探讨如何使用OpenCV和Python实现基于归一化互相关(Normalized Cross Correlation, NCC)的旋转匹配技术。这个过程涉及到几个关键步骤，包括圆投影、积分运算以及降采样，这些都是优化匹配效率的关键。 首先...
基于opencv的模板匹配
04-27
以下是一个基本的NCC模板匹配代码框架： ```python import cv2 import numpy as np # 加载图像 img = cv2.imread('large_image.jpg') template = cv2.imread('template.jpg', 0) # 计算模板的尺寸 w, h = template...
机器视觉模板匹配相关原理
05-26
基于灰度值的模板匹配是最基本的模板匹配方法。该方法通过计算图像和模板之间的灰度值差异来实现模板匹配。常见的基于灰度值的模板匹配方法有： 1. SAD（Sum of Absolute Differences）：计算图像和模板之间的灰度...
NCC Template matching_模板匹配_NCCTemplatematch_NCC_NCC_matching_ncc
09-11
NCC模板匹配，可以直接运行，加载本地图片。
NCC Template matching_模板匹配
09-29
NCC Template matching_模板匹配_NCCTemplatematch_NCC_NCC_matching_ncc模板匹配_源码.rar
halcon ncc 模板匹配
11-01
用halcon实现ncc模板匹配，可运行已调试，可作为学习参考
NCC匹配算法
10-13
匹配算法，NCC的原理和代码实现的示例，以及和对中匹配算法的效果比较
【Halcon视觉】NCC模板匹配
文布斯的博客
09-20 4564
图像匹配是通过对图像内容，特征，结构，纹理，灰度等的对应关系，进行相似性和一致性的分析，寻求相似图像目标的方法。 机器视觉的图像匹配，通常先确定目标，在某张样图中选择目标作为模板，然后在待匹配的图像中分析，是否有模板相似区，如果有，则进一步确定位姿，因此也被称作模板匹配。 图像像素的灰度值信息，包含了图像记录的所有信息。基于图案像素灰度值的匹配，是最基本的匹配算法。通常直接利用整幅图像的灰度信息，建立两幅图像之间的相似性度量，然后采用搜索算法寻找相似性度量...
基于相关性（NCC）的模板匹配Halcon
sinat_31608641的博客
06-02 5684
一、原理 归一化相关性.NCC，(normalization cross-correlation)，顾名思义，就是用于归一化待匹配目标之间的相关程度，注意这里比较的是原始像素。通过在待匹配像素位置p（px，py）构建3*3邻域匹配窗口，与目标像素位置p'(px+d,py）同样构建邻域匹配窗口的方式建立目标函数来对匹配窗口进行度量相关性。它是基于图像灰度信息的匹配方法。 NCC的定义 在[-1,1]绝对尺度范围之间衡量两者的相似性。相关系数刻画了两者之间的近似程度的线性描述。一般说来，越接近于1，两
基于 NCC/灰度信息 的模板匹配算法（QT + Opencv + C++），10ms内获取匹配结果，部分源码
某帅气小伙的博客
06-14 9240
文后代码，优化效果图结尾处，最快3ms得到匹配结果 NCC，全称为Normalized Cross Correlation，即归一化互相关系数， 在模板匹配中使用的非常非常广泛，也是众多模板匹配方法中非常耀眼的存在， 这个匹配的理论核心基础公式如下： 其实Opencv的matchTemplate函数使用的就是这个公式，实测直接使用这个公式实现无旋转角度的、单目标的模板匹配时用时大概26ms（其实这个结果已经满足大部分使用需求了），但是本博主响应国家号召，秉着自强不息、实事求是、勇于钻研的心态，决定从公
ncc模板匹配识别图片的原理
03-22
ncc模板匹配是一种基于图像相似度的匹配方法，它通过计算模板图像与待匹配图像的相似度来实现图像识别。具体来说，ncc模板匹配使用归一化互相关（Normalized Cross-Correlation，NCC）来计算相似度，即将模板图像与待匹配图像进行卷积运算，然后将结果归一化，得到一个范围在[-1,1]之间的相似度值，值越大表示两幅图像越相似。在实际应用中，可以通过设置一个阈值来判断是否匹配成功。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值