2019-04-06 15:42:38 Eastmount 阅读数 3633

该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

同时推荐作者的C++图像系列知识:
[数字图像处理] 一.MFC详解显示BMP格式图片
[数字图像处理] 二.MFC单文档分割窗口显示图片
[数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
[数字图像处理] 四.MFC对话框绘制灰度直方图
[数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
[数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
[数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

前文参考:
[Python图像处理] 一.图像处理基础知识及OpenCV入门函数
[Python图像处理] 二.OpenCV+Numpy库读取与修改像素
[Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
[Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
[Python图像处理] 五.图像融合、加法运算及图像类型转换
[Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
[Python图像处理] 七.图像阈值化处理及算法对比
[Python图像处理] 八.图像腐蚀与图像膨胀
[Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
[Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
[Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
[Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
[Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算
[Python图像处理] 十四.基于OpenCV和像素处理的图像灰度化处理
[Python图像处理] 十五.图像的灰度线性变换
[Python图像处理] 十六.图像的灰度非线性变换之对数变换、伽马变换
[Python图像处理] 十七.图像锐化与边缘检测之Roberts算子、Prewitt算子、Sobel算子和Laplacian算子

由于收集图像数据的器件或传输数图像的通道的存在一些质量缺陷,文物图像时间久远,或者受一些其他外界因素、动态不稳定抓取图像的影响,使得图像存在模糊和有噪声的情况,从而影响到图像识别工作的开展。这时需要开展图像锐化和边缘检测处理,加强原图像的高频部分,锐化突出图像的边缘细节,改善图像的对比度,使模糊的图像变得更清晰。

图像锐化和边缘提取技术可以消除图像中的噪声,提取图像信息中用来表征图像的一些变量,为图像识别提供基础。通常使用灰度差分法对图像的边缘、轮廓进行处理,将其凸显。前文分别采用Laplacian算子、Robert算子、Prewitt算子和Sobel算子进行图像锐化边缘处理实验,本文将继续讲解Scharr算子、Canny算子和LOG算子。

本文主要讲解灰度线性变换,基础性知识希望对您有所帮助。
1.Scharr算子
2.Canny算子
3.LOG算子
4.总结代码

注意 :该部分知识均为自己查阅资料撰写,转载请署名CSDN+杨秀璋及原地址出处,谢谢!!


PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时参考如下文献:
杨秀璋等. 基于苗族服饰的图像锐化和边缘提取技术研究[J]. 现代计算机,2018(10).
《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015.
张小洪,杨丹,刘亚威. 基于Canny算子的改进型边缘检测算法[J]. 计算机工程与应用,2003
[数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解
图像边缘检测——一阶微分算子 Roberts、Sobel、Prewitt、Kirsch、Robinson(Matlab实现)
[OpenCV图像处理入门学习教程四] 基于LoG算子的图像边缘检测 primetong
https://en.wikipedia.org/wiki/Canny_edge_detector


一.Scharr算子

由于Sobel算子在计算相对较小的核的时候,其近似计算导数的精度比较低,比如一个33的Sobel算子,当梯度角度接近水平或垂直方向时,其不精确性就越发明显。Scharr算子同Sobel算子的速度一样快,但是准确率更高,尤其是计算较小核的情景,所以利用33滤波器实现图像边缘提取更推荐使用Scharr算子。

Scharr算子又称为Scharr滤波器,也是计算x或y方向上的图像差分,在OpenCV中主要是配合Sobel算子的运算而存在的,其滤波器的滤波系数如下:

Scharr算子的函数原型如下所示,和Sobel算子几乎一致,只是没有ksize参数,其函数原型如下所示:

dst = Scharr(src, ddepth, dx, dy[, dst[, scale[, delta[, borderType]]]]])

  • src表示输入图像
  • dst表示输出的边缘图,其大小和通道数与输入图像相同
  • ddepth表示目标图像所需的深度,针对不同的输入图像,输出目标图像有不同的深度
  • dx表示x方向上的差分阶数,取值1或 0
  • dy表示y方向上的差分阶数,取值1或0
  • scale表示缩放导数的比例常数,默认情况下没有伸缩系数
  • delta表示将结果存入目标图像之前,添加到结果中的可选增量值
  • borderType表示边框模式,更多详细信息查阅BorderTypes

Python实现代码如下所示:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
# Scharr算子
x = cv2.Scharr(grayImage, cv2.CV_32F, 1, 0) #X方向
y = cv2.Scharr(grayImage, cv2.CV_32F, 0, 1) #Y方向
absX = cv2.convertScaleAbs(x)       
absY = cv2.convertScaleAbs(y)
Scharr = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'Scharr算子']  
images = [lenna_img, Scharr]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

运行结果如下图所示:


二.Canny算子

John F.Canny于1986年发明了一个多级边缘检测算法——Canny边缘检测算子,并创立了边缘检测计算理论(Computational theory of edge detection),该理论有效地解释了这项技术的工作理论。
边缘检测通常是在保留原有图像属性的情况下,对图像数据规模进行缩减,提取图像边缘轮廓的处理方式。

Canny算法是一种被广泛应用于边缘检测的标准算法,其目标是找到一个最优的边缘检测解或找寻一幅图像中灰度强度变化最强的位置。最优边缘检测主要通过低错误率、高定位性和最小响应三个标准进行评价。Canny算子的实现步骤如下:

1.使用高斯平滑(如公式所示)去除噪声。

2.按照Sobel滤波器步骤计算梯度幅值和方向,寻找图像的强度梯度。先将卷积模板分别作用x和y方向,再计算梯度幅值和方向,其公式如下所示。梯度方向一般取0度、45度、90度和135度四个方向。

3.通过非极大值抑制(Non-maximum Suppression)过滤掉非边缘像素,将模糊的边界变得清晰。该过程保留了每个像素点上梯度强度的极大值,过滤掉其他的值。

对于每个像素点,它进行如下操作:

1)将其梯度方向近似为以下值中的一个,包括0、45、90、135、180、225、270和315,即表示上下左右和45度方向。

2)比较该像素点和其梯度正负方向的像素点的梯度强度,如果该像素点梯度强度最大则保留,否则抑制(删除,即置为0)。其处理后效果如下图所示,左边表示梯度值,右边表示非极大值抑制处理后的边缘。

4.利用双阈值方法来确定潜在的边界。经过非极大抑制后图像中仍然有很多噪声点,此时需要通过双阈值技术处理,即设定一个阈值上界和阈值下界。图像中的像素点如果大于阈值上界则认为必然是边界(称为强边界,strong edge),小于阈值下界则认为必然不是边界,两者之间的则认为是候选项(称为弱边界,weak edge)。经过双阈值处理的图像如下图所示,左边为非极大值抑制处理后的边缘,右边为双阈值技术处理的效果图。

5.利用滞后技术来跟踪边界。若某一像素位置和强边界相连的弱边界认为是边界,其他的弱边界则被删除。

在OpenCV中,Canny()函数原型如下所示:

edges = Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]])

  • mage表示输入图像
  • edges表示输出的边缘图,其大小和类型与输入图像相同
  • threshold1表示第一个滞后性阈值
  • threshold2表示第二个滞后性阈值
  • apertureSize表示应用Sobel算子的孔径大小,其默认值为3
  • L2gradient表示一个计算图像梯度幅值的标识,默认值为false

Canny算子的边缘提取实现代码如下所示:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#高斯滤波降噪
gaussian = cv2.GaussianBlur(grayImage, (3,3), 0)
 
#Canny算子
Canny = cv2.Canny(gaussian, 50, 150) 

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'Canny算子']  
images = [lenna_img, Canny]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

其运行结果如图所示:


三.LOG算子

LOG(Laplacian of Gaussian)边缘检测算子是David Courtnay Marr和Ellen Hildreth在1980年共同提出的,也称为Marr & Hildreth算子,它根据图像的信噪比来求检测边缘的最优滤波器。该算法首先对图像做高斯滤波,然后再求其拉普拉斯(Laplacian)二阶导数,根据二阶导数的过零点来检测图像的边界,即通过检测滤波结果的零交叉(Zero crossings)来获得图像或物体的边缘。

LOG算子该综合考虑了对噪声的抑制和对边缘的检测两个方面,并且把Gauss平滑滤波器和Laplacian锐化滤波器结合了起来,先平滑掉噪声,再进行边缘检测,所以效果会更好。 该算子与视觉生理中的数学模型相似,因此在图像处理领域中得到了广泛的应用。它具有抗干扰能力强,边界定位精度高,边缘连续性好,能有效提取对比度弱的边界等特点。

常见的LOG算子是5*5模板,如下所示:

由于LOG算子到中心的距离与位置加权系数的关系曲线像墨西哥草帽的剖面,所以LOG算子也叫墨西哥草帽滤波器,如图所示。

LOG算子的边缘提取实现代码如下所示:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#先通过高斯滤波降噪
gaussian = cv2.GaussianBlur(grayImage, (3,3), 0)
 
#再通过拉普拉斯算子做边缘检测
dst = cv2.Laplacian(gaussian, cv2.CV_16S, ksize = 3)
LOG = cv2.convertScaleAbs(dst)

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'LOG算子']  
images = [lenna_img, LOG]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

其运行结果如下图所示:


四.总结代码

边缘检测算法主要是基于图像强度的一阶和二阶导数,但导数通常对噪声很敏感,因此需要采用滤波器来过滤噪声,并调用图像增强或阈值化算法进行处理,最后再进行边缘检测。下面是采用高斯滤波去噪和阈值化处理之后,再进行边缘检测的过程,并对比了四种常见的边缘提取算法。

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt

#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#高斯滤波
gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0)

#阈值处理
ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)

#Scharr算子
x = cv2.Scharr(grayImage, cv2.CV_32F, 1, 0) #X方向
y = cv2.Scharr(grayImage, cv2.CV_32F, 0, 1) #Y方向
absX = cv2.convertScaleAbs(x)       
absY = cv2.convertScaleAbs(y)
Scharr = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#Canny算子
gaussian = cv2.GaussianBlur(grayImage, (3,3), 0) #高斯滤波降噪
Canny = cv2.Canny(gaussian, 50, 150) 

#LOG算子
gaussian = cv2.GaussianBlur(grayImage, (3,3), 0) #先通过高斯滤波降噪
dst = cv2.Laplacian(gaussian, cv2.CV_16S, ksize = 3) #再通过拉普拉斯算子做边缘检测
LOG = cv2.convertScaleAbs(dst)

#效果图
titles = ['Source Image', 'Gray Image', 'Binary Image',
          'Scharr Image','Canny Image', 'LOG Image']  
images = [lenna_img, grayImage, binary, Scharr, Canny, LOG]  
for i in np.arange(6):  
   plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()  

输出结果如图所示。


希望这篇基础性文章对您有所帮助,如果有错误 或不足之处,请海涵!一起加油,考博加油。

(By:Eastmount 2019-04-06 下午4点写于贵阳·钟书阁 https://blog.csdn.net/Eastmount/)

2019-10-16 20:22:15 weixin_43262648 阅读数 578

数字图像处理——Sobel算子锐化、Prewitt算子锐化

一、Sobel算子锐化

%函数名称为Image_Sobel,输入参数Image,输出参数IMAGE
function [IMAGE] = Image_Sobel(Image)
%获取矩阵的行、列、波段数
[m,n,bands] = size(Image);
%定义模板大小,假设模板大小3×3
A = 1;
%定义Sobel算子x,y方向矩阵
Sobelx = [-1 -2 -1;0 0 0;1 2 1];
Sobely = [-1 0 1;-2 0 2;-1 0 1];
%初始化矩阵
Image1 = zeros(m,n,bands);
IMAGE = Image;
%Sobel算子
for k = 1:bands
    for i = 1+A:m-A
        for j = 1+A:n-A
            temp = Image(i-A:i+A,j-A:j+A,k);
           	Image1(i,j,k) = abs(sum(sum(Sobelx.*temp)))+abs(sum(sum(Sobely.*temp)));
        end
    end
end
IMAGE = Image + Image1;
%画图,左右分别表示原图和两幅处理后的图像
figure(1);
subplot(1,3,1);
imshow(uint8(Image));
title('原始图像');
subplot(1,3,2);
imshow(uint8(Image1));
title('边缘提取图像');
subplot(1,3,3);
imshow(uint8(IMAGE));
title('Sobel算子锐化后的图像')
end

二、prewitt算子锐化

%函数名称为Image_Prewitt,输入参数Image,输出参数IMAGE
function [IMAGE] = Image_Prewitt(Image)
%获取矩阵的行、列、波段数
[m,n,bands] = size(Image);
%定义模板大小,假设模板大小3×3
A = 1;
%定义Prewitt算子x,y方向矩阵
Prewittx = [-1 -2 -1;0 0 0;1 2 1];
Prewitty = [-1 0 1;-2 0 2;-1 0 1];
%初始化矩阵
Image1 = zeros(m,n,bands);
IMAGE = Image;
%Sobel算子
for k = 1:bands
    for i = 1+A:m-A
        for j = 1+A:n-A
            temp = Image(i-A:i+A,j-A:j+A,k);
           	Image1(i,j,k) = abs(sum(sum(Prewittx.*temp)))+abs(sum(sum(Prewitty.*temp)));
        end
    end
end
IMAGE = Image + Image1;
%画图,左中右分别表示原图和两幅处理后的图像
figure(1);
subplot(1,3,1);
imshow(uint8(Image));
title('原始图像');
subplot(1,3,2);
imshow(uint8(Image1));
title('边缘提取图像');
subplot(1,3,3);
imshow(uint8(IMAGE));
title('Prewitt锐化后的图像')
end

调用方法

Image = double(imread('当前目录下的图片名称.jpg'));
Sobel = Image_Sobel(Image);
Prewitt = Image_Prewitt(Image);

在这里插入图片描述

在这里插入图片描述

2019-04-03 18:26:46 Eastmount 阅读数 6788

该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

同时推荐作者的C++图像系列知识:
[数字图像处理] 一.MFC详解显示BMP格式图片
[数字图像处理] 二.MFC单文档分割窗口显示图片
[数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
[数字图像处理] 四.MFC对话框绘制灰度直方图
[数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
[数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
[数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

前文参考:
[Python图像处理] 一.图像处理基础知识及OpenCV入门函数
[Python图像处理] 二.OpenCV+Numpy库读取与修改像素
[Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
[Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
[Python图像处理] 五.图像融合、加法运算及图像类型转换
[Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
[Python图像处理] 七.图像阈值化处理及算法对比
[Python图像处理] 八.图像腐蚀与图像膨胀
[Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
[Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
[Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
[Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
[Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算
[Python图像处理] 十四.基于OpenCV和像素处理的图像灰度化处理
[Python图像处理] 十五.图像的灰度线性变换
[Python图像处理] 十六.图像的灰度非线性变换之对数变换、伽马变换

由于收集图像数据的器件或传输数图像的通道的存在一些质量缺陷,文物图像时间久远,或者受一些其他外界因素、动态不稳定抓取图像的影响,使得图像存在模糊和有噪声的情况,从而影响到图像识别工作的开展。这时需要开展图像锐化和边缘检测处理,加强原图像的高频部分,锐化突出图像的边缘细节,改善图像的对比度,使模糊的图像变得更清晰。

图像锐化和边缘提取技术可以消除图像中的噪声,提取图像信息中用来表征图像的一些变量,为图像识别提供基础。通常使用灰度差分法对图像的边缘、轮廓进行处理,将其凸显。本文分别采用Laplacian算子、Robert算子、Prewitt算子和Sobel算子进行图像锐化边缘处理实验。

本文主要讲解灰度线性变换,基础性知识希望对您有所帮助。
1.Roberts算子
2.Prewitt算子
3.Sobel算子
4.Laplacian算子
5.总结代码

PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时参考如下文献:
杨秀璋等. 基于苗族服饰的图像锐化和边缘提取技术研究[J]. 现代计算机,2018(10).
《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015.
[数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

闲谈:
希望大家帮我2019年CSDN博客之星投投票,每天可以投5票喔,谢谢大家!八年,在CSDN分享了410篇文章,15个专栏,400多万人次浏览,包括Python人工智能、数据挖掘、网络爬虫、图象处理、网络安全、JAVA网站、Android开发、LAMP/WAMP、C#网络编程、C++游戏、算法和数据结构、面试总结、人生感悟等。当然还有我和你的故事,感恩一路有你,感谢一路同行,希望通过编程分享帮助到更多人,也希望学成之后回贵州教更多学生。因为喜欢,所以分享,且看且珍惜,加油!等我四年学成归来~

投票地址:http://m234140.nofollow.ax.mvote.cn/opage/ed8141a0-ed19-774b-6b0d-39c3aaf89dde.html?from=singlemessage

在这里插入图片描述


一.Roberts算子

Roberts算子又称为交叉微分算法,它是基于交叉差分的梯度算法,通过局部差分计算检测边缘线条。常用来处理具有陡峭的低噪声图像,当图像边缘接近于正45度或负45度时,该算法处理效果更理想。其缺点是对边缘的定位不太准确,提取的边缘线条较粗。

Roberts算子的模板分为水平方向和垂直方向,如公式(11.7)所示,从其模板可以看出,Roberts算子能较好的增强正负45度的图像边缘。

详细计算公式如下所示:(PS-下图参考自己的书和论文)

在Python中,Roberts算子主要通过Numpy定义模板,再调用OpenCV的filter2D()函数实现边缘提取。该函数主要是利用内核实现对图像的卷积运算,其函数原型如下所示:

dst = filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])

  • src表示输入图像
  • dst表示输出的边缘图,其大小和通道数与输入图像相同
  • ddepth表示目标图像所需的深度
  • kernel表示卷积核,一个单通道浮点型矩阵
  • anchor表示内核的基准点,其默认值为(-1,-1),位于中心位置
  • delta表示在储存目标图像前可选的添加到像素的值,默认值为0
  • borderType表示边框模式

Python实现代码如下所示:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
#Roberts算子
kernelx = np.array([[-1,0],[0,1]], dtype=int)
kernely = np.array([[0,-1],[1,0]], dtype=int)
x = cv2.filter2D(grayImage, cv2.CV_16S, kernelx)
y = cv2.filter2D(grayImage, cv2.CV_16S, kernely)
#转uint8 
absX = cv2.convertScaleAbs(x)      
absY = cv2.convertScaleAbs(y)    
Roberts = cv2.addWeighted(absX,0.5,absY,0.5,0)

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'Roberts算子']  
images = [lenna_img, Roberts]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

运行结果如下图所示:


二.Prewitt算子

Prewitt是一种图像边缘检测的微分算子,其原理是利用特定区域内像素灰度值产生的差分实现边缘检测。由于Prewitt算子采用33模板对区域内的像素值进行计算,而Robert算子的模板为22,故Prewitt算子的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。Prewitt算子适合用来识别噪声较多、灰度渐变的图像,其计算公式如下所示。

在Python中,Prewitt算子的实现过程与Roberts算子比较相似。通过Numpy定义模板,再调用OpenCV的filter2D()函数实现对图像的卷积运算,最终通过convertScaleAbs()和addWeighted()函数实现边缘提取,代码如下所示:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
#Prewitt算子
kernelx = np.array([[1,1,1],[0,0,0],[-1,-1,-1]],dtype=int)
kernely = np.array([[-1,0,1],[-1,0,1],[-1,0,1]],dtype=int)
x = cv2.filter2D(grayImage, cv2.CV_16S, kernelx)
y = cv2.filter2D(grayImage, cv2.CV_16S, kernely)
#转uint8
absX = cv2.convertScaleAbs(x)       
absY = cv2.convertScaleAbs(y)    
Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0)

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'Prewitt算子']  
images = [lenna_img, Prewitt]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

输出结果如下图所示,左边为原始图像,右边为Prewitt算子图像锐化提取的边缘轮廓,其效果图的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。


三.Sobel算子

Sobel算子是一种用于边缘检测的离散微分算子,它结合了高斯平滑和微分求导。该算子用于计算图像明暗程度近似值,根据图像边缘旁边明暗程度把该区域内超过某个数的特定点记为边缘。Sobel算子在Prewitt算子的基础上增加了权重的概念,认为相邻点的距离远近对当前像素点的影响是不同的,距离越近的像素点对应当前像素的影响越大,从而实现图像锐化并突出边缘轮廓。

Sobel算子的边缘定位更准确,常用于噪声较多、灰度渐变的图像。其算法模板如公式所示,其中dx表示水平方向,dy表示垂直方向。

Sobel算子根据像素点上下、左右邻点灰度加权差,在边缘处达到极值这一现象检测边缘。对噪声具有平滑作用,提供较为精确的边缘方向信息。因为Sobel算子结合了高斯平滑和微分求导(分化),因此结果会具有更多的抗噪性,当对精度要求不是很高时,Sobel算子是一种较为常用的边缘检测方法。

dst = Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]])

  • src表示输入图像
  • dst表示输出的边缘图,其大小和通道数与输入图像相同
  • ddepth表示目标图像所需的深度,针对不同的输入图像,输出目标图像有不同的深度
  • dx表示x方向上的差分阶数,取值1或 0
  • dy表示y方向上的差分阶数,取值1或0
  • ksize表示Sobel算子的大小,其值必须是正数和奇数
  • scale表示缩放导数的比例常数,默认情况下没有伸缩系数
  • delta表示将结果存入目标图像之前,添加到结果中的可选增量值
  • borderType表示边框模式,更多详细信息查阅BorderTypes

注意,在进行Sobel算子处理之后,还需要调用convertScaleAbs()函数计算绝对值,并将图像转换为8位图进行显示。其算法原型如下:

dst = convertScaleAbs(src[, dst[, alpha[, beta]]])

  • src表示原数组
  • dst表示输出数组,深度为8位
  • alpha表示比例因子
  • beta表示原数组元素按比例缩放后添加的值

Sobel算子的实现代码如下所示:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
#Sobel算子
x = cv2.Sobel(grayImage, cv2.CV_16S, 1, 0) #对x求一阶导
y = cv2.Sobel(grayImage, cv2.CV_16S, 0, 1) #对y求一阶导
absX = cv2.convertScaleAbs(x)      
absY = cv2.convertScaleAbs(y)    
Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'Sobel算子']  
images = [lenna_img, Sobel]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

最终输出结果如下图所示:


四.Laplacian算子

拉普拉斯(Laplacian)算子是n维欧几里德空间中的一个二阶微分算子,常用于图像增强领域和边缘提取。它通过灰度差分计算邻域内的像素,基本流程是:判断图像中心像素灰度值与它周围其他像素的灰度值,如果中心像素的灰度更高,则提升中心像素的灰度;反之降低中心像素的灰度,从而实现图像锐化操作。在算法实现过程中,Laplacian算子通过对邻域中心像素的四方向或八方向求梯度,再将梯度相加起来判断中心像素灰度与邻域内其他像素灰度的关系,最后通过梯度运算的结果对像素灰度进行调整。

Laplacian算子分为四邻域和八邻域,四邻域是对邻域中心像素的四方向求梯度,八邻域是对八方向求梯度。其中,四邻域模板如公式所示:

通过模板可以发现,当邻域内像素灰度相同时,模板的卷积运算结果为0;当中心像素灰度高于邻域内其他像素的平均灰度时,模板的卷积运算结果为正数;当中心像素的灰度低于邻域内其他像素的平均灰度时,模板的卷积为负数。对卷积运算的结果用适当的衰弱因子处理并加在原中心像素上,就可以实现图像的锐化处理。

Laplacian算子的八邻域模板如下:

Python和OpenCV将Laplacian算子封装在Laplacian()函数中,其函数原型如下所示:

dst = Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]])

  • src表示输入图像
  • dst表示输出的边缘图,其大小和通道数与输入图像相同
  • ddepth表示目标图像所需的深度
  • ksize表示用于计算二阶导数的滤波器的孔径大小,其值必须是正数和奇数,且默认值为1,更多详细信息查阅getDerivKernels
  • scale表示计算拉普拉斯算子值的可选比例因子。默认值为1,更多详细信息查阅getDerivKernels
  • delta表示将结果存入目标图像之前,添加到结果中的可选增量值,默认值为0
  • borderType表示边框模式,更多详细信息查阅BorderTypes

注意,Laplacian算子其实主要是利用Sobel算子的运算,通过加上Sobel算子运算出的图像x方向和y方向上的导数,得到输入图像的图像锐化结果。同时,在进行Laplacian算子处理之后,还需要调用convertScaleAbs()函数计算绝对值,并将图像转换为8位图进行显示。

当ksize=1时,Laplacian()函数采用3×3的孔径(四邻域模板)进行变换处理。下面的代码是采用ksize=3的Laplacian算子进行图像锐化处理,其代码如下:

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt
 
#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
#拉普拉斯算法
dst = cv2.Laplacian(grayImage, cv2.CV_16S, ksize = 3)
Laplacian = cv2.convertScaleAbs(dst) 

#用来正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']

#显示图形
titles = [u'原始图像', u'Laplacian算子']  
images = [lenna_img, Laplacian]  
for i in xrange(2):  
   plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

最终输出结果如下图所示:


五.总结代码

边缘检测算法主要是基于图像强度的一阶和二阶导数,但导数通常对噪声很敏感,因此需要采用滤波器来过滤噪声,并调用图像增强或阈值化算法进行处理,最后再进行边缘检测。下面是采用高斯滤波去噪和阈值化处理之后,再进行边缘检测的过程,并对比了四种常见的边缘提取算法。

# -*- coding: utf-8 -*-
import cv2  
import numpy as np  
import matplotlib.pyplot as plt

#读取图像
img = cv2.imread('lena.png')
lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#高斯滤波
gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0)

#阈值处理
ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)

#Roberts算子
kernelx = np.array([[-1,0],[0,1]], dtype=int)
kernely = np.array([[0,-1],[1,0]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)     
absY = cv2.convertScaleAbs(y)    
Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#Prewitt算子
kernelx = np.array([[1,1,1],[0,0,0],[-1,-1,-1]], dtype=int)
kernely = np.array([[-1,0,1],[-1,0,1],[-1,0,1]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)  
absY = cv2.convertScaleAbs(y)    
Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0)

#Sobel算子
x = cv2.Sobel(binary, cv2.CV_16S, 1, 0)
y = cv2.Sobel(binary, cv2.CV_16S, 0, 1)    
absX = cv2.convertScaleAbs(x)   
absY = cv2.convertScaleAbs(y)    
Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#拉普拉斯算法
dst = cv2.Laplacian(binary, cv2.CV_16S, ksize = 3)
Laplacian = cv2.convertScaleAbs(dst) 

#效果图
titles = ['Source Image', 'Binary Image', 'Roberts Image',
          'Prewitt Image','Sobel Image', 'Laplacian Image']  
images = [lenna_img, binary, Roberts, Prewitt, Sobel, Laplacian]  
for i in np.arange(6):  
   plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()  

输出结果如图所示。其中,Laplacian算子对噪声比较敏感,由于其算法可能会出现双像素边界,常用来判断边缘像素位于图像的明区或暗区,很少用于边缘检测;Robert算子对陡峭的低噪声图像效果较好,尤其是边缘正负45度较多的图像,但定位准确率较差;Prewitt算子对灰度渐变的图像边缘提取效果较好,而没有考虑相邻点的距离远近对当前像素点的影响;Sobel算子考虑了综合因素,对噪声较多的图像处理效果更好。


这篇文章写于我2019年4月3日下午下课、接晚上上课前,《大数据技术及应用》这门课程我采用Python进行讲解,围绕爬虫、可视化、分析等案例进行。非常高兴看到,晚上的课,同学们提前两个小时就来把前五排的座位占了,这是之前北理工才能看到的,而且是专业课,我非常欣慰,非常高兴!这就是我来这里当老师的目的,我相信不止有文学、电影这类课程这么吸引学生,专业课同样可以,路还很漫长,我还需继续加油,继续探索。

同时,这周末忙完研究生复试,今天和女神来钟书阁看书。英语真的太差了,找本书来翻译锻炼下,专业知识也还有好多要学的,时间真是不够。哈哈,笑看人生,加油!

(By:Eastmount 2019-04-03 下午8点 https://blog.csdn.net/Eastmount/)

2013-09-03 23:28:21 kezunhai 阅读数 2929

          图像处理中,特征算子比较流行的现在已经不下上十种,而且关于图像特征算子的综述论文时有见刊。随着对图像处理及相关领域的进一步了解。一直就觉得有必要写一个关于图像处理中的特征算子的系列博文,来详细介绍这些算子的原理及其实现相关的内容。随着时间的推移,一直没有时间将这个工作付诸行动,不知不觉就毕业了。工作后,主要的工作内容还是和图像处理相关,而且发现工作中遇到的很多问题都可以从这些算子的设计思路中找到一些灵感,一定程度上助于问题的解决。遂,下定决心还是写一个关于特征算子系列吧。一来,当是对这些算子进一步的复习与理解;二来,希望能给正在学习图像处理路上的同学一些帮助;三来,也是为自己先前和现阶段的工作做一个小的总结。

         近年来,区分性强、对多种几何和光度变换具有不变性的局部不变特征在宽基线匹配、特定目标识别、目标类别识别、图像及视频检索、机器人导航、纹理识别和数据挖掘等多个领域内获得广泛的应用,是国内外的研究热点。

         局部不变特征是指局部特征的检测或描述对图像的各种变化,例如几何变换、光度变换、卷积变换、视角变化等保持不变。局部不变特征的基本思想是提取图像内容的本质属性特征,这些特征与图像内容的具体表现形式无关或具有自适应性(即表现形式变化时特征提取自适应的变化以描述相同的图像内容)。局部不变特征通常存在一个局部支撑邻域,与经典的图像分割算法不同,局部支撑邻域可能是图像的任何子集,支撑区域的边界不一定对应图像外观(例如颜色或纹理)的变化。

          局部不变特征的研究包含3个基本问题:一是局部不变特征的检测,二是局部不变特征的描述,三是局部不变特征的匹配。根据不同的准则,局部不变特征的研究方法可以分为不同的类别,按照使用的色调空间的不同可以分为局部灰度不变特征和局部彩色不变特征;按照特征层次的不同可以分为角点不变特征、blob不变特征和区域不变特征;按照几何变换不变性的自由度可以分为平移不变特征、旋转不变特征、尺度不变特征、欧氏不变特征、相似不变特征、仿射不变特征和投影不变特征;按照处理思路的不同可以分为基于轮廓曲率的不变特征、基于灰度梯度、灰度变化和显著性的不变特征,基于生物视觉启发的不变特征,基于多尺度的不变特征和基于分割的不变特征。

          局部不变特征应该具有以下特性:
          1)重复性(Repeatability) 
           相同场景或目标在不同成像条件下图像提取的局部不变特征应该是相同的;
          2)区分性 (Distinctiveness
           局部不变特征应包含较大的灰度或色度模式变化,易于区分;
          3)局部性(Locality
          局部不变特征应具有局部性,减小遮挡的概率,同时可以采用简单的变换模型对图像间的变换进行近似建模;
          4)精确性(Accuracy
          局部不变特征应可以在空域、尺度域及形状域上精确定位;
          5)不变性 (Invariant
          局部不变特征的检测和描述对各种变换应具有不变性;
          6)鲁棒性 (Robustness
           局部不变特征的检测和描述应对图像噪声、量化误差、模糊等不敏感。

欲了解更多特性,请参考:Tinne Turytelaars的论文:Local Invariant Feature Detectors 

          图像特征的研究最早可以追溯到1954年F.Attneave发表在Psychological Review的《some informational aspects of visual perception》,作者第一次观察到:形状信息集中在具有高曲率的主点(Dominant Points)上。经过近60年的发展,特征检测与提取算法得到了不断的丰富和突破。根据不同的分类,图像特征提取的方法可以分为不同的类别,主要包括基于轮廓曲率的方法(Contour Curvature Based Method)、基于灰度的方法(Intensity Based Methods,包括 海瑟矩阵方法(Hessian-Based Approach)、基于梯度方法(Gradient-Based Methods))、基于显著性的方法(Saliency Based Methods)、基于生物模拟的方法(Biologically Plausible Methods)、基于颜色的方法(Color Based Methods)、基于模型的方法(Model Based Methods)、多视角不变的方法(Toward Viewpoint Invariant Methods)、基于分割的方法(Segmentation Based Methods)以及基于机器学习的方法(machine learning based methods)等等。

          现今,在图像处理领域耳熟能详的特征算子包括:DoG、Fast、STAR、HARRIS、DENSE、SimpleBlob、MSER、SIFT、SURF、ORB、BRISK、FREAK等,本博文将逐一对这些算子进行分析。但可能由于工作原因,更新周期会比较长。今天写一个开篇,作为开始,也作为一个闹钟,提醒自己还有这个事没做。

         另外,有兴趣的朋友可以看看下列几篇文章,也可以通过链接下载:http://download.csdn.net/detail/kezunhai/6211147

          1)Keystian Mikolajczyk. A performance evaluation of local descriptors, 2005 PAMI

          2)Tinne Tuytelaars. Local Invariant Feature Detectors: A Survey, 2007 Computer Graphic & Vision

          3)王浩. 局部不变特征综述, 2011 计算机图像图像学报

          4) Umasankar Kandaswamy.  Comparison of Texture Analysis Schemes Under Nonideal Conditions,2011 IP

2019-05-05 16:15:33 zaishuiyifangxym 阅读数 4361

目录

1 边缘检测的基本原理

2 边缘检测算子分类

3 梯度

3.1 图像梯度

3.2 梯度算子

4 Roberts 算子

4.1 基本原理

4.2 代码示例

5 Prewitt 算子

5.1 基本原理

5.2 代码示例

6 Sobel 算子

6.1 基本原理

6.2 代码示例

7 Laplacian 算子

7.1 基本原理

7.2 代码示例

8 小结

8.1 各类算子实验比较

8.2 各类算子的优缺点

参考资料


 

1 边缘检测的基本原理

图像边缘是图像最基本的特征,所谓边缘(Edge) 是指图像局部特性的不连续性。灰度或结构等信息的突变处称之为边缘。例如,灰度级的突变、颜色的突变,、纹理结构的突变等。边缘是一个区域的结束,也是另一个区域的开始,利用该特征可以分割图像。

如图1所示,当我们看到一个有边缘的物体时,首先感受到的就是边缘

图1 灰度级跃变的边缘模型

图1(a)是一个理想的边缘所具备的特性。每个灰度级跃变到一个垂直的台阶上。而实际上,在图像采集系统的性能、采样率和获取图像的照明条件等因素的影响,得到的边缘往往是模糊的,边缘被模拟成具有“斜坡面”的剖面,如图1(b)所示,在这个模型中,模糊的边缘变得“宽”了,而清晰的边缘变得“窄”了。

图像的边缘有方向和幅度两种属性。边缘通常可以通过一阶导数二阶导数检测得到。一阶导数是以最大值作为对应的边缘的位置,而二阶导数则以过零点作为对应边缘的位置。


 

2 边缘检测算子分类

(1)一阶导数的边缘算子

通过模板作为核与图像的每个像素点做卷积和运算,然后选取合适的阈值来提取图像的边缘。常见的有Roberts算子、Sobel算子和Prewitt算子。

 

(2)二阶导数的边缘算子

依据于二阶导数过零点,常见的有Laplacian 算子,此类算子对噪声敏感。

 

(3)其他边缘算子

前面两类均是通过微分算子来检测图像边缘,还有一种就是Canny算子,其是在满足一定约束条件下推导出来的边缘检测最优化算子。


 

3 梯度

3.1 图像梯度

为了达到寻找边缘的目的,检测灰度变化可用一阶导数二阶导数来完成。下面将讨论一阶导数

为了在一幅图像f 的(x,y)位置处寻找边缘的强度和方向,所以选择的工具就是梯度,梯度用\nabla f来表示,并用向量来定义,定义如下所示:

                                                                             \nabla f\equiv \text{grad}(f)\equiv \left[ \begin{matrix} {{g}_{x}} \\ {{g}_{y}} \\ \end{matrix} \right]\equiv \left[ \begin{matrix} \frac{\partial f}{\partial x} \\ {} \\ \frac{\partial f}{\partial y} \\ \end{matrix} \right]

 

其中,梯度\nabla f 为一个向量,它表示f 在位置(x,y) 处的最大变化率的方向。

梯度\nabla f 的大小用M(x,y) 表示,则:

                                                                          M(x,y)=mag(\nabla f)=\sqrt{g_{x}^{2}+g_{y}^{2}}

其中,M(x,y) 表示梯度向量方向变化率的值。

 

数学梯度的简单推导

对于以为函数f(x) 在点 x 处的导数的近似:将函数f(x+\Delta x) 展开为 x 的泰勒级数,令\Delta x=1,且只保该级数的线性项,则函数f(x) 的梯度\nabla f 计算为:

                                                                      \nabla f=\frac{\partial f}{\partial x}={{f}^{'}}(x)=f(x+1)-f(x)

 

3.2 梯度算子

由上面的数学推导可知,要得到一幅图像的梯度,则要求在图像的每个像素点位置处计算偏导数。我们处理的是数字量,因此要求关于一点的邻域上的偏导数的数字近似,因此一幅图像f ,在 (x,y) 位置处的 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                       {{g}_{x}}=\frac{\partial f(x,y)}{\partial x}=f(x+1,y)-f(x,y)

                                                                       {{g}_{y}}=\frac{\partial f(x,y)}{\partial y}=f(x,y+1)-f(x,y)

上述两个公式对所有 x 和 y 的有关值可用下图的一维模板对 f(x,y) 的滤波得到。

用于计算梯度偏导数的滤波器模板,通常称之为梯度算子边缘算子边缘检测子等。

对于不同的滤波器模板得到的梯度是不同的,这也就衍生出很多算子,如Roberts、Prewitt、Sobel和Laplacian算子等。下面将详细介绍不同的算子。


 

4 Roberts 算子

4.1 基本原理

Roberts算子又称为交叉微分算法,它是基于交叉差分的梯度算法,通过局部差分计算检测边缘线条。常用来处理具有陡峭的低噪声图像,当图像边缘接近于正45度或负45度时,该算法处理效果更理想。其缺点是对边缘的定位不太准确,提取的边缘线条较粗。

Roberts算子的模板分为水平方向和垂直方向,如下式所示,从其模板可以看出,Roberts算子能较好的增强正负45度的图像边缘。

                                                                          {{d}_{x}}=\left[ \begin{matrix} -1 & 0 \\ 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} \\ {} & {} \\ \end{matrix}{{d}_{y}}=\left[ \begin{matrix} 0 & -1 \\ 1 & 0 \\ \end{matrix} \right]

例如,下面给出Roberts算子模板,在像素点P5处 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                                   {{g}_{x}}=\frac{\partial f}{\partial x}=\text{P1-P5}

                                                                                   {{g}_{y}}=\frac{\partial f}{\partial y}=\text{P8-P6}

 

 

4.2 代码示例

在Python中,Roberts算子主要通过numpy定义模板,再调用OpenCV的 filter2D() 函数实现边缘提取。该函数主要是利用内核实现对图像的卷积运算。filter2D() 函数用法如下所示:

dst = filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])

其中,参数:

src 表示输入图像;

dst 表示输出的边缘图,其大小和通道数与输入图像相同;

ddepth 表示目标图像所需的深度;

kernel 表示卷积核,一个单通道浮点型矩阵;

anchor 表示内核的基准点,其默认值为 (-1,-1),位于中心位置;

delta 表示在储存目标图像前可选的添加到像素的值,默认值为0;

borderType 表示边框模式。

代码如下所示:

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
img = cv2.imread('zxp.jpg')
img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #转成RGB 方便后面显示

# 灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Roberts算子
kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
kernely = np.array([[0, -1], [1, 0]], dtype=int)
x = cv2.filter2D(grayImage, cv2.CV_16S, kernelx)
y = cv2.filter2D(grayImage, cv2.CV_16S, kernely)
# 转uint8
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# 显示图形
# titles = [u'原始图像', u'Roberts算子']
# images = [img_RGB, Roberts]
# for i in range(2):
#     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
#     plt.title(titles[i])
#     plt.xticks([]), plt.yticks([])

# plt.show()

# 显示图形
plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
plt.subplot(122),plt.imshow(Roberts, cmap=plt.cm.gray ),plt.title('Roberts算子'), plt.axis('off')
plt.show()

 

运行结果如下图所示:

 


 

5 Prewitt 算子

5.1 基本原理

Prewitt算子是一种图像边缘检测的微分算子,其原理是利用特定区域内像素灰度值产生的差分实现边缘检测。由于Prewitt算子采用 3\times3 模板对区域内的像素值进行计算,而Robert算子的模板为 2\times2,故Prewitt算子的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。Prewitt算子适合用来识别噪声较多、灰度渐变的图像,其计算公式如下所示:

                                                                  {{d}_{x}}=\left[ \begin{matrix} -1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} & {} \\ {} & {} & {} \\ {} & {} & {} \\ \end{matrix}{{d}_{y}}=\left[ \begin{matrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \\ \end{matrix} \right]

例如,下面给出Prewitt算子模板,在像素点P5处 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                {{g}_{x}}=\frac{\partial f}{\partial x}=(\text{P7+P8+P9)-}(\text{P1+P2+P3)}

                                                                {{g}_{y}}=\frac{\partial f}{\partial y}=(\text{P3+P6+P9)-}(\text{P1+P4+P7)}

 

5.2 代码示例

在Python中,Prewitt算子的实现过程与Roberts算子比较相似。通过Numpy定义模板,再调用OpenCV的filter2D() 函数实现对图像的卷积运算,最终通过 convertScaleAbs() addWeighted() 函数实现边缘提取。filter2D() 函数用法如下所示:

dst = filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])

其中,参数:

src 表示输入图像;

dst 表示输出的边缘图,其大小和通道数与输入图像相同;

ddepth 表示目标图像所需的深度;

kernel 表示卷积核,一个单通道浮点型矩阵;

anchor 表示内核的基准点,其默认值为(-1,-1),位于中心位置;

delta 表示在储存目标图像前可选的添加到像素的值,默认值为0;

borderType 表示边框模式。

 

代码如下所示:

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
img = cv2.imread('zxp.jpg')
img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Prewitt算子
kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=int)
kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=int)
x = cv2.filter2D(grayImage, cv2.CV_16S, kernelx)
y = cv2.filter2D(grayImage, cv2.CV_16S, kernely)
# 转uint8
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Prewitt = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# 显示图形
# titles = [u'原始图像', u'Prewitt算子']
# images = [img_RGB, Prewitt]
# for i in range(2):
#     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
#     plt.title(titles[i])
#     plt.xticks([]), plt.yticks([])
# plt.show()


# 显示图形
plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
plt.subplot(122),plt.imshow(Prewitt, cmap=plt.cm.gray ),plt.title('Prewitt算子'), plt.axis('off')
plt.show()

 

运行结果如下图所示:

由上图可以看出Prewitt算子的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。

 


 

6 Sobel 算子

6.1 基本原理

Sobel算子是一种用于边缘检测的离散微分算子,它结合了高斯平滑和微分求导。该算子用于计算图像明暗程度近似值,根据图像边缘旁边明暗程度把该区域内超过某个数的特定点记为边缘。Sobel算子在Prewitt算子的基础上增加了权重的概念,认为相邻点的距离远近对当前像素点的影响是不同的,距离越近的像素点对应当前像素的影响越大,从而实现图像锐化并突出边缘轮廓。

Sobel算子根据像素点上下、左右邻点灰度加权差,在边缘处达到极值这一现象检测边缘。对噪声具有平滑作用,提供较为精确的边缘方向信息。因为Sobel算子结合了高斯平滑和微分求导(分化),因此结果会具有更多的抗噪性,当对精度要求不是很高时,Sobel算子是一种较为常用的边缘检测方法。

Sobel算子的边缘定位更准确,常用于噪声较多、灰度渐变的图像。其算法模板如下面的公式所示,其中 {{d}_{x}} 表示水平方向,{{d}_{y}} 表示垂直方向。

                                                                 {{d}_{x}}=\left[ \begin{matrix} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} & {} \\ {} & {} & {} \\ {} & {} & {} \\ \end{matrix}{{d}_{y}}=\left[ \begin{matrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ 1 & 2 & 1 \\ \end{matrix} \right]

例如,下面给出Sobel算子模板,在像素点P5处 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                              {{g}_{x}}=\frac{\partial f}{\partial x}=(\text{P7+2P8+P9)-}(\text{P1+2P2+P3)}

                                                              {{g}_{y}}=\frac{\partial f}{\partial y}=(\text{P3+2P6+P9)-}(\text{P1+2P4+P7)}

 

6.2 代码示例

Sobel() 函数用法如下所示:

dst = Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]])

其中,参数:

src 表示输入图像;

dst 表示输出的边缘图,其大小和通道数与输入图像相同;

ddepth 表示目标图像所需的深度,针对不同的输入图像,输出目标图像有不同的深度;

dx 表示 x 方向上的差分阶数,取值1或 0;

dy 表示 y 方向上的差分阶数,取值1或0;

ksize 表示Sobel算子的大小,其值必须是正数奇数

scale 表示缩放导数的比例常数,默认情况下没有伸缩系数;

delta 表示将结果存入目标图像之前,添加到结果中的可选增量值;

borderType 表示边框模式,更多详细信息查阅BorderTypes。

 

:在进行Sobel算子处理之后,还需要调用 convertScaleAbs() 函数计算绝对值,并将图像转换为8位图进行显示。其函数用法如下所示:

dst = convertScaleAbs(src[, dst[, alpha[, beta]]])

其中,参数:

src 表示原数组;

dst 表示输出数组,深度为8位;

alpha 表示比例因子;

beta 表示原数组元素按比例缩放后添加的值。

 

代码如下所示:

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
img = cv2.imread('zxp.jpg')
img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Sobel算子
x = cv2.Sobel(grayImage, cv2.CV_16S, 1, 0)  # 对x求一阶导
y = cv2.Sobel(grayImage, cv2.CV_16S, 0, 1)  # 对y求一阶导
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# # 显示图形
# titles = [u'原始图像', u'Sobel算子']
# images = [lenna_img, Sobel]
# for i in xrange(2):
#     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
#     plt.title(titles[i])
#     plt.xticks([]), plt.yticks([])
# plt.show()

# 显示图形
plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
plt.subplot(122),plt.imshow(Sobel, cmap=plt.cm.gray ),plt.title('Sobel算子'), plt.axis('off')
plt.show()

 

运行结果如下图所示:

 


 

7 Laplacian 算子

7.1 基本原理

拉普拉斯(Laplacian) 算子是 n 维欧几里德空间中的一个二阶微分算子,常用于图像增强领域和边缘提取。它通过灰度差分计算邻域内的像素。

算法基本流程

1)判断图像中心像素灰度值与它周围其他像素的灰度值,如果中心像素的灰度更高,则提升中心像素的灰度;反之降低中心像素的灰度,从而实现图像锐化操作;

2)在算法实现过程中,Laplacian算子通过对邻域中心像素的四方向或八方向求梯度,再将梯度相加起来判断中心像素灰度与邻域内其他像素灰度的关系;

3)最后通过梯度运算的结果对像素灰度进行调整。

Laplacian算子分为四邻域和八邻域,四邻域是对邻域中心像素的四个方向求梯度,八邻域是对八个方向求梯度。

其中,Laplacian算子四邻域模板如下所示:

                                                                              \text{H}=\left[ \begin{matrix} 0 & -1 & 0 \\ -1 & 4 & -1 \\ 0 & -1 & 0 \\ \end{matrix} \right]

Laplacian算子的八邻域模板如下所示:

                                                                              \text{H}=\left[ \begin{matrix} -1 & -1 & -1 \\ -1 & 8 & -1 \\ -1 & -1 & -1 \\ \end{matrix} \right]

通过Laplacian算子的模板可以发现:

1)当邻域内像素灰度相同时,模板的卷积运算结果为0;

2)当中心像素灰度高于邻域内其他像素的平均灰度时,模板的卷积运算结果为正数;

3)当中心像素的灰度低于邻域内其他像素的平均灰度时,模板的卷积为负数。对卷积运算的结果用适当的衰弱因子处理并加在原中心像素上,就可以实现图像的锐化处理。

                                                                              

 

7.2 代码示例

Python和OpenCV将Laplacian算子封装在 Laplacian() 函数中,其函数用法如下所示:

dst = Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]])

其中,参数:

src 表示输入图像;

dst 表示输出的边缘图,其大小和通道数与输入图像相同;

ddepth 表示目标图像所需的深度;

ksize 表示用于计算二阶导数的滤波器的孔径大小,其值必须是正数和奇数,且默认值为1,更多详细信息查阅getDerivKernels ;

scale 表示计算拉普拉斯算子值的可选比例因子。默认值为1,更多详细信息查阅getDerivKernels;

delta 表示将结果存入目标图像之前,添加到结果中的可选增量值,默认值为0;

borderType 表示边框模式,更多详细信息查阅BorderTypes。

:Laplacian算子其实主要是利用Sobel算子的运算,通过加上Sobel算子运算出的图像 x 方向和 y 方向上的导数,得到输入图像的图像锐化结果。同时,在进行Laplacian算子处理之后,还需要调用 convertScaleAbs() 函数计算绝对值,并将图像转换为8位图进行显示。其函数用法如下:

dst = convertScaleAbs(src[, dst[, alpha[, beta]]])

其中,参数:

src 表示原数组;

dst 表示输出数组,深度为8位;

alpha 表示比例因子;

beta 表示原数组元素按比例缩放后添加的值。

当ksize=1时,Laplacian() 函数采用 3\times3 的孔径 (四邻域模板) 进行变换处理。下面的代码是采用 ksize=3 的Laplacian算子进行图像锐化处理。

 

代码如下所示:

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
img = cv2.imread('zxp.jpg')
img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 拉普拉斯算法
dst = cv2.Laplacian(grayImage, cv2.CV_16S, ksize=3)
Laplacian = cv2.convertScaleAbs(dst)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# # 显示图形
# titles = [u'原始图像', u'Laplacian算子']
# images = [lenna_img, Laplacian]
# for i in xrange(2):
#     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
#     plt.title(titles[i])
#     plt.xticks([]), plt.yticks([])
# plt.show()


# 显示图形
plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
plt.subplot(122),plt.imshow(Laplacian, cmap=plt.cm.gray ),plt.title('Laplacian算子'), plt.axis('off')
plt.show()

 

运行结果如下图所示:

 


 

8 小结

8.1 各类算子实验比较

边缘检测算法主要是基于图像强度的一阶导数二阶导数,但导数通常对噪声很敏感,因此需要采用滤波器来过滤噪声,并调用图像增强或阈值化算法进行处理,最后再进行边缘检测。下面是采用高斯滤波去噪和阈值化处理之后,再进行边缘检测的过程,并对比了四种常见的边缘提取算法。

 

代码如下所示:

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import matplotlib.pyplot as plt

#读取图像
img = cv2.imread('zxp.jpg')
img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #转成RGB 方便后面显示

#灰度化处理图像
grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#高斯滤波
gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0)

#阈值处理
ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)

#Roberts算子
kernelx = np.array([[-1,0],[0,1]], dtype=int)
kernely = np.array([[0,-1],[1,0]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#Prewitt算子
kernelx = np.array([[1,1,1],[0,0,0],[-1,-1,-1]], dtype=int)
kernely = np.array([[-1,0,1],[-1,0,1],[-1,0,1]], dtype=int)
x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
y = cv2.filter2D(binary, cv2.CV_16S, kernely)
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0)

#Sobel算子
x = cv2.Sobel(binary, cv2.CV_16S, 1, 0)
y = cv2.Sobel(binary, cv2.CV_16S, 0, 1)
absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)
Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

#Laplacian算子
dst = cv2.Laplacian(binary, cv2.CV_16S, ksize = 3)
Laplacian = cv2.convertScaleAbs(dst)

# #效果图
# titles = ['Source Image', 'Binary Image', 'Roberts Image',
#           'Prewitt Image','Sobel Image', 'Laplacian Image']
# images = [lenna_img, binary, Roberts, Prewitt, Sobel, Laplacian]
# for i in np.arange(6):
#    plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')
#    plt.title(titles[i])
#    plt.xticks([]),plt.yticks([])
# plt.show()

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# # 显示图形
plt.subplot(231),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
plt.subplot(232),plt.imshow(binary, cmap=plt.cm.gray ),plt.title('二值图'), plt.axis('off')
plt.subplot(233),plt.imshow(Roberts, cmap=plt.cm.gray ),plt.title('Roberts算子'), plt.axis('off')
plt.subplot(234),plt.imshow(Prewitt, cmap=plt.cm.gray ),plt.title('Prewitt算子'), plt.axis('off')
plt.subplot(235),plt.imshow(Sobel, cmap=plt.cm.gray ),plt.title('Sobel算子'), plt.axis('off')
plt.subplot(236),plt.imshow(Laplacian, cmap=plt.cm.gray ),plt.title('Laplacian算子'), plt.axis('off')

plt.show()

 

运行结果如下图所示:

 

为了比较不同算子,多测试了几张图像,如下图所示:

 

 

 

由上面的结果所示,不同的算子进行了比较。可知:

1)Robert算子对陡峭的低噪声图像效果较好,尤其是边缘正负45度较多的图像,但定位准确率较差;

2)Prewitt算子对灰度渐变的图像边缘提取效果较好,而没有考虑相邻点的距离远近对当前像素点的影响;

3)Sobel算子考虑了综合因素,对噪声较多的图像处理效果更好。

4)Laplacian算子对噪声比较敏感,由于其算法可能会出现双像素边界,常用来判断边缘像素位于图像的明区或暗区,很少用于边缘检测;

 

8.2 各类算子的优缺点

(1)Roberts 算子 

Roberts算子利用局部差分算子寻找边缘,边缘定位精度较高,但容易丢失一部分边缘,不具备抑制噪声的能力。该算子对具有陡峭边缘且含噪声少的图像效果较好,尤其是边缘正负45度较多的图像,但定位准确率较差;

 

(2)Sobel 算子

Sobel算子考虑了综合因素,对噪声较多的图像处理效果更好,Sobel 算子边缘定位效果不错,但检测出的边缘容易出现多像素宽度。

 

(3) Prewitt 算子

Prewitt算子对灰度渐变的图像边缘提取效果较好,而没有考虑相邻点的距离远近对当前像素点的影响,与Sobel 算子类似,不同的是在平滑部分的权重大小有些差异;

 

(4)Laplacian 算子

Laplacian 算子不依赖于边缘方向的二阶微分算子,对图像中的阶跃型边缘点定位准确,该算子对噪声非常敏感,它使噪声成分得到加强,这两个特性使得该算子容易丢失一部分边缘的方向信息,造成一些不连续的检测边缘,同时抗噪声能力比较差,由于其算法可能会出现双像素边界,常用来判断边缘像素位于图像的明区或暗区,很少用于边缘检测;

 


 

参考资料

[1] https://blog.csdn.net/Eastmount/article/details/89001702

[2] 杨帆. 数字图像处理与分析(第三版). 北京航空航天大学出版社

[3] 冈萨雷斯. 数字图像处理(第三版) 

没有更多推荐了,返回首页