使用opencv进行车牌提取及识别

最新推荐文章于 2024-09-12 16:46:00 发布
最新推荐文章于 2024-09-12 16:46:00 发布
阅读量2k 收藏 20
点赞数

使用opencv进行车牌提取及识别
目录

车牌提取过程

一个典型的车辆牌照识别系统一般包括以下4个部分：车辆图像获取、车牌定位、车牌字符分割和车牌字符识别 。

本篇文章只介绍车牌的提取分割过程，关于如何对分割后的字符进行识别 ，请看我的另一篇WIKI ，opencv基于人工神经网络的字母识别。

车辆图像获取

车辆图像获取是车牌识别的第一步，也是很重要的一步，车辆图像的好坏对后面的工作有很大的影响。如果车辆图像的质量太差，连人眼都没法分辨，那么肯定不会被机器所识别出来。车辆图像都是在实际现场拍摄出来的，实际环境情况比较复杂，图像受天气和光线等环境影响较大，在恶劣的工作条件下系统性能将显著下降。 现有的车辆图像获取方式主要有两种：一种是由彩色摄像机和图像采集卡组成，其工作过程是：当车辆检测器（如地感线圈、红外线等）检测到车辆进入拍摄范围时，向主机发送启动信号，主机通过采集卡采集一幅车辆图像，为了提高系统对天气、环境、光线等的适应性，摄像机一般采用自动对焦和自动光圈的一体化机，同时光照不足时还可以自动补光照明，保证拍摄图片的质量；另一种是由数码照相机构成，其工作过程是：当车辆检测器检测到车辆进入拍摄范围时，直接给数码照相机发送一个信号，数码相机自动拍摄一幅车辆图像，再传到主机上，数码相机的一些技术参数可以通过与数码相机相连的主机进行设置，光照不足时也需要自动开启补光照明，保证拍摄图片的质量。

图（有车牌的图像）

车牌定位

车牌定位的主要工作是从摄入的汽车图像中找到汽车牌照所在位置，并把车牌从该区域中准确地分割出来，供字符分割使用。因此，牌照区域的确定是影响系统性能的重要因素之一，牌照的定位与否直接影响到字符分割和字符识别的准确率。目前车牌定位的方法很多，但总的来说可以分为以下4类：（1）基于颜色的分割方法，这种方法主要利用颜色空间的信息，实现车牌分割，包括彩色边缘算法、颜色距离和相似度算法等；（2）基于纹理的分割方法，这种方法主要利用车牌区域水平方向的纹理特征进行分割，包括小波纹理、水平梯度差分纹理等；（3）基于边缘检测的分割方法；（4）基于数学形态法的分割方法。 本文为了代码实现上的方便，我采用的是基于边缘检测的分割方法。主要是利用水平投影方法和垂直投影方法进行车牌定位。

车牌字符分割

要识别车牌字符，前提是先进行车牌字符的正确分割与提取。字符分割的任务是把多列或多行字符图像中的每个字符从整个图像中切割出来成为单个字符。车牌字符的正确分割对字符的识别是很关键的。传统的字符分割算法可以归纳为以下三类：直接分割法、基于识别基础上的分割法、自适应分割线类聚法。直接分割法简单，但它的局限是分割点的确定需要较高的准确性；基于识别基础上的分割法是把识别和分割结合起来，但是需要识别的高准确性，它根据分类和识别的耦合程度又有不同的划分；自适应分割线聚类法是要建立一个分类器，用它来判断图像的每一列是否是分割线，它是根据训练样本来进行自适应学习的神经网络分类器，但对于粘连字符训练困难。也有直接把字符组成的单词当作一个整体来识别的，诸如运用马尔科夫数学模型等方法进行处理，这些算法主要应用于印刷体文本识别。

车牌提取

灰度化

灰度化的概念就是将一张三通道RGB颜色的图像变成单通道灰度图，为接下来的图像处理做准备。

 //灰度化

 Mat  gray_image;

 cvtColor(image, gray_image, CV_RGB2GRAY);

 imshow("test", gray_image);

图（灰度图）

Candy边缘检测

Canny边缘检测算子的方向性质保证了很好的边缘强度估计，而且能同时产生边缘梯度方向和强度两个信息，即能在一定程度上抗噪声又能保持弱边缘，因此采用以canny算子做边缘检测。

Canny算法步骤：

(1)去噪

任何边缘检测算法都不可能在未经处理的原始数据上很好地處理，所以第一步是对原始数据与高斯 mask 作卷积，得到的图像与原始图像相比有些轻微的模糊（blurred）。这样，单独的一个像素雜訊在经过高斯平滑的图像上变得几乎没有影响。

(2)用一阶偏导的有限差分来计算梯度的幅值和方向。

(3)对梯度幅值进行非极大值抑制。

车牌细定位的目的是为下一步字符的分割做，就是要进一步去掉车牌冗余的部分。在一幅经过适当二值化处理 含有车牌的图像中，车牌区域具有以下三个基本特征：

1.在一个不大的区域内密集包含有多个字符；

2.车牌字符与车牌底色形成强烈对比；

3.车牌区域大小相对固定，区域长度和宽度成固定比例。

   //Candy/sobel 边缘检测：
    Mat candy_image;
   Canny(blur_image, candy_image, 500, 200, 3);
   //imshow("test", candy_image);

图（边缘检测）

形态学（膨胀腐蚀）处理

膨胀与腐蚀的处理效果就如其名字一样，我们通过膨胀连接相近的图像区域，通过腐蚀去除孤立细小的色块。通过这一步，我们希望将所有的车牌号字符连通起来，这样为我们接下来通过轮廓识别来选取车牌区域做准备。由于字符都是横向排列的，因此要连通这些字符我们只需进行横向的膨胀即可。

进行膨胀腐蚀操作需要注意的是要一次到位，如果一次膨胀没有连通到位，那么再次腐蚀将会将图像回复原装，因此我首先做了2次迭代的膨胀，保证数字区域能连通起来，再进行4次迭代腐蚀，尽可能多的去除小块碎片，随后2次迭代膨胀，保证膨胀次数与腐蚀次数相同，以回复连通区域形态大小。

矩形轮廓查找与筛选：经过上一步操作，理论上来说车牌上的字符连通成一个矩形区域，通过轮廓查找我们可以定位该区域。当然，更为准确的说，经过上面的操作，我们将原始图片中在X方向排列紧密的纵向边缘区域连通成了一个矩形区域，出了车牌符合这个特点外，其他一些部分如路间栏杆，车头的纹理等同样符合。因此我们会找到很多这样的区域，这就需要我们进一步根据一些关于车牌特点的先验知识对这些矩形进行进一步筛选。最终，定位车牌所在的矩形区。

        //形态学处理
	//图片膨胀处理
	Mat dilate_image, erode_image;
	//自定义 核进行 x 方向的膨胀腐蚀
	Mat elementX = getStructuringElement(MORPH_RECT, Size(25, 1));
	Mat elementY = getStructuringElement(MORPH_RECT, Size(1, 19));
	Point point(-1, -1);
	dilate(candy_image, dilate_image, elementX, point, 2);
	erode(dilate_image, erode_image, elementX, point, 4);
	dilate(erode_image, dilate_image, elementX, point, 2);

	//自定义 核进行 Y 方向的膨胀腐蚀
	erode(dilate_image, erode_image, elementY, point, 1);
	dilate(erode_image, dilate_image, elementY, point, 2);
	//imshow("test", dilate_image);
	//waitKey(1000);
	imwrite("dilate_image.jpg", dilate_image);
        //噪声处理
	//平滑处理 中值滤波
	Mat blurr_image;
	medianBlur(dilate_image, blurr_image, 15);
	medianBlur(blurr_image, blurr_image, 15);
	imshow("test", blurr_image);

图（形态学处理）

轮廓处理

提取轮廓

        //矩形轮廓查找与筛选：
	Mat contour_image;
	//深拷贝  查找轮廓会改变源图像信息，需要重新 拷贝 图像
	contour_image = blurr_image.clone();
	vector<vector<Point>> contours;
	findContours(contour_image, contours, CV_RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
	//画出轮廓
	drawContours(contour_image, contours, -1, Scalar(255), 1);
         //轮廓表示为一个矩形  车牌提取
	Mat  roi_image;
	vector<Point> rectPoint;
	for (int i = 0; i < contours.size(); i++) {
		Rect r = boundingRect(Mat(contours[i]));
		//RotatedRect r = minAreaRect(Mat(contours[i]));
		cout << "contours " << i << "  height = " << r.height << "  width = " << r.width << "rate = " << ((float)r.width / r.height) << endl;
		if ((float)r.width / r.height >= 2.2 && (float)r.width / r.height <= 3.6) {
			cout << "r.x = " << r.x << "  r.y  = " << r.y << endl;
			rectangle(contour_image, r, Scalar(0, 0, 255), 2);
                        for (int j = 0; j < contours[i].size(); j++) {
				cout << "point = " << contours[i][j] << endl;
			}
			//rectangle(image, r, Scalar(0, 0, 255), 3);
			roi_image = image(r);
		}
	}

图（轮廓）

自适应二值化处理

二值化的处理强化了锐利的边缘，进一步去除图像中无用的信息，使用过程中主要注意阀值的选取，我为了省事儿使用了opencv自带的自适应的的二值化处理，缺点是无用信息有点多，但车牌数字信息也会更为凸显。

cvThreshold(sobel, threshold, 0, 255, CV_THRESH_BINARY| CV_THRESH_OTSU);

最后的参数CV_THRESH_OTSU就是使用自适应算法

        //Candy 边缘检测
	Mat candy_roi_image;
	Canny(roi_gray_image, candy_roi_image, 450, 120, 3);
	imshow("test", candy_roi_image);
        //二值化
	Mat roi_threadhold_image;
	threshold(candy_roi_image, roi_threadhold_image, 50, 255, CV_THRESH_BINARY);
	imshow("test", roi_threadhold_image);

图（二值化）

字符提取分割

像素值判断

这里主要使用水平映射和垂直映射像素进行像素级分割。

分割方法：首先判断每一列的像素值大于0的像素个数超过5个时，认为此列是有数字的，记录每列像素是否大于5，产生一个数组,数组的值有可能是一下。

a[100] = {00000001001110011111111111111100001111111111000000011111111100000000000001111110000110101011110000000000000000。。。。。。。}

这里做一个简单的水平方向的滤波，Size大小是5 ，然后对 每一个像素做处理，处理方法：

        //对数组进行滤波，减少突变概率
	for (int i = 2; i < roi_col - 1 - 2; i++) {
		if ((pixrow[i - 1] + pixrow[i - 2] + pixrow[i + 1] + pixrow[i + 2]) >= 3) {
			pixrow[i] = 1;
		}
		else if((pixrow[i - 1] + pixrow[i - 2] + pixrow[i + 1] + pixrow[i + 2]) <= 1) {
			pixrow[i] = 0;
		}
	}

如果 该像素周围为1的像素大于等于3个，不算自己 那么久认为该像素为 1， 如果 该像素周围 像素为0的个数小于等于1 ，那么就认为该像素为0

确认字符位置

//确认字符位置
	int count = 0;
	bool flage = false;
	for (int i = 0; i < roi_col - 1; i++) {
		pix = pixrow[i];
		if (pix == 1 && !flage) {
			flage = true;
			position1[count] = i;
			continue;
		}
		if (pix == 0 && flage) {
			flage = false;
			position2[count] = i;
			count++;
		}
		if (i == (roi_col - 2) && flage) {
			flage = false;
			position2[count] = i;
			count++;
		}
	}

水平映射以同样的方式完成，最后分割字符

//截取字符
	Mat licenseN = Mat(Scalar(0));
	cout << "countYY = "<< countYY << endl;
	for (int i = 0; i < countYY; i++) {
		Rect rect(licenseX[i], licenseY[i], licenseW[i], licenseH[i]);
		cout << "position = " << licenseX[i] << "  " << licenseY[i] << "  " << licenseW[i] << "  " << licenseH[i] << endl;
		licenseN = roi_threadhold_image(rect);
		imshow("test1"+i, licenseN);
		ostringstream oss;
		oss << "licenseN" << i << ".jpg";
		imwrite(oss.str(), licenseN);
		waitKey(1000);
	}

  图（分割后）


源代码

检测分割部分

#include<opencv2/opencv.hpp>
#include<opencv2/core/core.hpp> 
#include<opencv2/highgui/highgui.hpp>
#include<iostream>
#include<sstream>
using namespace std;
using namespace cv;


int  main_licenseprogress(Mat & image);


//int main() {
// string path = "license/license";
// Mat image;
// for (int i = 2; i <= 2; i++) {
// ostringstream oss;
// oss << path << i << ".jpg";
// cout << "path = " << path << "str = " << oss.str() << endl;
// image = imread(oss.str(), 1);
// main_licenseprogress(image);
// }
// system("pause");
// return 0;
//}




int main_licenseprogress(Mat & image) {
imshow("test", image);
waitKey(1000);
//灰度化
Mat  gray_image;
cvtColor(image, gray_image, CV_RGB2GRAY);
imshow("test", gray_image);
imwrite("license3_gray.jpg", gray_image);

waitKey(1000);


//平滑处理 中值滤波
Mat blur_image;
medianBlur(gray_image, blur_image, 3);
imwrite("blur_image.jpg", blur_image);
//imshow("test", gray_image);
//waitKey(1000);


//自适应二值化处理  由于candy 算子产生的图像已经是二值化图像，所以这里不做处理
//Mat threadhold_image;
//threshold(blur_image, threadhold_image, 200, 255, CV_THRESH_BINARY);
//imshow("test", threadhold_image);
//waitKey(1000);


//Candy/sobel 边缘检测：
float mask[3][3] = { { 1,2,1 },{ 0,0,0 },{ -1,-2,-1 } };
Mat y_mask = Mat(3, 3, CV_32F, mask) / 8;
Mat x_mask = y_mask.t(); // 转置
Mat sobelX, sobelY;
filter2D(blur_image, sobelX, CV_32F, x_mask);
filter2D(blur_image, sobelY, CV_32F, y_mask);
sobelX = abs(sobelX);
sobelY = abs(sobelY);


Mat candy_image;
Canny(blur_image, candy_image, 500, 250, 3);
//imshow("test", candy_image);
//waitKey(1000);
//imshow("test", sobelY);
//waitKey(1000);
imwrite("candy_image.jpg", candy_image);


//形态学处理
//图片膨胀处理
Mat dilate_image, erode_image;
//自定义 核进行 x 方向的膨胀腐蚀
Mat elementX = getStructuringElement(MORPH_RECT, Size(25, 1));
Mat elementY = getStructuringElement(MORPH_RECT, Size(1, 19));
Point point(-1, -1);
dilate(candy_image, dilate_image, elementX, point, 2);
imwrite("dilate_image.jpg", dilate_image);
erode(dilate_image, erode_image, elementX, point, 4);
imwrite("erode_image.jpg", erode_image);
dilate(erode_image, dilate_image, elementX, point, 2);
imwrite("dilate_image1.jpg", dilate_image);
//自定义 核进行 Y 方向的膨胀腐蚀
erode(dilate_image, erode_image, elementY, point, 1);
imwrite("erode_image1.jpg", erode_image);
dilate(erode_image, dilate_image, elementY, point, 2);
//imshow("test", dilate_image);
//waitKey(1000);
imwrite("dilate_image2.jpg", dilate_image);
//噪声处理
//平滑处理 中值滤波
Mat blurr_image;
medianBlur(dilate_image, blurr_image, 15);
medianBlur(blurr_image, blurr_image, 15);
imshow("test", blurr_image);
waitKey(1000);


//矩形轮廓查找与筛选：
Mat contour_image;
//深拷贝  查找轮廓会改变源图像信息，需要重新 拷贝 图像
contour_image = blurr_image.clone();
vector<vector<Point>> contours;
findContours(contour_image, contours, CV_RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
//画出轮廓
drawContours(contour_image, contours, -1, Scalar(255), 1);
//imshow("test", contour_image);
//waitKey(1000);


//Mat cannyy_image;
//Canny(contour_image, cannyy_image, 500, 200, 3);


//hough 直线 
//vector<Vec4i> lines;
//HoughLinesP(cannyy_image, lines, 1, CV_PI / 180, 20, 10, 0);
//for (size_t i = 0; i < lines.size(); i++) {
// Vec4i l = lines[i];
// line(image, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 1, LINE_AA);
// cout << "直线：  "<< i <<endl;
//}
//imshow("test", image);
//waitKey(1000);


//轮廓表示为一个矩形  车牌提取
Mat  roi_image;
vector<Point> rectPoint;
for (int i = 0; i < contours.size(); i++) {
Rect r = boundingRect(Mat(contours[i]));
//RotatedRect r = minAreaRect(Mat(contours[i]));
cout << "contours " << i << "  height = " << r.height << "  width = " << r.width << "rate = " << ((float)r.width / r.height) << endl;
if ((float)r.width / r.height >= 2.2 && (float)r.width / r.height <= 3.6) {
cout << "r.x = " << r.x << "  r.y  = " << r.y << endl;
rectangle(contour_image, r, Scalar(0, 0, 255), 2);
imwrite("contour_image.jpg", contour_image);
Point p1, p2, p3, p4;
p1.x = r.x;
p1.y = r.y;
p2.x = r.x + r.width;
p2.x = r.y;
p3.x = r.x + r.width;
p3.y = r.y + r.height;
p4.x = r.x;
p4.y = r.y + r.height;


rectPoint.push_back(p1);
rectPoint.push_back(p2);
rectPoint.push_back(p3);
rectPoint.push_back(p4);


for (int j = 0; j < contours[i].size(); j++) {
cout << "point = " << contours[i][j] << endl;
}
//rectangle(image, r, Scalar(0, 0, 255), 3);
roi_image = image(r);
}
}
imshow("test", roi_image);
waitKey(1000);
imwrite("roi_image.jpg", roi_image);
//图片放大
Mat large_image;
int col = roi_image.cols, row = roi_image.rows;
resize(roi_image, large_image, Size(300, 300 * row / col));
imshow("test", large_image);
waitKey(2000);
//车牌分割
//灰度化 
Mat  roi_gray_image;
cvtColor(large_image, roi_gray_image, CV_RGB2GRAY);
imshow("test", roi_gray_image);
waitKey(1000);


//中值滤波 增强边缘




//Candy 边缘检测
Mat candy_roi_image;
Canny(roi_gray_image, candy_roi_image, 450, 120, 3);
imshow("test", candy_roi_image);
imwrite("candy_roi_image.jpg", candy_roi_image);
waitKey(1000);
//二值化
Mat roi_threadhold_image;
threshold(candy_roi_image, roi_threadhold_image, 50, 255, CV_THRESH_BINARY);
imshow("test", roi_threadhold_image);
waitKey(1000);
imwrite("roi_threadhold_image.jpg", roi_threadhold_image);
//平滑处理 中值滤波
//Mat roi_blurr_image;
//medianBlur(roi_threadhold_image, roi_blurr_image, 1);
//imshow("test", roi_blurr_image);
//waitKey(1000);


//查找轮廓
Mat roi_contours_image;
vector<vector<Point>> roi_contours;
roi_contours_image = roi_threadhold_image.clone();
findContours(roi_contours_image, roi_contours, CV_RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
//画出轮廓
//drawContours(roi_contours_image, roi_contours, -1, Scalar(255), 2);
//imshow("test", roi_contours_image);
//waitKey(1000);


//轮廓表示成矩形
//轮廓表示为一个矩形  车牌提取
vector<Point> roi_rectPoint;
for (int i = 0; i < roi_contours.size(); i++) {
Rect r = boundingRect(Mat(roi_contours[i]));
//RotatedRect r = minAreaRect(Mat(contours[i]));
cout << "contours " << i << "  height = " << r.height << "  width = " << r.width << "rate = " << ((float)r.width / r.height) << endl;
cout << "r.x = " << r.x << "  r.y  = " << r.y << endl;




//rectangle(large_image, r, Scalar(0, 0, 255), 1);
Point p1, p2, p3, p4;
p1.x = r.x;
p1.y = r.y;
p2.x = r.x + r.width;
p2.x = r.y;
p3.x = r.x + r.width;
p3.y = r.y + r.height;
p4.x = r.x;
p4.y = r.y + r.height;


roi_rectPoint.push_back(p1);
roi_rectPoint.push_back(p2);
roi_rectPoint.push_back(p3);
roi_rectPoint.push_back(p4);
for (int j = 0; j < roi_contours[i].size(); j++) {
cout << "point = " << roi_contours[i][j] << endl;
}
}
imshow("test", roi_threadhold_image);
waitKey(1000);


//矩形轮廓特征提取
int contours_height[30], contours_width[30];
for (int i = 0; i < roi_contours.size(); i++) {
Rect r = boundingRect(Mat(roi_contours[i]));
contours_height[i] = r.height;
contours_width[i] = r.width;
cout << "contours_height = " << r.height << " contours_width = " << r.width << endl;
}


//判断字符水平位置
int roi_col = roi_threadhold_image.cols, roi_row = roi_threadhold_image.rows, position1[50], position2[50], roi_width[50];
uchar pix;
//cout << roi_threadhold_image << endl;

//确认为1 的像素
int pixrow[1000];
for (int i = 0; i < roi_col - 1; i++) {
for (int j = 0; j < roi_row - 1; j++) {
pix = roi_threadhold_image.at<uchar>(j, i);
pixrow[i] = 0;
if (pix > 0) {
pixrow[i] = 1;
break;
}
}
}
//对数组进行滤波，减少突变概率
for (int i = 2; i < roi_col - 1 - 2; i++) {
if ((pixrow[i - 1] + pixrow[i - 2] + pixrow[i + 1] + pixrow[i + 2]) >= 3) {
pixrow[i] = 1;
}
else if((pixrow[i - 1] + pixrow[i - 2] + pixrow[i + 1] + pixrow[i + 2]) <= 1) {
pixrow[i] = 0;
}
}
//确认字符位置
int count = 0;
bool flage = false;
for (int i = 0; i < roi_col - 1; i++) {
pix = pixrow[i];
if (pix == 1 && !flage) {
flage = true;
position1[count] = i;
continue;
}
if (pix == 0 && flage) {
flage = false;
position2[count] = i;
count++;
}
if (i == (roi_col - 2) && flage) {
flage = false;
position2[count] = i;
count++;
}
}
//记录所有字符宽度
for (int n = 0; n < count; n++) {
cout << " position1 = " << position2[n] <<" position2 = "<< position2[n] << "distance =" << (position2[n] - position1[n]) << endl;
roi_width[n] = position2[n] - position1[n];
}
// 减去最大值，最小值
int max = roi_width[0], max_index = 0;
int min = roi_width[0], min_index = 0;
for (int n = 1; n < count; n++) {
if (max < roi_width[n]) {
max = roi_width[n];
max_index = n;
}
if (min > roi_width[n]) {
min = roi_width[n];
min_index = n;
}
}
int index = 0;
int new_roi_width[50];
for (int i = 0; i < count; i++) {
if (i == min_index || i == max_index) {


}
else {
new_roi_width[index] = roi_width[i];
index++;
}
}
cout << "count = " << count << endl;
for (int i = 0; i < count - 2; i++) {
cout << "new roi width = " << new_roi_width[i] << endl;
}
//取后面三个值的平均值：
int avgre = (int)((new_roi_width[count - 3] + new_roi_width[count - 4] + new_roi_width[count - 5]) / 3.0);
cout << avgre << endl;
//for (int i = count-3; i < count - 6; i--) {
//if (i < 0) {
// break;
//}
//cout << "count = " << new_roi_width[i] << endl;
//}
//字母位置信息确认
int licenseX[10], licenseW[10], licenseNum = 0;
int countX = 0;
for (int i = 0; i < count; i++) {
if (roi_width[i] > (avgre - 8) && roi_width[i] < (avgre + 8)) {
licenseX[licenseNum] = position1[i];
licenseW[licenseNum] = roi_width[i];
licenseNum++;
cout << "licenseX = " << licenseX[i] << "  roi_width  =" << roi_width[i] << endl;
continue;
}
if (roi_width[i] > (avgre * 2 - 10) && roi_width[i] < (avgre * 2 + 10)) {
licenseX[licenseNum] = position1[i];
licenseW[licenseNum] = roi_width[i];
licenseNum++;
cout << "licenseX = " << licenseX[i] <<"  roi_width  ="<< roi_width[i]<< endl;
}
}


 //判断字符垂直位置
int licenseY[10], licenseH[10];
int position3[10], position4[10];
//确认为1 的像素
int countYY = 0;
int pixcol[1000], row_height[10];
for (int temp = 0; temp < licenseNum; temp++) {
for (int i = 0; i < roi_row - 1; i++) {
for (int j = licenseX[temp]; j < (licenseX[temp]+ licenseW[temp]); j++) {
pix = roi_threadhold_image.at<uchar>(i, j);
pixcol[i] = 0;
if (pix > 0) {
pixcol[i] = 1;
break;
}
}
}
//对数组进行滤波，减少突变概率
for (int i = 2; i < roi_row - 1 - 2; i++) {
if ((pixcol[i - 1] + pixcol[i - 2] + pixcol[i + 1] + pixcol[i + 2]) >= 3) {
pixcol[i] = 1;
}
else if ((pixcol[i - 1] + pixcol[i - 2] + pixcol[i + 1] + pixcol[i + 2]) <= 1) {
pixcol[i] = 0;
}
}
//确认字符位置
int countY = 0;
bool flage2 = false;
for (int i = 0; i < roi_row - 1; i++) {
pix = pixcol[i];
if (pix == 1 && !flage2) {
flage2 = true;
position3[countY] = i;
continue;
}
if (pix == 0 && flage2) {
flage2 = false;
position4[countY] = i;
countY++;
}
}

//记录所有字符宽度
for (int n = 0; n < countY; n++) {
cout << " position3 = " << position3[n] << " position4 = " << position4[n] << "distance =" << (position4[n] - position3[n]) << endl;
row_height[countYY] = position4[n] - position3[n];
licenseY[countYY] = position3[n];
licenseH[countYY] = row_height[countYY];
}
countYY++;
}

//截取字符
Mat licenseN = Mat(Scalar(0));
cout << "countYY = "<< countYY << endl;
for (int i = 0; i < countYY; i++) {
Rect rect(licenseX[i], licenseY[i], licenseW[i], licenseH[i]);
cout << "position = " << licenseX[i] << "  " << licenseY[i] << "  " << licenseW[i] << "  " << licenseH[i] << endl;
licenseN = large_image(rect);
imshow("test1"+i, licenseN);
ostringstream oss;
oss << "licenseN" << i << ".jpg";
imwrite(oss.str(), licenseN);
waitKey(1000);
}



cout << "license plate process" << endl;
return 0;
}



识别部分：

#include<opencv2/opencv.hpp>
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include <opencv2/ml/ml.hpp>
#include<iostream>
#include<sstream>
using namespace std;
using namespace cv;
using namespace ml;




float sumMatValue(const Mat & image) {
float sumValue = 0;
int r = image.rows;
int c = image.cols;
if (image.isContinuous()) {
c = r*c;
r = 1;
}
for (int i = 0; i < r; i++) {
const uchar *linePtr = image.ptr<uchar>(i);
for (int j = 0; j < c; j++) {
sumValue += linePtr[j];
}
}
return sumValue;
}
void calcGradientFeat(Mat & imgSrc, vector<float> & feat) {
Mat image;
cvtColor(imgSrc, image, CV_BGR2GRAY);
resize(image, image, Size(8, 16));
float mask[3][3] = { { 1,2,1 },{ 0,0,0 },{ -1,-2,-1 } };
Mat y_mask = Mat(3, 3, CV_32F, mask) / 8;
Mat x_mask = y_mask.t(); // 转置
Mat sobelX, sobelY;


filter2D(image, sobelX, CV_32F, x_mask);
filter2D(image, sobelY, CV_32F, y_mask);
sobelX = abs(sobelX);
sobelY = abs(sobelY);


float totleValueX = sumMatValue(sobelX);
float totleValueY = sumMatValue(sobelY);
for (int i = 0; i < image.rows; i = i + 4)
{
for (int j = 0; j < image.cols; j = j + 4)
{
Mat subImageX = sobelX(Rect(j, i, 4, 4));
feat.push_back(sumMatValue(subImageX) / totleValueX);
Mat subImageY = sobelY(Rect(j, i, 4, 4));
feat.push_back(sumMatValue(subImageY) / totleValueY);
}
}


Mat img2;
resize(image, img2, Size(4, 8));
int r = img2.rows;
int c = img2.cols;
if (img2.isContinuous()) {
c = r*c;
r = 1;
}
for (int i = 0; i < r; i++) {
const uchar *linePtr = img2.ptr<uchar>(i);
for (int j = 0; j < c; j++) {
feat.push_back(linePtr[j]);
}
}
//       cout<<sobelX<<endl;
//      cout<<sobelY<<endl;
// cout<< x_mask<<endl;
// cout<<img2<<endl;
// for(int i=0; i<feat[num].size(); i++)
//    {
//           cout<<feat[i]<<endl;
//    }
//       imshow("cat", img2);
//       cout<<"sumValue ="<<sumMatValue(image)<<endl;
}


Ptr<StatModel> buildMLPClassifier(Mat & input, Mat & output) {
Ptr<ANN_MLP> model;
//train classifier;
int layer_sz[] = { input.cols, 100 , output.cols };
int nlayers = (int)(sizeof(layer_sz) / sizeof(layer_sz[0]));
Mat layer_sizes(1, nlayers, CV_32S, layer_sz);
int method;
double method_param;
int max_iter;
if (1) {
method = ANN_MLP::BACKPROP;
method_param = 0.01;
max_iter = 100;
}
else {
method = ANN_MLP::RPROP;
method_param = 0.1;
max_iter = 1000;
}
Ptr<TrainData> tData = TrainData::create(input, ROW_SAMPLE, output);
model = ANN_MLP::create();
cout << "create success" << endl;
model->setLayerSizes(layer_sizes);
model->setActivationFunction(ANN_MLP::SIGMOID_SYM, 0, 0);
model->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, max_iter, FLT_EPSILON));
//setIterCondition(max_iter, 0);
model->setTrainMethod(method, method_param);
cout << "train data in process ...."<<endl;
model->train(tData);
cout << "train success" << endl;
model->save("mlp1.xml");
return model;
}
Ptr<StatModel> loadMLPClassifiler() {


Ptr<ANN_MLP> model = Algorithm::load<ANN_MLP>("mlp1.xml");
return model;
}




int main_num_reconginzed()
{
Mat image;
vector<float>feats;
vector<float>test, test1;
string path = "code/python_image_learn/identfying_code_recognize/charSamples/";
int num = 0;
int classfilternum = 34;
int modlenum = 30;
for (int i = 0; i < classfilternum; i++) {
for (int j = 0; j < modlenum; j++) {
ostringstream oss;
oss << path << i << "/" << j << ".png";
//cout<<oss.str()<<endl;
image = imread(oss.str());
calcGradientFeat(image, feats);
num++;


if (i == 11 && j == 10) {
ostringstream oss;
oss << path << i << "/" << (j + 1) << ".png";
//cout<<oss.str()<<endl;
image = imread(oss.str());
calcGradientFeat(image, test);
}
}
}
Mat input, output;
input = Mat(classfilternum*modlenum, 48, CV_32F);
output = Mat(classfilternum*modlenum, classfilternum, CV_32F, Scalar(0));
int r = input.rows;
int c = input.cols;
if (input.isContinuous()) {
c = r*c;
r = 1;
}
for (int i = 0; i < r; i++) {
float *linePtr = input.ptr<float>(i);
for (int j = 0; j < c; j++) {
linePtr[j] = feats[c*i + j];
}
}
for (int i = 0; i < output.rows; i++) {
float *lineoutput = output.ptr<float>(i);
lineoutput[i / modlenum] = 1;
}


//if(
//Ptr<StatModel> model = buildMLPClassifier(input, output);
Ptr<StatModel> model = loadMLPClassifiler();
float response = model->predict(test, test1);
cout << "response = " << response << endl;
for (int i = 0; i < test1.size(); i++)
{
cout << "test1 = " << test1[i] << endl;
}
//cout<<input<<endl;
//cout<<"rows = "<<input.rows<<"col = "<<input.cols<<endl;
//cout<<output<<endl;
    waitKey(0);                    //等待按键
system("pause");
return 0;
}
qq_40909394
关注
【OpenCV实战】简洁易懂的车牌号识别Python+OpenCV实现“超详解”（含代码）
qq_40784418的博客
04-22 8万+
简洁易懂的车牌号识别Python实现（含代码）1、整体思路2、代码详解 1、整体思路 2、代码详解
从零使用OpenCV快速实现简单车牌识别系统
热门推荐
Sparrowfc的专栏
11-17 3万+
从零使用OpenCV快速实现简单车牌识别系统 这篇文章献给所有第一次听说车牌识别ANPR但需要短时间实现的苦逼同学们。   最近的小学期实训做的是一个车牌识别系统，说实话真不知道学校怎么想的，虽然说图像处理也算的上是数字媒体很重要的一块分支了，但咱这几年学的全是图形渲染啊。图形与图像虽然只差了一个字，但内容真是差了十万八千里了（当然这话是夸张了，事实上在使用shader进行特效渲染的最后一步
车牌识别完整版 基于OPENCV3 完全实现车牌的字符提取 分割 识别 准确率高达95%
04-29
作者历经小半年的调试 才把程序调试好 完全可以实现车牌的字符识别，分割，提取，采用了SVM分类器和ANN神经网络，若下载后实现不了相应的功能，可以找作者把积分退还给大家
OpenCV车牌识别技术详解
极客代码
07-21 2313
本节介绍了OpenCV中的图像预处理技术，包括图像读取与显示、图像灰度化、图像二值化、图像形态学操作和图像轮廓提取。通过Python代码示例，展示了如何使用这些功能来处理车牌图像，为后续的车牌定位和字符分割做好准备。这些预处理步骤是车牌识别系统中不可或缺的部分，它们有助于提高识别的准确性和效率。后续文章将继续介绍OpenCV的其他功能模块和技术原理。本节介绍了OpenCV中的车牌定位技术，包括基于边缘检测的方法和基于颜色分割的方法。通过Python代码示例，展示了如何使用这些方法来定位车牌在图像中的位置。
车牌识别技术：从理论到实践的全面解析
最新发布
weixin_42298778的博客
09-12 1024
本文还有配套的精品资源，点击获取 简介：车牌识别技术在计算机视觉领域扮演着关键角色，应用于交通监控、停车场管理等场景。本文包涵了车牌识别过程中的关键步骤，包括图像预处理、车牌定位、车牌分割、字符分割和字符识别。深入探讨了深度学习模型在字符识别中的应用，并提供了相关学术论文链接及可能包含的代码或数据集资源。本技术的挑战和研究进展将为相关领域的专业人士提供宝贵的参考信息。 ...
opencv-python实战项目四：车牌识别
HanWenKing的博客
08-10 1472
随着科技的不断发展，车牌识别技术在智能交通、安防监控等领域得到了广泛应用。本文将介绍如何使用OpenCV库来实现车牌识别功能。通过学习本项目，您将掌握如何通过opencv以及ocr字符识别来进行车牌定位与识别。
采集图片的车牌识别
weixin_39800738的博客
08-05 1756
车牌识别是非常基础的案例，其中包括blob分析、形状特征的提取与转换、仿射变换等。 blob分析：从一幅图像将获取到相同特征、颜色的区域联合起来，然后按要求将不同区域提取出来。涉及到的技术包括去燥、滤波、二值化、图像分割等。 形状特征的提取与转换：每一块区域都有它自己的的形状特征，就好比世界上没有相同的树叶一样。提取就是通过特征筛选自己要的区域，转换就是区域转换成想要形状，一般是转换成矩形或圆形，...
车牌信息提取（OpenCV）
05-14
基于一个已经完成的车牌信息提取程序，能够做到对车牌位置的提取，角度校正，为之后的识别做好基础。
application.properties 不识别_如何用 Python 识别车牌，识别率竟然高达99%！
weixin_39900023的博客
11-09 248
车牌识别在高速公路中有着广泛的应用，比如我们常见的电子收费（ETC）系统和交通违章车辆的检测，除此之外像小区或地下车库门禁也会用到，基本上凡是需要对车辆进行身份检测的地方都会用到。简介车牌识别系统（Vehicle License Plate Recognition）是计算机视频图像识别技术在车辆牌照识别中的一种应用，通常一个车牌识别系统主要包括以下这四个部分：车辆图像获取车牌定位车牌字符分割车牌字...
基于OPENCV的智能车牌识别系统,基于opencv的车牌识别系统毕业设计,C,C++
09-10
总结，基于OpenCV的车牌识别系统利用其强大的图像处理和模式识别功能，能够有效地实现从图像中提取并识别车牌。通过不断优化和改进，这样的系统在交通管理、智能停车等领域具有广泛的应用前景。
C# OpenCvSharp 车牌颜色识别.rar
06-18
在本项目中，我们主要探讨的是使用C#编程语言结合OpenCvSharp库进行车牌颜色识别的技术。OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉和机器学习软件库，而OpenCvSharp是其为.NET ...
使用Opencv的车牌识别
lvquanye9483的博客
08-11 2万+
使用openCV识别车牌 流程框架 图像的预处理 车牌定位的第一步为图像预处理。为了方便计算，系统通常将获取的图片灰度化。将彩色图像转化成为灰度图像的过程就称为图像的灰度化处理。彩色图像中R、G、B三个分量的值决定了具体的像素点。一个像素点可以有上千万种颜色。而灰度图像是一种彩色图像，但是它的特点在于R、G、B三个分量具体的值是一致的。灰度图中每个像素点的变化区间是0到255，由...
基于Opencv+python的车牌识别系统，
05-05
总的来说，车牌识别系统结合了计算机视觉和机器学习的技术，通过OpenCV的图像处理功能和Python的便利性，实现了自动化、高效的车牌识别。实际应用中，系统性能会受到光照条件、车牌倾斜、字符模糊等因素的影响，因此...
基于opencv的车牌信息提取
weixin_45151279的博客
12-06 300
检索汽车牌照信息 第一次发文章，废话不多说，先来一个流程图。
基于OpenCV技术的汽车牌照的识别
sxdcfb的博客
04-21 3196
title: 基于OpenCV技术的汽车牌照的识别 OpenCV是一个基于BSD许可（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows、Android和Mac OS操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。 车牌识别技术要求能够将运动中的汽...
OpenCV（项目）车牌识别1 -- 车牌提取（形态学）
great_yzl的博客
09-02 1万+
一、车牌提取 1、读取图片，转灰度图 # 1、读取图片，转灰度图 img = cv.imread('Resource/car.jpg') gray = cv.cvtColor(img, cv.COLOR_RGB2GRAY) cv.imshow('gray', gray) 2、提取轮廓（Sobel算子提取y方向边缘） 为什么对Y方向取边缘：让图像变“瘦”，便于把车牌揉成一团。 # 2、提取轮廓（Sobel算子提取y方向） y = cv.Sob...
基于opencv的车牌识别（二）车牌定位与提取预处理操作思路
老狗识屠的博客
06-17 1万+
如题，我们这一篇博文的目的是为了将车牌提取出来的预处理，我将之总结为车牌特征提取。 （1）首先我们来看车牌部分与其他部分的区别，及车牌的特征，整体的车牌定位及提取方案即时基于此（基于灰度图像中考虑）： a.车牌部分是矩形 b.车牌具有特定的长宽比； c.车牌的面积一定 （2）接着我们对整幅图片进行预处理(车牌特征提取思路，实际代码部分可能为了更好的显示效果会稍加修改) a.图像转为灰度
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值