摄像头车牌图像识别

最新推荐文章于 2024-06-14 20:27:35 发布
最新推荐文章于 2024-06-14 20:27:35 发布
阅读量5k 收藏 25
点赞数 3
文章标签： 人工智能 c#
原文链接：https://my.oschina.net/sitsit/blog/3094592
版权
技术：C#+WinForm+Windows API
运行环境：Visual Studio 2015

概述

使用C#进行车牌检测和车牌识别，车牌检测包括图像分割和特征提取，车牌识别是指对检测到的车牌进行内容识别。利用 Visual Studio 2015 集成开发环境，采用System.Drawing命名空间的类来处理图片、Windows API控制摄像头。

详细

一、运行效果

000.png

111.png

333.png

222.png

二、实现过程

①、图像处理模块

图像处理使用了灰度化、灰度均衡化、高斯滤波、边缘检测、二值化等技术实现了车牌图像的定位和检测，再通过对已有图片的特征匹配来实现车牌图片的识别。

//车辆图片处理事件
private void t灰度化()
{

	if (m_Bitmap != null)
	{
		int tt = 0;
		for (int i = 0; i < 256; i++)//清掉数组gray里的数据
		{
			gray[i] = 0;
		}
		for (int i = 0; i < 256; i++)//清掉数组rr里的数据
		{
			rr[i] = 0;
		}
		for (int i = 0; i < 256; i++)//清掉数组gg里的数据
		{
			gg[i] = 0;
		}
		for (int i = 0; i < 256; i++)//清掉数组bb里的数据
		{
			bb[i] = 0;
		}
		BitmapData bmData = m_Bitmap.LockBits(new Rectangle(0, 0, m_Bitmap.Width, m_Bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
		int stride = bmData.Stride;//获取或设置 Bitmap 对象的跨距宽度（也称为扫描宽度）。 
		System.IntPtr Scan0 = bmData.Scan0;//获取或设置位图中第一个像素数据的地址。 它也可以看成是位图中的第一个扫描行
		unsafe
		{
			byte* p = (byte*)(void*)Scan0;
			int nOffset = stride - m_Bitmap.Width * 3;
			byte red, green, blue;
			int nWidth = m_Bitmap.Width;
			int nHeight = m_Bitmap.Height;
			for (int y = 0; y < nHeight; ++y)
			{
				for (int x = 0; x < nWidth; ++x)
				{
					blue = p[0];
					green = p[1];
					red = p[2];
					tt = p[0] = p[1] = p[2] = (byte)(.299 * red + .587 * green + .114 * blue);
					rr[red]++;
					gg[green]++;
					bb[blue]++;
					gray[tt]++;   //统计灰度值为tt的象素点数目  
					p += 3;
				}
				p += nOffset;
			}
		}
		m_Bitmap.UnlockBits(bmData);
		flag = 1;
		graydo();
	}

}
private void t灰度均衡化()
{

	if (m_Bitmap != null)
	{
		BitmapData bmData = m_Bitmap.LockBits(new Rectangle(0, 0, m_Bitmap.Width, m_Bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
		//加入内存进行处理
		int stride = bmData.Stride;
		System.IntPtr Scan0 = bmData.Scan0;//扫描的第一行
		int tt = 0;
		int[] SumGray = new int[256];
		for (int i = 0; i < 256; i++)
		{
			SumGray[i] = 0;
		}
		unsafe
		{
			byte* p = (byte*)(void*)Scan0;
			int nOffset = stride - m_Bitmap.Width * 3;
			int nHeight = m_Bitmap.Height;
			int nWidth = m_Bitmap.Width;
			SumGray[0] = gray[0];//灰度均衡化 
			for (int i = 1; i < 256; ++i)//灰度级频度数累加                         
				SumGray[i] = SumGray[i - 1] + gray[i];
			for (int i = 0; i < 256; ++i) //计算调整灰度值     频率乘以灰度总级数得出该灰度变换后的灰度级                   
				SumGray[i] = (int)(SumGray[i] * 255 / count);
			for (int i = 0; i < 256; i++)
			{
				gray[i] = 0;
			}
			for (int y = 0; y < nHeight; ++y)
			{
				for (int x = 0; x < nWidth; ++x)
				{
					tt = p[0] = p[1] = p[2] = (byte)(SumGray[p[0]]);
					gray[tt]++;
					p += 3;
				}
				p += nOffset;
			}
		}
		m_Bitmap.UnlockBits(bmData);
		flag = 1;
		graydo();
	}
}
private void t高斯滤波()
{
	if (m_Bitmap != null)
	{
		BitmapData bmData = m_Bitmap.LockBits(new Rectangle(0, 0, m_Bitmap.Width, m_Bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
		for (int i = 0; i < 256; i++)
		{
			gray[i] = 0;
		}
		unsafe
		{
			int stride = bmData.Stride;
			System.IntPtr Scan0 = bmData.Scan0;
			byte* p = (byte*)(void*)Scan0;
			byte* pp;
			int tt;
			int nOffset = stride - m_Bitmap.Width * 3;
			int nWidth = m_Bitmap.Width;
			int nHeight = m_Bitmap.Height;
			long sum = 0;
			int[,] gaussianMatrix = { { 1, 2, 3, 2, 1 }, { 2, 4, 6, 4, 2 }, { 3, 6, 7, 6, 3 }, { 2, 4, 6, 4, 2 }, { 1, 2, 3, 2, 1 } };//高斯滤波器所选的n=5模板
			for (int y = 0; y < nHeight; ++y)
			{
				for (int x = 0; x < nWidth; ++x)
				{
					if (!(x <= 1 || x >= nWidth - 2 || y <= 1 || y >= nHeight - 2))
					{
						pp = p;
						sum = 0;
						int dividend = 79;
						for (int i = -2; i <= 2; i++)
							for (int j = -2; j <= 2; j++)
							{
								pp += (j * 3 + stride * i);
								sum += pp[0] * gaussianMatrix[i + 2, j + 2];
								if (i == 0 && j == 0)
								{
									if (pp[0] > 240)//如果模板中心的灰度大于240
									{
										sum += p[0] * 30;
										dividend += 30;
									}
									else if (pp[0] > 230)
									{
										sum += pp[0] * 20;
										dividend += 20;
									}
									else if (pp[0] > 220)
									{
										sum += p[0] * 15;
										dividend += 15;
									}
									else if (pp[0] > 210)
									{
										sum += pp[0] * 10;
										dividend += 10;
									}
									else if (p[0] > 200)
									{
										sum += pp[0] * 5;
										dividend += 5;
									}
								}
								pp = p;
							}
						sum = sum / dividend;
						if (sum > 255)
						{
							sum = 255;
						}
						p[0] = p[1] = p[2] = (byte)(sum);
					}
					tt = p[0];
					gray[tt]++;
					p += 3;
				}
				p += nOffset;
			}
		}
		flag = 1;
		m_Bitmap.UnlockBits(bmData);
		graydo();
	}
}

//定位处理事件
private void sobel边缘检测()
{
	if (m_Bitmap != null)
	{
		BitmapData bmData = m_Bitmap.LockBits(new Rectangle(0, 0, m_Bitmap.Width, m_Bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
		float valve = 67;
		for (int i = 0; i < 256; i++)
		{
			gray[i] = 0;
		}
		unsafe
		{
			int stride = bmData.Stride;
			System.IntPtr Scan0 = bmData.Scan0;
			byte* p = (byte*)(void*)Scan0;
			byte* pp;
			int tt;
			int nOffset = stride - m_Bitmap.Width * 3;
			int nWidth = m_Bitmap.Width;
			int nHeight = m_Bitmap.Height;
			int Sx = 0;
			int Sy = 0;
			//	float max = 0;
			double sumM = 0;
			double sumCount = 0;
			int[] marginalMx = { -1, 0, 1, -2, 0, 2, -1, 0, 1 };   //sobel模板
			int[] marginalMy = { 1, 2, 1, 0, 0, 0, -1, -2, -1 };
			int[,] dlta = new int[nHeight, nWidth];
			for (int y = 0; y < nHeight; ++y)      //sobel算子
			{
				for (int x = 0; x < nWidth; ++x)
				{
					if (!(x <= 0 || x >= nWidth - 1 || y <= 0 || y >= nHeight - 1))
					{
						pp = p;
						Sx = 0;
						Sy = 0;
						for (int i = -1; i <= 1; i++)
							for (int j = -1; j <= 1; j++)
							{
								pp += (j * 3 + stride * i);
								Sx += pp[0] * marginalMx[(i + 1) * 3 + j + 1];
								Sy += pp[0] * marginalMy[(i + 1) * 3 + j + 1];
								pp = p;
							}
						m[y, x] = (int)(Math.Sqrt(Sx * Sx + Sy * Sy));
						if (m[y, x] > valve / 2) //增强白点
						{
							if (p[0] > 240)
							{
								m[y, x] += valve;
							}
							else if (p[0] > 220)
							{
								m[y, x] += (float)(valve * 0.8);
							}
							else if (p[0] > 200)
							{
								m[y, x] += (float)(valve * 0.6);
							}
							else if (p[0] > 180)
							{
								m[y, x] += (float)(valve * 0.4);
							}
							else if (p[0] > 160)
							{
								m[y, x] += (float)(valve * 0.2);
							}
						}
						float tan;
						if (Sx != 0)
						{
							tan = Sy / Sx;
						}
						else tan = 10000;
						if (-0.41421356 <= tan && tan < 0.41421356)//角度为-22.5度到22.5度之间
						{
							dlta[y, x] = 0; //	m[y,x]+=valve;                                 
						}
						else if (0.41421356 <= tan && tan < 2.41421356)//角度为22.5度到67.5度之间
						{
							dlta[y, x] = 1; //m[y,x] = 0;
						}
						else if (tan >= 2.41421356 || tan < -2.41421356)//角度为67.5度到90度之间或-90度到-67.5度
						{
							dlta[y, x] = 2;    //	m[y,x]+=valve;
						}
						else
						{
							dlta[y, x] = 3;//m[y,x] = 0;     
						}
					}
					else
						m[y, x] = 0;
					p += 3;
					if (m[y, x] > 0)
					{
						sumCount++;
						sumM += m[y, x];
					}
				}
				p += nOffset;

			}
			p = (byte*)(void*)Scan0; //非极大值抑制和阀值
			for (int y = 0; y < nHeight; ++y)
			{
				for (int x = 0; x < nWidth; ++x)
				{
					if (m[y, x] > sumM / sumCount * 1.2)
					{
						p[0] = p[1] = p[2] = (byte)(m[y, x]); //m[y,x]=1;                            
					}
					else
					{
						m[y, x] = 0;
						p[0] = p[1] = p[2] = 0;
					}
					if (x >= 1 && x <= nWidth - 1 && y >= 1 && y <= nHeight - 1 && m[y, x] > valve)
					{
						switch (dlta[y, x])
						{
							case 0:
								if (m[y, x] >= m[y, x - 1] && m[y, x] >= m[y, x + 1])//水平边缘
								{
									p[0] = p[1] = p[2] = 255;
								}
								break;

							case 1:
								if (m[y, x] >= m[y + 1, x - 1] && m[y, x] >= m[y - 1, x + 1])//正斜45度边缘
								{
									p[0] = p[1] = p[2] = 255;
								}
								break;

							case 2:
								if (m[y, x] >= m[y - 1, x] && m[y, x] >= m[y + 1, x])//垂直边缘
								{
									p[0] = p[1] = p[2] = 255;
								}
								break;

							case 3:
								if (m[y, x] >= m[y + 1, x + 1] && m[y, x] >= m[y - 1, x - 1])//反斜45度边缘
								{
									p[0] = p[1] = p[2] = 255;
								}
								break;
						}
					}
					if (p[0] == 255)
					{
						m[y, x] = 1;
					}
					else
					{
						m[y, x] = 0;
						p[0] = p[1] = p[2] = 0;
					}

					tt = p[0];
					gray[tt]++;
					p += 3;
				}
				//  p += nOffse
最低0.47元/天 解锁文章
chuyang2652
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
车牌图像识别
maotoula的专栏
06-20 2万+
1.车牌预处理 车牌预处理过程的好坏直接影响到车牌图像进行后期处理过程，比如车牌字符分割等。车牌预处理也是尽可能的消除噪声，减少后期处理带来的不必要的麻烦。 输入的车牌是24Bit的BMP真彩色图像，车牌照有黄底黑字，蓝底白字等颜色，为了将这些车牌图像一并处理，就要先将车牌进行灰度化处理，然后进行二值化（黑白）处理。 图4-1 原始图像 将采集的车牌图像进行预处理，为了方便起见
基于qt5.1.1与opencv2.4.7车牌字符切割与字符识别demo
12-16
基于qt5.1.1与opencv2.4.7车牌字符切割与字符识别demo，内有注释详解，适合新手学习，需要这方面资料的同学可以在此处下载
开源百宝箱《HelloGitHub》第 64 期
HelloGitHub 的博客
07-28 1083
兴趣是最好的老师，HelloGitHub 让你对编程感兴趣！分享 GitHub 上有趣、入门级的开源项目。HelloGitHub 有实战、教程、黑科技、开源书籍、企业级开源项目，涵盖多种编...
浏览器实时播放摄像头数据并通过 Yolo 进行图像识别
hawk2014bj的博客
06-14 412
功能很好实现，效果还要微调，苹果的充电器并没有识别出来。
13、案例分析-在C#中识别车牌
panjinliang066333的博客
01-07 3499
直接上干货，最终完成的效果图。 接前面博客继续：《9、Haclon图像中字符识别》https://blog.csdn.net/panjinliang066333/article/details/104676302 （1）将已经可以实现车牌识别的Halcon程序，以C#文件格式导出。 （2）创建C# winform 程序工程，按照上一节所讲的进行配置，运行没有报错。 （3）按照效果图进行界面布局。 代码实现： （1）打开车牌图片。需要注意的是，车牌图片在面板上全屏显示需要额外的进行设置。
【朝夕教育】2023年04月 .NET CORE工具案例-基于Halcon车牌识别
微软MVP Eleven
04-03 1万+
Halcon是一种计算机视觉软件工具，用于图像处理、分析和机器视觉应用。它由德国MVTec公司开发，是一种功能强大的视觉软件工具，可用于解决各种计算机视觉问题，包括目标检测、图像识别、三维视觉等。Halcon支持多种编程语言，包括C++、C#、Python等，用户可以使用自己熟悉的编程语言进行开发和应用。
C# Yolo+Onnx 号牌识别
.NET 人工智能实践
07-21 842
C# Yolo+Onnx 号牌识别
海康威视摄像头车牌识别范例
03-26
【海康威视摄像头车牌识别范例】 海康威视作为全球领先的安防产品及解决方案提供商，其在视频监控领域有着深厚的技术积累。车牌识别技术是智能交通系统中的关键部分，用于自动识别车辆的车牌号码，以实现车辆追踪、...
宇视摄像头车牌识别SDK
08-27
宇视摄像头车牌识别SDK是一款专为智能交通领域设计的软件开发工具包，它集成了先进的图像处理和机器学习技术，能够帮助开发者实现高效、准确的车牌识别功能。SDK中的核心功能包括设备连接、实时视频流处理、车牌检测...
matlab 车牌识别，图形图像处理大作业
最新发布
07-29
其基本原理是将摄像头拍摄到的包含车辆车牌的图像通过视频卡输入到计算机中，经过预处理、车牌定位、字符分割和字符识别等步骤，最终输出车牌号码。 二、MATLAB车牌识别的主要步骤 图像采集： 通过摄像头或其他图像...
C#读取摄像头采集图片avicap
12-08
主要使用C# avicap读取摄像头，并且抓取bmp格式的图像，提取其中的R值，并且画图动态显示R值。
车牌识别Hyperlpr
02-05
HyperLPR是一个使用深度学习针对对中文车牌识别的实现，开源地址：https://github.com/zeusees/HyperLPR，在windows下，使用vs2013编译成功，编译前需要修改opencv340的include和lib路径。
车牌号识别3_车牌识别_识别_车牌_图像识别_
09-30
预处理是图像识别过程的关键步骤，对于车牌号识别来说尤其重要。在对车牌图像进行识别前，通常需要进行以下预处理操作： 1. **图像采集**：首先，需要获取到清晰的车牌图像。这可以通过摄像头或其他图像采集设备...
STM32单片机车牌识别摄像头图像识别系统设计
07-19
3、识别主要过程包括图像采集、二值化分析、识别车牌区域、字符分割、字符匹配五个过程。 4、车牌锁定后会有蜂鸣器提醒，在分析获取到车牌后对车停留时间进行计时，并进行计费。 5、在图像采集界面，通过按键可以...
LPR牌超识别
本 的专栏
07-14 793
牌照识别 牌照两个阶段 识别拍照区域 识别拍照区域内字符 牌照识别过程 识别出图像中拍照区域 标准化：将大小，对比度，高亮牌照区域 字符分割：获取单个字符区域 OCR：光学字符识别，识别单个区域内的字符 与标准对比 撒旦法
多车牌识别
m0_49423868的博客
03-21 4269
多车牌识别：yolov5 + HyperLPR
调用海康威视sdk获取车牌号
热门推荐
cngwj的博客
03-25 3万+
环境： win10（10.0.16299.0）+ vs2017sdk版本：CH-HCNetSDK_Win32_V5.3.2.15_build20171122https://download.csdn.net/download/cngwj/10307129（工程已包含sdk下载后可直接运行）1、首先确认摄像头是否支持车辆检测2、 启用事件抓图3、配置sdk下载sdk http://w...
使用OpenCV查找图像中矩形的位置
It is me 的博客
11-25 3125
import cv2 image = cv2.imread('1.jpg') blur = cv2.pyrMeanShiftFiltering(image, 11, 21) gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY) thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1] cnts = cv2.findContours(thresh, cv2....
delphi 摄像头车牌识别代码 详细
05-26
很抱歉，我并不是一个能够提供具体代码的人工智能。但是，我可以给你一些思路和建议。 首先，你需要一个能够捕捉摄像头图像的组件。Delphi 自带的 TWebcam 组件可以很方便地实现这个功能。你可以在 Delphi 的菜单栏中选择 Component -> Install Packages，然后在 Packages 中选择 WebCam Package，安装后就可以在工具箱中找到 TWebcam 组件。 接下来，你需要一个能够识别车牌的算法。这个算法可以比较复杂，因为车牌的颜色、大小、字体等方面都可能有所不同。常见的车牌识别算法有基于机器学习的方法和基于模板匹配的方法。基于机器学习的方法需要大量的训练数据和计算资源，而基于模板匹配的方法则需要大量的模板和精准的图像处理技术。 最后，你需要将摄像头捕捉的图像和车牌识别算法结合起来，实现车牌识别的功能。具体实现方式可以参考以下步骤： 1. 使用 TWebcam 组件捕捉摄像头图像。 2. 对捕捉到的图像进行预处理，例如去噪、增强对比度等。 3. 使用车牌识别算法对预处理后的图像进行车牌定位和识别。 4. 将识别到的车牌信息显示在界面上或者保存到数据库中。 希望这些思路和建议能够帮助你，祝你顺利完成项目！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值