python图像边缘检测

---

原文：https://blog.csdn.net/HuangZhang_123/article/details/80511270

import cv2

img = cv2.imread(r"e:\new\fanshe3.jpg", 0)
cv2.imwrite("canny.jpg", cv2.Canny(img, 200, 300))
cv2.imshow("canny", cv2.imread("canny.jpg"))
cv2.waitKey()
cv2.destroyAllWindows()

 

很明显，Canny边缘检测的效果是很显著的。相比普通的梯度算法大大抑制了噪声引起的伪边缘，而且是边缘细化，易于后续处理。对于对比度较低的图像，通过调节参数，Canny算法也能有很好的效果。

      

                       原图                            Canny梯度模，高斯半径2，低阀值30，高阀值100       Canny梯度二值化图，高斯半径2，低阀值30，高阀值100

      

                      原图                         Canny梯度模，高斯半径1，低阀值40，高阀值80  Canny梯度二值化图，高斯半径1，低阀值40，高阀值80

 

Sobel边缘检测

 

Sobel算子是一种具有方向性的边缘检测算子，可以分别计算水平和垂直方向上的灰阶突变。

 

 

import cv2

img = cv2.imread("01.jpg", 0)

x = cv2.Sobel(img, cv2.CV_16S, 1, 0)
y = cv2.Sobel(img, cv2.CV_16S, 0, 1)

xy = cv2.Sobel(img,cv2.CV_16S, 1 , 1)

absX = cv2.convertScaleAbs(x)
absY = cv2.convertScaleAbs(y)

xy = cv2.convertScaleAbs(xy)

dst = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

cv2.imshow("absX", absX)
cv2.imshow("absY", absY)
cv2.imshow("Result", dst)
cv2.imshow("XY",xy)
cv2.waitKey(0)
cv2.destroyAllWindows()

 

cv2.Sobel()函数中第三和第四个参数如果都取1，处理效果是检测到倾斜方向上的边缘，对水平和垂直方向上的边缘都过滤掉了。

 

Laplacian边缘检测

 

 

Laplacian基本上可以检测出图像在各个方向上的灰阶突变，效果上基本等同于使用Sobel检测的X和Y方向上的边缘的叠加。

 

 

import cv2
import numpy

img = cv2.imread("01.jpg", 0)
imgGau = cv2.GaussianBlur(img,(5,5),0)

gray_lap = cv2.Laplacian(imgGau, cv2.CV_16S, ksize=3)
dst = cv2.convertScaleAbs(gray_lap)

bond = numpy.hstack((img,dst))

cv2.imshow("bond",bond)
cv2.waitKey(0)
cv2.destroyAllWindows()

 

numpy中的hstack()函数可以把两幅尺寸相同的图片粘合到一起。
Canny边缘检测

Canny边缘检测可以相对有效的连接断裂的边缘，需要指定一个最大最小灰阶值组成区间，结果生成的是二值图像。

import cv2

img = cv2.imread("01.jpg", 0)
img = cv2.GaussianBlur(img, (3, 3), 0)

canny = cv2.Canny(img, 50, 255)

cv2.imshow('Canny', canny)
cv2.waitKey(0)
cv2.destroyAllWindows()

---

 导数，梯度，边缘信息 

在数学中，与变化率有关的就是导数。

如果灰度图像的像素是连续的(实际不是)，那么我们可以分别原图像G对x方向和y方向求导数

，

获得x方向的导数图像Gx和y方向的导数图像Gy。Gx和Gy分别隐含了x和y方向的灰度变化信息，也就隐含了边缘信息。

如果要在同一图像上包含两个方向的边缘信息，我们可以用到梯度。（梯度是一个向量）

原图像的梯度向量Gxy为（Gx,Gy）,梯度向量的大小和方向可以用下面两个式子计算

角度值好像需要根据向量所在象限不同适当+pi或者-pi。

梯度向量大小就包含了x方向和y方向的边缘信息。

---

 

 图像导数 

实际上，图像矩阵是离散的。

连续函数求变化率用的是导数，而离散函数求变化率用的是差分。

差分的概念很容易理解，就是用相邻两个数的差来表示变化率。

下面公式是向后差分

x方向的差分：Gx(n,y) = G(n,y)-G(n-1,y)

y方向的差分：Gy(x,n) = G(x,n)-G(x,n-1)

 实际计算图像导数时，我们是通过原图像和一个算子进行卷积来完成的(这种方法是求图像的近似导数)。

最简单的求图像导数的算子是 Prewitt算子 ：

x方向的Prewitt算子为

y方向的Prewitt算子为

---------------------------------------------

原图像和一个算子进行卷积的大概过程如下

如果图像矩阵中一块区域为

那么x5处的x方向的导数是，将x方向算子的中心和x5重合，然后对应元素相乘再求和，即

x5处的x方向导数为x3+x6+x9-x1-x4-x7

对矩阵中所有元素进行上述计算，就是卷积的过程。

--------------------------------------------

因此，利用原图像和x方向Prewitt算子进行卷积就可以得到图像的x方向导数矩阵Gx，

利用原图像和y方向Prewitt算子进行卷积就可以得到图像的y方向导数矩阵Gy。

利用公式

就可以得到图像的梯度矩阵Gxy，这个矩阵包含图像x方向和y方向的边缘信息。

---

 

 Python实现卷积及Prewitt算子的边缘检测 

 首先我们把图像卷积函数封装在一个名为imconv的函数中  ( 实际上，scipy库中的signal模块含有一个二维卷积的方法convolve2d()  )

import numpy as np
from PIL import Image

def imconv(image_array,suanzi):
    '''计算卷积
        参数
        image_array 原灰度图像矩阵
        suanzi      算子
        返回
        原图像与算子卷积后的结果矩阵
    '''
    image = image_array.copy()     # 原图像矩阵的深拷贝
    
    dim1,dim2 = image.shape

    # 对每个元素与算子进行乘积再求和(忽略最外圈边框像素)
    for i in range(1,dim1-1):
        for j in range(1,dim2-1):
            image[i,j] = (image_array[(i-1):(i+2),(j-1):(j+2)]*suanzi).sum()
    
    # 由于卷积后灰度值不一定在0-255之间，统一化成0-255
    image = image*(255.0/image.max())

    # 返回结果矩阵
    return image

 

然后我们利用Prewitt算子计算x方向导数矩阵Gx，y方向导数矩阵Gy，和梯度矩阵Gxy。

import numpy as np
import matplotlib.pyplot as plt

# x方向的Prewitt算子
suanzi_x = np.array([[-1, 0, 1],
                    [ -1, 0, 1],
                    [ -1, 0, 1]])

# y方向的Prewitt算子
suanzi_y = np.array([[-1,-1,-1],
                     [ 0, 0, 0],
                     [ 1, 1, 1]])

# 打开图像并转化成灰度图像
image = Image.open("pika.jpg").convert("L")

# 转化成图像矩阵
image_array = np.array(image)

# 得到x方向矩阵
image_x = imconv(image_array,suanzi_x)

# 得到y方向矩阵
image_y = imconv(image_array,suanzi_y)

# 得到梯度矩阵
image_xy = np.sqrt(image_x**2+image_y**2)
# 梯度矩阵统一到0-255
image_xy = (255.0/image_xy.max())*image_xy

# 绘出图像
plt.subplot(2,2,1)
plt.imshow(image_array,cmap=cm.gray)
plt.axis("off")
plt.subplot(2,2,2)
plt.imshow(image_x,cmap=cm.gray)
plt.axis("off")
plt.subplot(2,2,3)
plt.imshow(image_y,cmap=cm.gray)
plt.axis("off")
plt.subplot(2,2,4)
plt.imshow(image_xy,cmap=cm.gray)
plt.axis("off")
plt.show()

 

 Prewitt算子 的结果如下图所示

上方：左图为原图像，右图为x方向导数图像

下方：左图为y方向导数图像，右图为梯度图像

从图中可以看出，Prewitt算子虽然能检测出图像边缘，但是检测结果较为粗糙，还带有大量的噪声。

---

 

 近似导数的Sobel算子 

Sobel算子与Prewitt比较类似，但是它比Prewitt算子要好一些。

x方向的Sobel算子为

y方向的Sobel算子为

python代码只需要将上面代码中的Prewitt算子改成Sobel算子即可。

# x方向的Sobel算子
suanzi_x = np.array([[-1, 0, 1],
                    [ -2, 0, 2],
                    [ -1, 0, 1]])

# y方向的Sobel算子
suanzi_y = np.array([[-1,-2,-1],
                     [ 0, 0, 0],
                     [ 1, 2, 1]])

 Sobel算子 的结果如下图所示

上方：左图为原图像，右图为x方向导数图像

下方：左图为y方向导数图像，右图为梯度图像

从图中看出，比较Prewitt算子和Sobel算子，Sobel算子稍微减少了一点噪声，但噪声还是比较多的。

---

 近似二阶导数的Laplace算子 

Laplace算子是一个二阶导数的算子，它实际上是一个x方向二阶导数和y方向二阶导数的和的近似求导算子。

实际上，Laplace算子是通过Sobel算子推导出来的。

Laplace算子为

Laplace还有一种扩展算子为

为了不再重复造轮子，这次我们运用scipy库中signal模块的convolve()方法来计算图像卷积。

convolve()的第一个参数是原图像矩阵，第二个参数为卷积算子，然后指定关键字参数mode="same"(输出矩阵大小和原图像矩阵相同)。

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import scipy.signal as signal     # 导入sicpy的signal模块

# Laplace算子
suanzi1 = np.array([[0, 1, 0],  
                    [1,-4, 1],
                    [0, 1, 0]])

# Laplace扩展算子
suanzi2 = np.array([[1, 1, 1],
                    [1,-8, 1],
                    [1, 1, 1]])

# 打开图像并转化成灰度图像
image = Image.open("pika.jpg").convert("L")
image_array = np.array(image)

# 利用signal的convolve计算卷积
image_suanzi1 = signal.convolve2d(image_array,suanzi1,mode="same")
image_suanzi2 = signal.convolve2d(image_array,suanzi2,mode="same")

# 将卷积结果转化成0~255
image_suanzi1 = (image_suanzi1/float(image_suanzi1.max()))*255
image_suanzi2 = (image_suanzi2/float(image_suanzi2.max()))*255

# 为了使看清边缘检测结果，将大于灰度平均值的灰度变成255(白色)
image_suanzi1[image_suanzi1>image_suanzi1.mean()] = 255
image_suanzi2[image_suanzi2>image_suanzi2.mean()] = 255

# 显示图像
plt.subplot(2,1,1)
plt.imshow(image_array,cmap=cm.gray)
plt.axis("off")
plt.subplot(2,2,3)
plt.imshow(image_suanzi1,cmap=cm.gray)
plt.axis("off")
plt.subplot(2,2,4)
plt.imshow(image_suanzi2,cmap=cm.gray)
plt.axis("off")
plt.show()

 

结果如下图

其中上方为原图像

下方：左边为Laplace算子结果，右边为Laplace扩展算子结果

从结果可以看出，laplace算子似乎比前面两个算子（prewitt算子和Sobel算子）要好一些，噪声减少了，但还是比较多。

而Laplace扩展算子的结果看上去比Laplace的结果少一些噪声。

---

 降噪后进行边缘检测 

 为了获得更好的边缘检测效果，可以先对图像进行模糊平滑处理，目的是去除图像中的高频噪声。

python程序如下

首先用标准差为5的5*5高斯算子对图像进行平滑处理，然后利用Laplace的扩展算子对图像进行边缘检测。

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import scipy.signal as signal

# 生成高斯算子的函数
def func(x,y,sigma=1):
    return 100*(1/(2*np.pi*sigma))*np.exp(-((x-2)**2+(y-2)**2)/(2.0*sigma**2))

# 生成标准差为5的5*5高斯算子
suanzi1 = np.fromfunction(func,(5,5),sigma=5)

# Laplace扩展算子
suanzi2 = np.array([[1, 1, 1],
                    [1,-8, 1],
                    [1, 1, 1]])

# 打开图像并转化成灰度图像
image = Image.open("pika.jpg").convert("L")
image_array = np.array(image)

# 利用生成的高斯算子与原图像进行卷积对图像进行平滑处理
image_blur = signal.convolve2d(image_array, suanzi1, mode="same")

# 对平滑后的图像进行边缘检测
image2 = signal.convolve2d(image_blur, suanzi2, mode="same")

# 结果转化到0-255
image2 = (image2/float(image2.max()))*255

# 将大于灰度平均值的灰度值变成255（白色），便于观察边缘
image2[image2>image2.mean()] = 255

# 显示图像
plt.subplot(2,1,1)
plt.imshow(image_array,cmap=cm.gray)
plt.axis("off")
plt.subplot(2,1,2)
plt.imshow(image2,cmap=cm.gray)
plt.axis("off")
plt.show()

 

结果如下图

从图中可以看出，经过降噪处理后，边缘效果较为明显。

---

 

参考列表

1. 《python计算机视觉编程》 

2. 网络（感谢百度，感觉网络上分享知识的网友）

---

实际上，一些现成的Python库已经对边缘检测过程进行了封装，效果和效率更为出色。

文中以自己的python代码进行边缘检测，实际上是想对实际过程有更好的认识和了解