识别车牌是什么神经网络,车牌识别深度神经网络

1、急求用BP神经网络实现车牌识别的MATLAB程序代码

车牌识别技术(Vehicle License Plate Recognition，VLPR) 是计算机视频图像识别技术在车辆牌照识别中的一种应用。车牌识别技术要求能够将运动中的汽车牌照从复杂背景中提取并识别出来，通过车牌提取、图像预处理、特征提取、车牌字符识别等技术，识别车辆牌号，目前的技术水平为字母和数字的识别率可达到96%，汉字的识别率可达到95%。
附件为基于matlab的车牌识别的源程序（可以实现），其中包括车牌定位，车牌矫正，字符分割，字符识别4部分。还有已训练好的BP神经网络用于字符识别。

谷歌人工智能写作项目：小发猫

2、您好，请问您有基于BP神经网络算法的车牌识别的程序代码吗？用matlab可以运行的那种。

1、对样本集进行归一化
2、创建BP神经网络
3、设置网络的训练参数
4、把样本输入BP网络进行训练
5、把代识别的样本输入样本进行训练得到相应的结果，并输出参考：一个技术宅的学习笔记。
这就是构建BP神经网络的大致步骤

3、车牌识别程序

汽车牌照自动识别技术是一项利用车辆的动态视频或静态图像进行牌照号码、牌照颜色自动识别的模式识别技术。通过对图像的采集和处理，完成车牌自动识别功能，能从一幅图像中自动提取车牌图像，自动分割字符，进而对字符进行识别.其硬件基础一般包括触发设备(监测车辆是否进入视野)、摄像设备、照明设备、图像采集设备、识别车牌号码的处理机(如计算机)等，其软件核心包括车牌定位算法、车牌字符分割算法和光学字符识别算法等。某些牌照识别系统还具有通过视频图像判断车辆驶入视野的功能称之为视频车辆检测。

一、车牌识别技术流程剖解

车牌识别作为交通监控的核心技术，应用在多项子系统中，如闯红灯监测系统、超速监测系统、逆行监测系统、禁行监测系统、公交车道监测系统、非机动车道行车监测系统、压双黄线监测系统、紧急停车带行车监测系统、移动式车辆稽查系统等等。智能化多媒体网络车牌识别系统广泛应用在过往车辆自动登记、验证，公路收费，车辆安全核查，小区、停车场管理等方面。

系统采用视频实时触发方式进行检测抓拍，能够自动侦测、准确识别及验证行驶或停泊中车辆的整车车牌号码。可对已抓拍图像与数据库资料及时进行比对，当发现应拦截车辆时，系统能在本地机和中心机上及时报警。系统采用先进的模糊图像处理技术，通过程序能很好的实现对于车牌的整体倾斜、车牌的文字倾斜、车牌的污损和模糊等的处理，将人眼都很难辨别的车牌号识别出来。

优位停车车牌识别的流程可分为车牌定位、车牌预处理、字符分割和字符识别四个步骤。

二、系统实现功能和技术特点

准确识别不同地区及各种类型的车牌号码。

采用图像自动触发方式，不需要其他外在触发机制。

自动完成车辆记数，车流量统计。

对已抓拍图像能与数据库资料及时进行比对，当发现应拦截车辆时，在本地机和中心机上及时。

内置的数据库管理软件能存储、搜索及整理车辆资料，能自动备份数据并完成统计报告。

在网络的环境下实现各地的数据同步，可实时监控前端系统的运行状况。

对运动速度在180公里/小时以下的汽车车牌进行自动识别。

在良好光照条件下，车牌识别率不低于96%，在阴雨天、夜间人工光照条件下，车牌识别率不低于90%。系统能够识别的车牌类型包括：普通民用汽车车牌、军用汽车车牌(含武警车牌)、警用汽车车牌系统能够识别车辆类型，绘制出车辆的三维图像。

抓拍图像的时间小于0.03秒，识别图像的时间小于0.2秒。

系统适应全天候条件下工作。

三、停车场车牌识别应用

一个完整的牌照识别系统应包括车辆检测、图像采集、牌照识别等几部分。当车辆检测部分检测到车辆到达时触发图像采集单元，采集当前的视频图像。牌照识别单元对图像进行处理，定位出牌照位置，再将牌照中的字符分割出来进行识别，然后组成牌照号码输出。

（一）车辆检测

车辆检测可以采用埋地线圈检测、红外检测、雷达检测、视频检测等多种方式。采用视频检测可以避免破坏路面、不必附加外部检测设备、不需矫正触发位置、节省开支，而且更适合移动式、便携式应用的要求。

具备视频车辆检测功能的牌照识别系统，首先对视频信号中的一帧(场)的信号进行图像采集，数字化，得到对应的数字图像；然后对其进行分析，判断其中是否有车辆；若认为有车辆通行，则进入到下一步进行牌照识别；否则继续采集视频信号，进行处理。

系统进行视频车辆检测，需要具备很高的处理速度并采用优秀的算法，在基本不丢帧的情况下实现图像采集、处理。若处理速度慢，则导致丢帧，使系统无法正确检测到行驶速度较快的车辆，同时也难以保证在有利于识别的位置开始识别处理，影响系统识别率。因此，将视频车辆检测与牌照自动识别相结合具备一定的技术难度。

（二）牌照号码、颜色识别

为了进行牌照识别，需要以下几个基本的步骤：

牌照定位，定位图片中的牌照位置；

牌照字符分割，把牌照中的字符分割出来；

牌照字符识别，把分割好的字符进行识别，最终组成牌照号码。

牌照识别过程中，牌照颜色的识别依据算法不同，可能在上述不同步骤实现，通常与牌照识别互相配合、互相验证。

1、牌照定位

自然环境下，汽车图像背景复杂、光照不均匀，如何在自然背景中准确地确定牌照区域是整个识别过程的关键。首先对采集到的视频图像进行大范围相关搜索，找到符合汽车牌照特征的若干区域作为候选区，然后对这些侯选区域做进一步分析、评判，最后选定一个最佳的区域作为牌照区域，并将其从图象中分割出来。

2、牌照字符分割

完成牌照区域的定位后，再将牌照区域分割成单个字符，然后进行识别。字符分割一般采用垂直投影法。由于字符在垂直方向上的投影必然在字符间或字符内的间隙处取得局部最小值的附近，并且这个位置应满足牌照的字符书写格式、字符、尺寸限制和一些其他条件。利用垂直投影法对复杂环境下的汽车图像中的字符分割有较好的效果。

3、牌照字符识别

字符识别方法目前主要有基于模板匹配算法和基于人工神经网络算法。基于模板匹配算法首先将分割后的字符二值化，并将其尺寸大小缩放为字符数据库中模板的大小，然后与所有的模板进行匹配，最后选最佳匹配作为结果。基于人工神经元网络的算法有两种：一种是先对待识别字符进行特征提取，然后用所获得特征来训练神经网络分配器；另一种方法是直接把待处理图像输入网络，由网络自动实现特征提取直至识别出结果。

实际应用中，牌照识别系统的识别率与牌照质量和拍摄质量密切相关。牌照质量会受到各种因素的影响，如生锈、污损、油漆剥落、字体褪色、牌照被遮挡、牌照倾斜、高亮反光、多牌照、假牌照等等；实际拍摄过程也会受到环境亮度、拍摄亮度、车辆速度等等因素的影响。这些影响因素不同程度上降低了牌照识别的识别率，也正是牌照识别系统的困难和挑战所在。为了提高识别率，除了不断的完善识别算法，还应该想办法克服各种光照条件，使采集到的图像最利于识别。

车牌识别厂家哪家好？武汉车牌识别哪家好？首选优位停车，为用户提供2017停车系统设计方案效果图,整体报价。包括车牌识别停车场效果图、车牌识别设备,安装线材,车牌识别问题解答。武汉海量案例，政府单位，事业单位，工业物流园，小区，商场，医院，学校都广泛采用优位停车车牌识别系统。

4、求车牌识别中的倾斜矫正程序 MATLAB

最小二乘我没用过；倾斜校正用得比较多的是hough变换和randon变换；hough变换必须得在车牌二值化的时候出现边框，要是粗定位没有边框或本来车牌边框不明显就没辙了。所以貌似radon变换比较靠谱；也叫旋转投影法，鲁棒性也比较好。
我现在用的是改进的radon变换，以检测投影值的一阶导数累加值为基础。你可以先看看相关论文
下面是我的radon变换子程序，你可以参考一下
function [picbw_xz,angle_xz]=radon(temparea_gray)
%temparea_gray=rgb2gray(temparea);
[height,width]=size(temparea_gray);
level=ostugetT(temparea_gray,height,width);
picbw=im2bw(temparea_gray,level/255.0);
%figure(1);imshow(picbw);
sum_xz=zeros(21,height);
total_xz=zeros(1,21);
max_total=0;
for angle=-5:5
picbw_temp = imrotate(picbw,angle,'crop');
t=angle+11;%%
for i=1:height
sum_xz(t,i)=0;
for j=1:width
sum_xz(t,i)=sum_xz(t,i)+picbw_temp(i,j);
end
end
total_xz(t)=0;
for i=1:height-1
total_xz(t)=total_xz(t)+abs( sum_xz(t,i)-sum_xz(t,i+1) );
end
if total_xz(t)>max_total
angle_xz=angle;
picbw_xz=picbw_temp;
max_total=total_xz;
end
end
字符识别的话用BP神经网络好了，简单。
下面这段是用来训练神经网络的，BP网络的基础知识是必须的啊忍忍多看两遍就理解了。
文件夹下面有1～199张阿拉伯数字的样本图片，循环送到MATLAB中保存32×16×200的特征值，并与输出教师信号t对应,存在num_PT里头。
然后送到matlab的神经网络工具箱里面去训练。（相关资料百度文库里面也有）最后保存网络
% 引自《神经网络模型及其MATLAB仿真程序设计》一书P94～98
% 生成输入向量和目标向量
clear all;
'LOADING......'
for kk = 0:199
m=strcat('use_num\',int2str(kk),'.jpg');%
x=imread(m,'jpg'); %依次输入训练字符。
bw1=im2bw(x,0.5); %用0.5阈值进行二值化
for m=0:15
p(m*32+1:(m+1)*32,kk+1)=bw1(1:32,m+1);
end

switch kk
case{0,1,2,3,4,5,6,7,8,9,100,101,102,103,104,105,106,107,108,109}
t(:,kk+1)=[0 0 0 0 0 0 0]; % t(kk+1)记录了真实的数值
case{10,11,12,13,14,15,16,17,18,19,110,111,112,113,114,115,116,117,118,119}
t(:,kk+1)=[0 0 0 0 0 0 1];
case{20,21,22,23,24,25,26,27,28,29,120,121,122,123,124,125,126,127,128,129}
t(:,kk+1)=[0 0 0 0 0 1 0];
case{30,31,32,33,34,35,36,37,38,39,130,131,132,133,134,135,136,137,138,139}
t(:,kk+1)=[0 0 0 0 0 1 1];
case{40,41,42,43,44,45,46,47,48,49,140,141,142,143,144,145,146,147,148,149}
t(:,kk+1)=[0 0 0 0 1 0 0];
case{50,51,52,53,54,55,56,57,58,59,150,151,152,153,154,155,156,157,158,159}
t(:,kk+1)=[0 0 0 0 1 0 1];
case{60,61,62,63,64,65,66,67,68,69,160,161,162,163,164,165,166,167,168,169}
t(:,kk+1)=[0 0 0 0 1 1 0];
case{70,71,72,73,74,75,76,77,78,79,170,171,172,173,174,175,176,177,178,179}
t(:,kk+1)=[0 0 0 0 1 1 1];
case{80,81,82,83,84,85,86,87,88,89,180,181,182,183,184,185,186,187,188,189}
t(:,kk+1)=[0 0 0 1 0 0 0];
case{90,91,92,93,94,95,96,97,98,99,190,191,192,193,194,195,196,197,198,199}
t(:,kk+1)=[0 0 0 1 0 0 1];
end
end
'LOAD OK.'
save num_PT p t;
% 创建和训练BP网络
load num_PT p t;
pr(1:512,1)=0;
pr(1:512,2)=1;
net=newff(pr,[30 7],{'logsig' 'logsig'}, 'traingdx', 'learngdm');% pr为输入节点 [25 1]隐层数目 {。。。}为隐层传输函数
net.trainParam.epochs=3000; %最大训练步数 %Backpropagation network training function %%%%Backpropagation weight/bias learning function
%net.trainParam.goal=0.0001; %训练目标误差
net.trainParam.show=10; %显示训练结果的间隔步数
net.trainParam.lr=0.01; %学习速度
net=train(net,p,t)
'TRAIN OK.'
save num_PT net;
保存好的网络num_PT net说白了就是记录权值系数的矩阵，在识别的地方调用这些系数与待识别的特征值相乘；得到的t就是识别结果

5、求c或者c++的神经网络车牌识别代码，参考一下

#pragma hdrstop
#include
#include
const A=30.0;
const B=10.0;
const MAX=500; //最大训练次数
const COEF=0.0035; //网络的学习效率
const BCOEF=0.001;//网络的阀值调整效率
const ERROR=0.002 ; // 网络训练中的允许误差
const ACCURACY=0.0005;//网络要求精度
double sample[41][4]={{0,0,0,0},{5,1,4,19.020},{5,3,3,14.150},
{5,5,2,14.360},{5,3,3,14.150},{5,3,2,15.390},
{5,3,2,15.390},{5,5,1,19.680},{5,1,2,21.060},
{5,3,3,14.150},{5,5,4,12.680},{5,5,2,14.360},
{5,1,3,19.610},{5,3,4,13.650},{5,5,5,12.430},
{5,1,4,19.020},{5,1,4,19.020},{5,3,5,13.390},
{5,5,4,12.680},{5,1,3,19.610},{5,3,2,15.390},
{1,3,1,11.110},{1,5,2,6.521},{1,1,3,10.190},
{1,3,4,6.043},{1,5,5,5.242},{1,5,3,5.724},
{1,1,4,9.766},{1,3,5,5.870},{1,5,4,5.406},
{1,1,3,10.190},{1,1,5,9.545},{1,3,4,6.043},
{1,5,3,5.724},{1,1,2,11.250},{1,3,1,11.110},
{1,3,3,6.380},{1,5,2,6.521},{1,1,1,16.000},
{1,3,2,7.219},{1,5,3,5.724}};
double w[4][10][10],wc[4][10][10],b[4][10],bc[4][10];
double o[4][10],netin[4][10],d[4][10],differ;//单个样本的误差
double is; //全体样本均方差
int count,a;
void netout(int m, int n);//计算网络隐含层和输出层的输出
void calculd(int m,int n); //计算网络的反向传播误差
void calcalwc(int m,int n);//计算网络权值的调整量
void calcaulbc(int m,int n); //计算网络阀值的调整量
void changew(int m,int n); //调整网络权值
void changeb(int m,int n);//调整网络阀值
void clearwc(int m,int n);//清除网络权值变化量wc
void clearbc(int m,int n);//清除网络阀值变化量bc
void initialw(void);//初始化NN网络权值W
void initialb(void); //初始化NN网络阀值
void calculdiffer(void);//计算NN网络单个样本误差
void calculis(void);//计算NN网络全体样本误差
void trainNN(void);//训练NN网络
/*计算NN网络隐含层和输出层的输出 */
void netout(int m,int n)
{
int i,j,k;
//隐含层各节点的的输出
for (j=1,i=2;j<=m;j++) //m为隐含层节点个数
{
netin[i][j]=0.0;
for(k=1;k<=3;k++)//隐含层的每个节点均有三个输入变量
netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];
netin[i][j]=netin[i][j]-b[i][j];
o[i][j]=A/(1+exp(-netin[i][j]/B));
}
//输出层各节点的输出
for (j=1,i=3;j<=n;j++)
{
netin[i][j]=0.0;
for (k=1;k<=m;k++)
netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];
netin[i][j]=netin[i][j]-b[i][j];
o[i][j]=A/(1+exp(-netin[i][j]/B)) ;
}
}
/*计算NN网络的反向传播误差*/
void calculd(int m,int n)
{
int i,j,k;
double t;
a=count-1;
d[3][1]=(o[3][1]-sample[a][3])*(A/B)*exp(-netin[3][1]/B)/pow(1+exp(-netin[3][1]/B),2);
//隐含层的误差
for (j=1,i=2;j<=m;j++)
{
t=0.00;
for (k=1;k<=n;k++)
t=t+w[i+1][j][k]*d[i+1][k];
d[i][j]=t*(A/B)*exp(-netin[i][j]/B)/pow(1+exp(-netin[i][j]/B),2);
}
}
/*计算网络权值W的调整量*/
void calculwc(int m,int n)
{
int i,j,k;
// 输出层（第三层）与隐含层（第二层）之间的连接权值的调整
for (i=1,k=3;i<=m;i++)
{
for (j=1;j<=n;j++)
{
wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];
}
// printf("\n");
}
//隐含层与输入层之间的连接权值的调整
for (i=1,k=2;i<=m;i++)
{
for (j=1;j<=m;j++)
{
wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];
}
// printf("\n");
}
}
/*计算网络阀值的调整量*/
void calculbc(int m,int n)
{
int j;
for (j=1;j<=m;j++)
{
bc[2][j]=BCOEF*d[2][j];
}
for (j=1;j<=n;j++)
{
bc[3][j]=BCOEF*d[3][j];
}
}
/*调整网络权值*/
void changw(int m,int n)
{
int i,j;
for (i=1;i<=3;i++)
for (j=1;j<=m;j++)
{
w[2][i][j]=0.9*w[2][i][j]+wc[2][i][j];
//为了保证系统有较好的鲁棒性，计算权值时乘惯性系数0.9
printf("w[2][%d][%d]=%f\n",i,j,w[2][i][j]);
}
for (i=1;i<=m;i++)
for (j=1;j<=n;j++)
{
w[3][i][j]=0.9*w[3][i][j]+wc[3][i][j];
printf("w[3][%d][%d]=%f\n",i,j,w[3][i][j]);
}
}
/*调整网络阀值*/
void changb(int m,int n)
{
int j;
for (j=1;j<=m;j++)
b[2][j]=b[2][j]+bc[2][j];
for (j=1;j<=n;j++)
b[3][j]=b[3][j]+bc[3][j];
}
/*清除网络权值变化量wc*/
void clearwc(void)
{
for (int i=0;i<4;i++)
for (int j=0;j<10;j++)
for (int k=0;k<10;k++)
wc[i][j][k]=0.00;
}
/*清除网络阀值变化量*/
void clearbc(void)
{
for (int i=0;i<4;i++)
for (int j=0;j<10;j++)
bc[i][j]=0.00;
}
/*初始化网络权值W*/
void initialw(void)
{
int i,j,k,x;
double weight;
for (i=0;i<4;i++)
for (j=0;j<10;j++)
for (k=0;k<10;k++)
{
randomize();
x=100+random(400);
weight=(double)x/5000.00;
w[i][j][k]=weight;
}
}
/*初始化网络阀值*/
void initialb(void)
{
int i,j,x;
double fazhi;
for (i=0;i<4;i++)
for (j=0;j<10;j++)
{
randomize();
for (int k=0;k<12;k++)
{
x=100+random(400);
}
fazhi=(double)x/50000.00;
b[i][j]=fazhi;
}
}
/*计算网络单个样本误差*/
void calculdiffer(void)
{
a=count-1;
differ=0.5*(o[3][1]-sample[a][3])*(o[3][1]-sample[a][3]);
}
void calculis(void)
{
int i;
is=0.0;
for (i=0;i<=19;i++)
{
o[1][1]=sample[i][0];
o[1][2]=sample[i][1];
o[1][3]=sample[i][2];
netout(8,1);
is=is+(o[3][1]-sample[i][3])*(o[3][1]-sample[i][3]);
}
is=is/20;
}
/*训练网络*/
void trainNN(void)
{
long int time;
int i,x[4];
initialw();
initialb();
for (time=1;time<=MAX;time++)
{
count=0;
while(count<=40)
{
o[1][1]=sample[count][0];
o[1][2]=sample[count][1];
o[1][3]=sample[count][2];
count=count+1;
clearwc();
clearbc();
netout(8,1);
calculdiffer();
while(differ>ERROR)
{
calculd(8,1);
calculwc(8,1);
calculbc(8,1);
changw(8,1);
changb(8,1);
netout(8,1);
calculdiffer();
}
}
printf("This is %d times training NN...\n",time);
calculis();
printf("is==%f\n",is);
if (is }
}
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
double result;
int m,test[4];
char ch='y';
cout<<"Please wait for the train of NN:"< trainNN();
cout<<"Now,this modular network can work for you."< while(ch=='y' || ch=='Y')
{
cout<<"Please input data to be tested."< for (m=1;m<=3;m++)
cin>>test[m];
ch=getchar();
o[1][1]=test[1];
o[1][2]=test[2];
o[1][3]=test[3];
netout(8,1);
result=o[3][1];
printf("Final result is %f.\n",result);
printf("Still test?[Yes] or [No]\n");
ch=getchar();
}
return 0;
}

6、如何实现车牌自动识别

车牌自动识别管理系统将火眼臻睛车牌识别摄像机在入口拍摄的车辆车牌号码图象自动识别并转换成数字信号。同时自动比对进出车辆，方便了管理人员在车辆出场时进行比对，大大增强了系统的安全性。升级后的摄像系统可以采集更清晰的图片，作为档案保存，可以为一些纠纷提供有力的证据。

• 原理就是通过摄像机拍摄道路上行驶的车辆图像进行车牌号码的识别，过程涉及：车辆检测—图像采集—预处理—车牌定位—字符分割—字符识别—结果输出。

• 车辆检测：可采用埋地线圈检测、红外检测、雷达检测技术、视频检测等多种方式感知车辆的经过，并触发图像采集抓拍。

• 图像采集：通过高清摄像抓拍主机对通行车辆进行实时、不间断记录、采集。

• 预处理：噪声过滤、自动白平衡、自动曝光以及伽马校正、边缘增强、对比度调整等。

• 车牌定位：在经过图像预处理之后的灰度图像上进行行列扫描，确定车牌区域。

• 字符分割：在图像中定位出车牌区域后，通过灰度化、二值化等处理，精确定位字符区域，然后根据字符尺寸特征进行字符分割。

• 字符识别：对分割后的字符进行缩放、特征提取，与字符数据库模板中的标准字符表达形式进行匹配判别。

• 结果输出：将车牌识别的结果以文本格式输出。