图像边缘检测各种算子MATLAB实现以及实际应用

《图像处理中的数学方法》实验报告
学生姓名：赵芳舟
教师姓名：曾理
学院：数学与统计学院
专业：信息与计算科学
学号：
联系方式：
梯度和拉普拉斯算子在图像边缘检测中的应用
一、数学方法
边缘检测最通用的方法是检测灰度值的不连续性，这种不连续性用一阶和二阶导数来检测。

1.（1）一阶导数：一阶导数即为梯度，对于平面上的图像来说，我们只需用到二维函数
的梯度，即：,该向量的幅值：
,为简化计算，省略上式平方根，得到近似值；或通过取绝对值来近似，得到：。

（2）二阶导数：二阶导数通常用拉普拉斯算子来计算，由二阶微分构成：
2.边缘检测的基本思想：
（1）寻找灰度的一阶导数的幅度大于某个指定阈值的位置；
（2）寻找灰度的二阶导数有零交叉的位置。

3.几种方法简介
（1）Sobel边缘检测器：以差分来代替一阶导数。

Sobel边缘检测器使用一个3×3邻域的行和列之间的离散差来计算梯度，其中，每行或每列的中心像素用2来
加权，以提供平滑效果。

-1-21
000
121
-101
-202
-101
（2）Prewitt边缘检测器:使用下图所示模板来数字化地近似一阶导数。

与Sobel检测器相比，计算上简单一些，但产生的结果中噪声可能会稍微大一些。

-1-1-1
000
111
-101
-101
-101
（3）Roberts边缘检测器：使用下图所示模板来数字化地将一阶导数近似为相邻像素之间的差，它与前述检测器相比功能有限（非对称，且不能检测多种45°倍数的边缘）。

-10
01
0-1
10
（4）Laplace边缘检测器：二维函数的拉普拉斯是一个二阶的微分定义：
010
1-41
010
（八邻域）
（5）LoG边缘检测器
由于噪声点（灰度与周围点相差很大的像素点）对边缘检测有一定的影响，所以效果更好的是LoG算子，即Laplacian-Guass算子。

引入高斯函数来平滑噪声：
该函数的Laplace算子：
它把Guass平滑滤波器和Laplace锐化滤波器结合起来，先平滑掉噪声，再进行边缘检测，所以效果比单用Laplace算子要更为平滑，效果更好。

（6）Canny边缘检测器
主要分为以下几个步骤：①使用具有指定标准差的一个高斯滤波器来平滑图像，以减少噪声；②在每个点处计算局部梯度和边缘方向；③对步骤②中确定的边缘点产生梯度中的脊线顶部进行追踪，并将实际山不在脊线顶部的像素设置为零，从而在输出中给出一条细线（非最大值抑制），然后使用滞后阈值处理法对这些脊线像素进行阈值处理。

最后进行边缘连接。

二、实验结果
原始图像：
算子
算子
算子
算子
（4邻域）
（8邻域）
5.LoG
四种结果的比较：（Laplace采用8邻域模板）
图像来源：（网行天下首页>>设计图库>>文化艺术>>插画集：《牧羊犬灰度》）
图像规格：800×677 格式：SVG 模式：RGB
硬件条件：
软件条件：运行环境：Matlab r2015b
三、讨论
1.各方法优缺点及比较：
（1）Roberts算子：Roberts算子是2×2算子，对具有陡峭的低噪声图像响应最好，并且检测垂直边缘的效果好于斜向边缘，定位精度高。

然而，它对噪声敏感，无法抑制噪声的影
响。

因此，它适用于边缘明显且噪声较少的图像分割。

（2）Prewitt算子：Prewitt算子将两个点的各自一定领域内的灰度值求和，并根据两个灰度值和的差来计算x,y的偏导数。

它是平均滤波，对噪声有抑制作用，对于灰度渐变的低噪声图像有较好的检测效果，但是像素平均相当于对图像的低通滤波，所以它对边缘的定位不如Roberts算子。

对于混合多复杂噪声的图像，效果不太理想。

（3）Sobel算子：Sobel算子是滤波算子的形式，用于提取边缘，可以利用快速卷积函数，简单有效，因此应用广泛。

美中不足的是，Sobel算子并没有将图像的主体与背景严格地区分开来，即Sobel算子没有严格地模拟人的视觉生理特征，所以提取的图像轮廓有时并不能令人满意。

（4）Laplace算子：Laplace算子是一种各向同性算子，在只关心边缘的位置而不考虑其周围的象素灰度差值时比较合适。

Laplace算子对孤立象素的响应要比对边缘或线的响应要更强烈，因此只适用于无噪声图象。

存在噪声情况下，使用Laplacian算子检测边缘之前需要先进行低通滤波。

（5）LoG算子：由于二阶导数是线性运算，利用LoG卷积一幅图像与首先使用高斯型平滑函数卷积改图像，然后计算所得结果的拉普拉斯是一样的。

所以在LoG公式中使用高斯函数的目的就是对图像进行平滑处理，使用Laplacian算子的目的是提供一幅用零交叉确定边缘位置的图像；图像的平滑处理减少了噪声的影响并且它的主要作用还是抵消由Laplacian
算子的二阶导数引起的逐渐增加的噪声影响。

（6）Canny算子：是一个具有滤波，增强和检测的多阶段的优化算子，在进行处理前，Canny 算子先利用高斯平滑滤波器来平滑图像以消除噪声，Canny分割算法采用一阶偏导的有限差分来计算梯度的幅值和方向。

在处理过程中，Canny算法还将经过一个非极大值抑制的过程。

最后Canny算法将采用两个阈值来连接边缘。

高定位精度、低误判率、抑制虚假边缘，适用于高噪声图像。

四、实际应用
1、概述：图像边缘检测广泛应用于车牌识别，人脸识别，地震带检测，生物医疗以及产品外观检测等方面。

为了体现其实际应用，在此针对车牌识别来进行实验，实验流程如下：
3、实验结果
原图像：
灰度处理：将彩色图像转化为灰度图像，缩小图片占用的空间，减少处理时间
边缘检测：车牌区域的边缘信息一般比其他部分丰富且集中，只要 背景不太复杂，没有过多干扰，边缘特征可将车牌区域与其他部分区别开来，从而消除图像中的无关信息。

腐蚀和膨胀：腐蚀可以分割独立的图像元素，膨胀用于连接相邻的元素，更加利于图像的分割
最后将车牌号分割成七个单个字符，建立模板库，与其进行配对，最终得出结果。

五、程序介绍
（1） Roberts 边缘检测
clear;
sourcePic=imread('C:\Users\34899\Desktop\'); %读取原图像
grayPic=mat2gray(sourcePic); %实现图像矩阵的归一化操作
[m,n]=size(grayPic);
newGrayPic=grayPic;%为保留图像的边缘一个像素
robertsNum=0; %经roberts 算子计算得到的每个像素的值
robertThreshold=; %设定阈值
for j=1:m-1 %进行边界提取
for k=1:n-1
robertsNum = abs(grayPic(j,k)-grayPic(j+1,k+1)) +
abs(grayPic(j+1,k)-grayPic(j,k+1));
if(robertsNum > robertThreshold)
newGrayPic(j,k)=255;
else
newGrayPic(j,k)=0;
end
end
end
subplot(1,2,1);imshow(sourcePic);title('原图');
subplot(1,2,2);imshow(newGrayPic);title('Robert算子处理后图像');
（2）Prewitt边缘检测
clear;
sourcePic=imread('C:\Users\34899\Desktop\'); %读取原图像
grayPic=mat2gray(sourcePic);%实现图像矩阵的归一化操作
[m,n]=size(grayPic);
newGrayPic=grayPic;%为保留图像的边缘一个像素
PrewittNum=0;%经Prewitt算子计算得到的每个像素的值
PrewittThreshold=;%设定阈值
for j=2:m-1 %进行边界提取
for k=2:n-1
PrewittNum=abs(grayPic(j-1,k+1)-grayPic(j+1,k+1)+grayPic(j-1,k
)-grayPic(j+1,k)+grayPic(j-1,k-1)-grayPic(j+1,k-1))+abs(grayPic(j-1,k+1)+g rayPic(j,k+1)+grayPic(j+1,k+1)-grayPic(j-1,k-1)-grayPic(j,k-1)-grayPic(j+1,k-
1));
if(PrewittNum > PrewittThreshold)
newGrayPic(j,k)=255;
else
newGrayPic(j,k)=0;
end
end
end
subplot(1,2,1);imshow(sourcePic);title('原图');
subplot(1,2,2);imshow(newGrayPic);title('Prewitt算子处理后图像');
（3）Sobel边缘检测
clear all;
close all;
imag = imread('C:\Users\34899\Desktop\'); %读取关键帧
imag = rgb2gray(imag); %转化为灰度图
subplot(1,2,1);imshow(imag);title('原图');
[high,width] = size(imag); % 获得图像的高度和宽度
F2 = double(imag);
U = double(imag);
uSobel = imag;
for i = 2:high - 1 %sobel边缘检测
for j = 2:width - 1
Gx = (U(i+1,j-1) + 2*U(i+1,j) + F2(i+1,j+1)) - (U(i-1,j-1) + 2*U(i-1,j) + F2(i-1,j+1));
Gy = (U(i-1,j+1) + 2*U(i,j+1) + F2(i+1,j+1)) - (U(i-1,j-1) + 2*U(i,j-1) + F2(i+1,j-1));
uSobel(i,j) = sqrt(Gx^2 + Gy^2);
end
end
subplot(1,2,2);imshow(im2uint8(uSobel)):title('Sobel边缘检测后');
（4）Laplace边缘检测
主函数：
f=imread('C:\Users\34899\Desktop\')
fGray=rgb2gray(f);
figure()
imshow(fGray),title('灰度图像');
fGray=double(fGray);
T=60;
LapModType=8;%设置laplace模板方式
fLapEdge=LaplaceEdge(fGray,LapModType,T);
fGrayLapEdge=uint8(fLapEdge);
figure()
imshow(fLapEdge),title('laplace边缘图像');
四邻域算子和八邻域算子
function fLapEdge=LaplaceEdge(fGray,MoldType,Thresh)
%-------------------------参数介绍-----------------
%输入参数：
% fGray;输入的灰度图像
% MoldType:模板类型，包括四邻域和八邻域
% Thresh:边缘检测阈值
%输出参数：
% fEdge:边缘像素点，存储的是二值化图像
[r,c]=size(fGray);
fLapEdge=zeros(r,c);
%四邻域拉普拉斯边缘检测算子
if 4==MoldType
for i=2:r-1
for j=2:c-1
Temp=-4*fGray(i,j)+fGray(i-1,j)+fGray(i+1,j)+fGray(i,j-1)+fGray(i,j+1);
if Temp>Thresh
fLapEdge(i,j)=255;
else
fLapEdge(i,j)=0;
end
end
end
end
%八邻域拉普拉斯边缘检测算子
if 8==MoldType
for i=2:r-1
for j=2:c-1
Temp=-8*fGray(i,j)+fGray(i-1,j)+fGray(i+1,j)+fGray(i,j-1)+fGray(i,j+1)+fGray(i-1,j-1)+fGray(i+1,j+1)+fGray(i+1,j-1)+fGray(i-1,j+1);
if Temp>Thresh
fLapEdge(i,j)=255;
else
fLapEdge(i,j)=0;
end
end
end
End
（5）拉普拉斯—高斯检测器
clc; clear all;
close all;
hsize = [5 5];
sigma = ;
h = fspecial('log', hsize, sigma);
I = imread('C:\Users\34899\Desktop\');
bw = imfilter(I, h, 'replicate');
figure;
subplot(1, 2, 1); imshow(I, []); title('原图像', 'FontWeight', 'Bold');
subplot(1, 2, 2); imshow(bw, []); title('边缘图像', 'FontWeight', 'Bold');
（6）Canny算子
tic % 记录CPU使用时间，开始计时
I = imread('C:\Users\34899\Desktop\'); % 读入图像
I=rgb2gray(I); % 转化为灰色图像
% figure,imshow(I);title('原图') % 显示原图像
% a = im2single(I); % 将图像矩阵转换为单精度类型
% a = im2uint8(a); % 将图像矩阵转换为8位无符号整数类型
% I = uint16(I); % 8位无符号整数转化为16位无符号整数
%**************************** matlab的高斯平滑 **************************** [row,line] = size(I); % 行列
temp = zeros(row+8,line+8); % 申请空间
imagedata = zeros(row,line); % 申请空间
% 高斯核计算,核大小为9*9
GaussianDieOff = .0001;
sigma = 1;
pw = 1:30; % possible widths
ssq = sigma^2;
width = find(exp(-(pw.*pw)/(2*ssq))>GaussianDieOff,1,'last');
if isempty(width)
width = 1; % the user entered a really small sigma
end
t = (-width:width);
gau = exp(-(t.*t)/(2*ssq))/(2*pi*ssq);
kernel = gau' * gau; % 高斯核,大小为9*9
kernel = im2single(kernel);
% 图像边缘复制
for q = 5:row+4 % 首先载入源图像信息
for p = 5:line+4
temp(q,p) = I(q-4,p-4);
end
end
for q = 1:row+8 % 复制列5:line+4
for p = 5:line+4
if(q<5)
temp(q,p) = temp(5,p);
end
if(q>row+4)
temp(q,p) = temp(row+4,p);
end
end
end
for q = 1:row+8 % 复制行1:row+8
for p = 1:line+8
if(p<5)
temp(q,p) = temp(q,5);
end
if(p>line+4)
temp(q,p) = temp(q,line+4);
end
end
end
for q = 1:row % 高斯卷积
for p = 1:line
for n = 1:9
for m = 1:9
imagedata(q,p) = imagedata(q,p) + kernel(n,m) * temp(q+n-1,p+m-1);
end
end
end
end
%************************ matlab的高斯平滑说明结束 ************************
%****************************** matlab求梯度 ******************************
dx = zeros(size(I)); % 申请空间,存放x方向的幅值
dy = zeros(size(I)); % 申请空间,存放y方向的幅值
[x,y]=meshgrid(-width:width,-width:width);
dgau2D=-x.*exp(-(x.*x+y.*y)/(2*ssq))/(pi*ssq); % 核
% 图像边缘复制
for q = 5:row+4 % 首先载入源图像信息
for p = 5:line+4
temp(q,p) = imagedata(q-4,p-4);
end
end
for q = 1:row+8 % 复制列5:line+4
for p = 5:line+4
if(q<5)
temp(q,p) = temp(5,p);
end
if(q>row+4)
temp(q,p) = temp(row+4,p);
end
end
end
for q = 1:row+8 % 复制行1:row+8
for p = 1:line+8
if(p<5)
temp(q,p) = temp(q,5);
end
if(p>line+4)
temp(q,p) = temp(q,line+4);
end
end
end
for q = 1:row % x方向卷积
for p = 1:line
for n = 1:9
for m = 1:9
dx(q,p) = dx(q,p) + dgau2D(n,m) * temp(q+n-1,p+m-1);
end
end
end
end
dgau2D = dgau2D';
for q = 1:row % y方向卷积
for p = 1:line
for n = 1:9
for m = 1:9
dy(q,p) = dy(q,p) + dgau2D(n,m) * temp(q+n-1,p+m-1);
end
end
end
end
%**************************** matlab求梯度结束 ****************************
%***************************** 自适应阈值计算 ***************************** value = sqrt(dx.^2 + dy.^2); % 幅值
value = double(value);
value = value/max(max(value));% 归一化
temp_value = value;
counts=imhist(value, 64);
high_threshold = find(cumsum(counts) > *row*line,1,'first') / 64;
low_threshold = * high_threshold; % 低阈值
clear counts
%*************************** 自适应阈值计算结束 ***************************
%***************************** 方向与阈值判别 ***************************** num = 0; % 当前堆栈个数
flag = zeros(80000,2); % 堆栈
temp_flag = zeros(80000,2); % 临时堆栈
imagedata = zeros(row,line); % 初始化
% 方向：
% 0为0°~45°
% 1为45°~90°
% 2为90°~135°
% 3为135°~180°
direction = zeros(size(I)); % 申请空间,存放小于高阈值而大于低阈值
for q = 2:row-1
for p = 2:line-1
if((dy(q,p)<=0 && dx(q,p)>-dy(q,p)) || (dy(q,p)>=0 && dx(q,p)<-dy(q,p))) d = abs(dy(q,p)/dx(q,p)); % 0°~45°方向
gradmag = temp_value(q,p);
gradmag1 = temp_value(q,p+1)*(1-d) + temp_value(q-1,p+1)*d;
gradmag2 = temp_value(q,p-1)*(1-d) + temp_value(q+1,p-1)*d;
elseif((dx(q,p)>0 && -dy(q,p)>=dx(q,p)) || (dx(q,p)<0 && -dy(q,p)<=dx(q,p))) d = abs(dx(q,p)/dy(q,p)); % 45°~90°方向
gradmag = temp_value(q,p);
gradmag1 = temp_value(q-1,p)*(1-d) + temp_value(q-1,p+1)*d;
gradmag2 = temp_value(q+1,p)*(1-d) + temp_value(q+1,p-1)*d;
elseif((dx(q,p)<=0 && dx(q,p)>dy(q,p)) || (dx(q,p)>=0 && dx(q,p)<dy(q,p))) d = abs(dx(q,p)/dy(q,p)); % 90°~135°方向
gradmag = temp_value(q,p);
gradmag1 = temp_value(q-1,p)*(1-d) + temp_value(q-1,p-1)*d;
gradmag2 = temp_value(q+1,p)*(1-d) + temp_value(q+1,p+1)*d;
elseif((dy(q,p)<0 && dx(q,p)<=dy(q,p)) || (dy(q,p)>0 && dx(q,p)>=dy(q,p))) d = abs(dy(q,p)/dx(q,p)); % 135°~180°方向
gradmag = temp_value(q,p);
gradmag1 = temp_value(q,p-1)*(1-d) + temp_value(q-1,p-1)*d;
gradmag2 = temp_value(q,p+1)*(1-d) + temp_value(q+1,p+1)*d;
end
if(gradmag>=gradmag1 && gradmag>=gradmag2)
if(gradmag >= high_threshold) % 高阈值判别
value(q,p) = 255;
elseif(gradmag >= low_threshold)% 低阈值判别
value(q,p) = 125;
else
value(q,p) = 0; % 小于低阈值
end
else
value(q,p) = 0; % 非极大值抑制
end
end
end
for q = 2:row-1 % 高阈值判别，检查高阈值邻域8个方向范围内是否存在低阈值for p = 2:line-1
if(value(q,p) == 255)
imagedata(q,p) = 255;
if(value(q-1,p-1) == 125)
value(q-1,p-1) = 255;
imagedata(q-1,p-1) = 255;
if((q-1 > 1) && (p-1 > 1))
num = num + 1;
flag(num,1) = q-1;
flag(num,2) = p-1;
end
end
if(value(q-1,p) == 125)
value(q-1,p) = 255;
imagedata(q-1,p) = 255;
if(q-1 > 1)
num = num + 1;
flag(num,1) = q-1;
flag(num,2) = p;
end
end
if(value(q-1,p+1) == 125)
value(q-1,p+1) = 255;
imagedata(q-1,p+1) = 255;
if((q-1 > 1) && (p+1 < line)) num = num + 1;
flag(num,1) = q-1;
flag(num,2) = p+1;
end
end
if(value(q,p-1) == 125)
value(q,p-1) = 255;
imagedata(q,p-1) = 255;
if(p-1 > 1)
num = num + 1;
flag(num,1) = q;
flag(num,2) = p-1;
end
end
if(value(q,p+1) == 125)
value(q,p+1) = 255;
imagedata(q,p+1) = 255;
if(p+1 < line)
num = num + 1;
flag(num,1) = q;
flag(num,2) = p+1;
end
end
if(value(q+1,p-1) == 125)
value(q+1,p-1) = 255;
imagedata(q+1,p-1) = 255;
if((q+1 < row) && (p-1 > 1))
num = num + 1;
flag(num,1) = q+1;
flag(num,2) = p-1;
end
end
if(value(q+1,p) == 125)
value(q+1,p) = 255;
imagedata(q+1,p) = 255;
if(q+1 < row)
num = num + 1;
flag(num,1) = q+1;
flag(num,2) = p;
end
end
if(value(q+1,p+1) == 125)
value(q+1,p+1) = 255;
imagedata(q+1,p+1) = 255;
if((q+1 < row) && (p+1 < line)) num = num + 1;
flag(num,1) = q+1;
flag(num,2) = p+1;
end
end
end
end
end
done = num; % 完成标志,等于0表示当前连线已完成while done ~= 0
num = 0;
for temp_num = 1:done
q = flag(temp_num,1);
p = flag(temp_num,2);
if(value(q-1,p-1) == 125)
value(q-1,p-1) = 255;
imagedata(q-1,p-1) = 255;
if((q-1 > 1) && (p-1 > 1))
num = num + 1;
temp_flag(num,1) = q-1;
temp_flag(num,2) = p-1;
end
end
if(value(q-1,p) == 125)
value(q-1,p) = 255;
imagedata(q-1,p) = 255;
if(q-1 > 1)
num = num + 1;
temp_flag(num,1) = q-1; temp_flag(num,2) = p;
end
end
if(value(q-1,p+1) == 125)
value(q-1,p+1) = 255;
imagedata(q-1,p+1) = 255;
if((q-1 > 1) && (p+1 < line)) num = num + 1;
temp_flag(num,1) = q-1; temp_flag(num,2) = p+1;
end
end
if(value(q,p-1) == 125)
value(q,p-1) = 255;
imagedata(q,p-1) = 255;
if(p-1 > 1)
num = num + 1;
temp_flag(num,1) = q;
temp_flag(num,2) = p-1;
end
end
if(value(q,p+1) == 125)
value(q,p+1) = 255;
imagedata(q,p+1) = 255;
if(p+1 < line)
num = num + 1;
temp_flag(num,1) = q;
temp_flag(num,2) = p+1;
end
end
if(value(q+1,p-1) == 125)
value(q+1,p-1) = 255;
imagedata(q+1,p-1) = 255;
if((q+1 < row) && (p-1 > 1)) num = num + 1;
temp_flag(num,1) = q+1; temp_flag(num,2) = p-1;
end
end
if(value(q+1,p) == 125)
value(q+1,p) = 255;
imagedata(q+1,p) = 255;
if(q+1 < row)
num = num + 1;
temp_flag(num,1) = q+1;
temp_flag(num,2) = p;
end
end
if(value(q+1,p+1) == 125)
value(q+1,p+1) = 255;
imagedata(q+1,p+1) = 255;
if((q+1 < row) && (p+1 < line))
num = num + 1;
temp_flag(num,1) = q+1;
temp_flag(num,2) = p+1;
end
end
end
done = num;
flag = temp_flag;
end
%*************************** 方向与阈值判别结束 ***************************
%****************************** 目标图像显示 ****************************** imagedata = uint8(imagedata); % 16位无符号整数转化为8位无符号整数
figure,imshow(imagedata);title('canny算子检测后') % 显示非极大值抑制后的图像clear all
%**************************** 目标图像显示结束 ****************************
toc % 记录CPU使用时间，结束计时
（7）车牌号识别
2：代码（主函数）：
function [d]=main(jpg)
close all
clc
I=imread('C:\Users\34899\Desktop\');
figure(1),imshow(I);title('原图')
I1=rgb2gray(I);
figure(2),subplot(1,2,1),imshow(I1);title('灰度图');
figure(2),subplot(1,2,2),imhist(I1);title('灰度图直方图');
%I2=edge(I1,'robert',,'both');
%figure(3),imshow(I2);title('robert算子边缘检测')
sourcePic=imread('C:\Users\34899\Desktop\'); %读取原图像grayPic=mat2gray(sourcePic); %实现图像矩阵的归一化操作[m,n]=size(grayPic);
I2=grayPic;%为保留图像的边缘一个像素
robertsNum=0; %经roberts算子计算得到的每个像素的值robertThreshold=; %设定阈值
for j=1:m-1 %进行边界提取
for k=1:n-1
robertsNum = abs(grayPic(j,k)-grayPic(j+1,k+1)) + abs(grayPic(j+1,k)-grayPic(j,k+1));
if(robertsNum > robertThreshold)
I2(j,k)=255;
else
I2(j,k)=0;
end
end
end
figure(3),imshow(I2);title('Roberts算子检测后图像');
se=[1;1;1];
I3=imerode(I2,se);
figure(4),imshow(I3);title('腐蚀后图像');
se=strel('rectangle',[25,25]);
I4=imclose(I3,se);
figure(5),imshow(I4);title('平滑图像的轮廓');
I5=bwareaopen(I4,2000);
%figure(6),mesh(I5);title('从对象中移除小对象');
[y,x,z]=size(I5);
myI=double(I5);
tic
Blue_y=zeros(y,1);
for i=1:y
for j=1:x
if(myI(i,j,1)==1)
Blue_y(i,1)= Blue_y(i,1)+1;%蓝色像素点统计end
end
end
[temp MaxY]=max(Blue_y);%Y方向车牌区域确定
PY1=MaxY;
while ((Blue_y(PY1,1)>=5)&&(PY1>1))
PY1=PY1-1;
end
PY2=MaxY;
while ((Blue_y(PY2,1)>=5)&&(PY2<y))
PY2=PY2+1;
end
IY=I(PY1:PY2,:,:);
%%%%%% X方向 %%%%%%%%%
Blue_x=zeros(1,x);%进一步确定x方向的车牌区域
for j=1:x
for i=PY1:PY2
if(myI(i,j,1)==1)
Blue_x(1,j)= Blue_x(1,j)+1;
end
end
end
PX1=1;
while ((Blue_x(1,PX1)<3)&&(PX1<x))
PX1=PX1+1;
end
PX2=x;
while ((Blue_x(1,PX2)<3)&&(PX2>PX1))
PX2=PX2-1;
end
PX1=PX1-1;%对车牌区域的校正
PX2=PX2+1;
dw=I(PY1:PY2-8,PX1:PX2);
t=toc;
figure(7),subplot(1,2,1),imshow(IY),title('行方向合理区域');
figure(7),subplot(1,2,2),imshow(dw),title('定位剪切后的彩色车牌图像') imwrite(dw,'');
[filename,filepath]=uigetfile('','输入一个定位裁剪后的车牌图像');
jpg=strcat(filepath,filename);
a=imread('');
b=mat2gray(a);
imwrite(b,'1.车牌灰度图像.jpg');
figure(8);subplot(3,2,1),imshow(b),title('1.车牌灰度图像')
g_max=double(max(max(b)));
g_min=double(min(min(b)));
%T=round(g_max-(g_max-g_min)/3); % T 为二值化的阈值
T=;
[m,n]=size(b);
d=(double(b)>=T); % d:二值图像
imwrite(d,'2.车牌二值图像.jpg');
figure(8);subplot(3,2,2),imshow(d),title('2.车牌二值图像')
figure(8),subplot(3,2,3),imshow(d),title('3.均值滤波前')
% 滤波
h=fspecial('average',3);
d=im2bw(round(filter2(h,d)));
imwrite(d,'4.均值滤波后.jpg');
figure(8),subplot(3,2,4),imshow(d),title('4.均值滤波后')
% 某些图像进行操作
% 膨胀或腐蚀
% se=strel('square',3); % 使用一个3X3的正方形结果元素对象对创建的图像进行膨胀% 'line'/'diamond'/'ball'...
se=eye(2); % eye(n) returns the n-by-n identity matrix 单位矩阵
[m,n]=size(d);
if bwarea(d)/m/n>=
d=imerode(d,se);
elseif bwarea(d)/m/n<=
d=imdilate(d,se);
end
imwrite(d,'5.膨胀或腐蚀处理后.jpg');
figure(8),subplot(3,2,5),imshow(d),title('5.膨胀或腐蚀处理后')
% 寻找连续有文字的块，若长度大于某阈值，则认为该块有两个字符组成，需要分割
d=qiege(d);
[m,n]=size(d);
figure,subplot(2,1,1),imshow(d),title(n)
k1=1;k2=1;s=sum(d);j=1;
while j~=n
while s(j)==0
j=j+1;
end
k1=j;
while s(j)~=0 && j<=n-1
j=j+1;
end
k2=j-1;
if k2-k1>=round(n/
[val,num]=min(sum(d(:,[k1+5:k2-5])));
d(:,k1+num+5)=0; % 分割
end
end
% 再切割
d=qiege(d);
% 切割出 7 个字符
y1=10;y2=;flag=0;word1=[];
while flag==0
[m,n]=size(d);
left=1;wide=0;
while sum(d(:,wide+1))~=0
wide=wide+1;
end
if wide<y1 % 认为是左侧干扰
d(:,[1:wide])=0;
d=qiege(d);
else
temp=qiege(imcrop(d,[1 1 wide m]));
[m,n]=size(temp);
all=sum(sum(temp));
two_thirds=sum(sum(temp([round(m/3):2*round(m/3)],:)));
if two_thirds/all>y2
flag=1;word1=temp; % WORD 1
end
d(:,[1:wide])=0;d=qiege(d);
end
end
% 分割出第二个字符
[word2,d]=getword(d);
% 分割出第三个字符
[word3,d]=getword(d);
% 分割出第四个字符
[word4,d]=getword(d);
% 分割出第五个字符
[word5,d]=getword(d);
% 分割出第六个字符
[word6,d]=getword(d);
% 分割出第七个字符
[word7,d]=getword(d);
subplot(5,7,1),imshow(word1),title('1');
subplot(5,7,2),imshow(word2),title('2');
subplot(5,7,3),imshow(word3),title('3');
subplot(5,7,4),imshow(word4),title('4');
subplot(5,7,5),imshow(word5),title('5');
subplot(5,7,6),imshow(word6),title('6');
subplot(5,7,7),imshow(word7),title('7');
[m,n]=size(word1);
% 商用系统程序中归一化大小为 40*20,此处演示
word1=imresize(word1,[40 20]);
word2=imresize(word2,[40 20]);
word3=imresize(word3,[40 20]);
word4=imresize(word4,[40 20]);
word5=imresize(word5,[40 20]);
word6=imresize(word6,[40 20]);
word7=imresize(word7,[40 20]);
subplot(5,7,15),imshow(word1),title('1');
subplot(5,7,16),imshow(word2),title('2');
subplot(5,7,17),imshow(word3),title('3');
subplot(5,7,18),imshow(word4),title('4');
subplot(5,7,19),imshow(word5),title('5');
subplot(5,7,20),imshow(word6),title('6');
subplot(5,7,21),imshow(word7),title('7');
imwrite(word1,'');
imwrite(word2,'');
imwrite(word3,'');
imwrite(word4,'');
imwrite(word5,'');
imwrite(word6,'');
imwrite(word7,'');
liccode=char(['0':'9''A':'Z''苏豫陕鲁']); %建立自动识别字符代码表SubBw2=zeros(40,20);
l=1;
for I=1:7
ii=int2str(I);
t=imread([ii,'.jpg']);
SegBw2=imresize(t,[40 20],'nearest');
if l==1 %第一位汉字识别
kmin=37;
kmax=40;
elseif l==2 %第二位 A~Z 字母识别
kmin=11;
kmax=36;
else l>=3 %第三位以后是字母或数字识别
kmin=1;
kmax=36;
end
for k2=kmin:kmax
fname=strcat('字符模板\',liccode(k2),'.jpg');
SamBw2 = imread(fname);
for i=1:40
for j=1:20
SubBw2(i,j)=SegBw2(i,j)-SamBw2(i,j);
end
end
% 以上相当于两幅图相减得到第三幅图
Dmax=0;
for k1=1:40
for l1=1:20
if ( SubBw2(k1,l1) > 0 | SubBw2(k1,l1) <0 )
Dmax=Dmax+1;
end
end
end
Error(k2)=Dmax;
end
Error1=Error(kmin:kmax);
MinError=min(Error1);
findc=find(Error1==MinError);
Code(l*2-1)=liccode(findc(1)+kmin-1);
Code(l*2)=' ';
l=l+1;
end
figure(10),imshow(dw),title (['车牌号码:', Code],'Color','b');
六、参考文献
【1】Rafeal 、Richard 、Steven ，数字图像处理，第二版，2014，电子工业出版社【2】【3】【4】【5】【6】【7】。