Programming Computer Vision with Python （学习笔记七）

摘要：数学形态学关注的是图像中的形状，它提供了一些方法用于检测形状和改变形状。所以这个结果也会把形状以外的噪点排除掉。你还可以查看其它笔记。参考资料图像的膨胀与腐蚀数学形态学基本操作及其应用计算机视觉特征提取与图像处理第三版

数学形态学（mathematical morphology）关注的是图像中的形状，它提供了一些方法用于检测形状和改变形状。起初是基于二值图像提出的，后来扩展到灰度图像。二值图像就是：每个像素的值只能是0或1，1代表描绘图像的点，0代表背景。

基本的形态学运算包括：腐蚀（erosion）、膨胀（dilation）、开（opening）、闭（closing），对于这些运算，都需要用到被称为结构元素(Structuring element)的模板，一般为方形，以小矩阵的形式表示，但它的元素的值只能是0或1，它代表的是一个集合，这个集合罩在原图像上，可以跟原图像的形状进行集合运算。

要讲清楚去处过程不容易，直接上图看效果：

图中(a)为原图像，(b)为腐蚀运算后结果，可以看出除了字母笔刷变细了之外，黑色背景的噪点也都不见了，(c)是膨胀运算结果，字母笔刷比原图像粗。

ok，现在看腐蚀是怎么实现的，还是先看图：

如图所示，(a)是3×3结构元素，相当于：

array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

图中标识出了它的中心点。

结构元素的设置也可以是其它大小，也不一定全是1（黑点），比如是一个3×3十字形：

[[0,1,0],
 [1,1,1],
 [0,1,0]]

(b)为待处理的原图像，我们把其中由所有黑点组成的集合设为X

(c)为腐蚀后的结果，黑色点就是经过腐蚀之后保留下来的点，灰色的点表示被排除出去的点，我们看到的效果是X变小了一圈，这也之所以叫腐蚀的原因吧。

可以这样来形象理解腐蚀运算过程：将结构元素平移到原图像上某个位置，如果结构元素中所有的黑点（值为1）都落在X里，就把结构元素中心点对应的原图像的像素点保留下来，否则就排除出去，如(c)所示，假设结构元素盖在这个位置，这时结构元素下半部还有几个点没落在原图X中，所以将中心点对应的像素点排除出去，从黑色标记为灰色。将结构元素在原图像上进行平移，直到原图像的每一个像素都被处理过。

所以这个结果也会把形状以外的噪点排除掉。

腐蚀函数说明

scipy.ndimage.morphology.binary_erosion(input, structure=None, iterations=1,...)

input: 原图像二值图
structure: 即结构元素，默认为3×3十字形
iterations: 表示要连续应用腐蚀多少次

返回腐蚀后二值图结果，ndarray类型

示例：

>>> a = np.zeros((7,7), dtype=np.int)
>>> a[1:6, 2:5] = 1
>>> a  #原图像二值图，注意中间由1组成的矩形形状
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])
       
>>> ndimage.binary_erosion(a).astype(a.dtype) 
#可以看出矩形形状被"腐蚀"了一圈
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])     

类似地：

如图(c)就是膨胀的结果，运算过程跟腐蚀类似，只不过对像素的排除判断不一样，膨胀的判断方式是：只要结构元素中有一个黑点（值为1）落在X集合里，就把结构元素中心点对应的原图像的像素点保留下来，否则就排除出去。

膨胀函数scipy.ndimage.morphology.binary_dilation与腐蚀类似，使用示例：

>>> a = np.zeros((5, 5))
>>> a[2, 2] = 1
>>> a
array([
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
>>> ndimage.binary_dilation(a).astype(a. dtype) #binary_dilation第二个参数可指定结构元素，默认为3×3十字形
array([
[ 0., 0., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 1., 1., 1., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 0., 0.]])

我们从以上的效果图可以看到，腐蚀和膨胀可以改变形状，同时也可以去背景噪点。
另外，把形状的膨胀结果减去它的腐蚀结果，可以得到形状的粗略边缘以及角点。

先对原图像进行腐蚀，再膨胀，就是开运算。有什么用呢？简单点说它可以去除与结构元素大小相当的孔洞和碎片。如果一处图像中有多个形状，开运算可以把那些只有一点点粘连的形状分开。因为那点粘连的地方被去除了。
简单示例：

>>> a = np.zeros((5,5), dtype=np.int)
>>> a[1:4, 1:4] = 1; a[4, 4] = 1
>>> a #原图像，注意右下角有个1，表示零散的碎片
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 1]])

>>> ndimage.binary_opening(a, structure=np.ones((3,3))).astype(np.int)
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0]]) #基于3×3全1的结构元素应用开运算，把原图像角落的1去掉
       
>>> ndimage.binary_opening(a).astype(np.int)
array([[0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 1, 0, 0],
       [0, 0, 0, 0, 0]]) #还可以用于平滑边角，也就是四角处缩小变平滑了，如果形状与形状有边角的粘连，就可以分开

与开运算相反，先对原图进行膨胀，再腐蚀，就是闭运算。闭运算可以填充图像中的孔洞，连接一些缺口和碎片，变成块状。举个应用场景——车牌定位，如下图：

右图是使用通过简单的算法得到车的粗略边角，车牌位置像是一堆散点，如果对这个边角图运用闭运算可以得到这样的效果：

车牌的位置变成一个接近车牌形状的矩形，为下一步检测提供了便利。

闭运算函数ndimage.binary_closing的用法：

>>> a = np.zeros((5,5), dtype=np.int)
>>> a[1:-1, 1:-1] = 1; a[2,2] = 0
>>> a #原图像，注意中间有个0，表示形状里面有个空洞
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 0, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0]])

>>> ndimage.binary_closing(a).astype(np.int)
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0]])  #应用闭运算之后，空洞被填充了

开闭运算原理看似简单，但很强大，只要结构元素选取得当，可以做很多事情。

这里说的对象是指图像中与周围没有连通的多带带的形状，我们的目标是要计算这些对象的个数，计算对象个数可以使用函数：

label, num_features = scipy.ndimage.measurements.label(input, structure=None, output=None)
参数
input: 数组类型，其中元素非0值表示对象组成的点，0表示图像背景
structure: 结构元素，用于检测对象的连通特征，默认是3×3十字形

返回值
label: 返回与input一样的大小，但是把对象标记出来
num_features：对象的个数

用法简单示例：

>>> a = np.array([[0,0,1,1,0,0],
...               [0,0,0,1,0,0],
...               [1,1,0,0,1,0],
...               [0,0,0,1,0,0]])
>>> labeled_array, num_features = measurements.label(a) #使用默认3×3十字形结构元素
>>> print(num_features)
4
>>> print(labeled_array) #打印被识别出来的对象的位置，分别用1,2,3...递增的下标标记出来，所以labeled_array可以当成灰度图打印出来，被标识的对象的灰度从黑到白变化
array([[0, 0, 1, 1, 0, 0],
       [0, 0, 0, 1, 0, 0],
       [2, 2, 0, 0, 3, 0],
       [0, 0, 0, 4, 0, 0]])

从上面例子看出，使用默认3×3十字形结构元素，检测时，只有水平和垂直连通才认为像素属于同一个对象，对角连通不算，如果要把对角连通当作是同一个对象来计算，可以指定结构元素为：

[[1,1,1],
 [1,1,1],
 [1,1,1]]

有时候，因受噪声影响，对象之间有一点边角的粘连，人眼可以很容易分辨出是两个对象，但要让label函数理解这一点，可以使用前面提到的开运算先对把对象稍微分开，再把结果传给label函数进行计数，下面给出一个具体的图像进行示例：

from PIL import Image
import numpy as np
from scipy.ndimage import measurements,morphology
import matplotlib.pyplot as plt

im = np.array(Image.open("house.png").convert("L"))
im = 1 * (im < 128) #把灰度图像转为二值图，即灰度少于128的当成图像黑点，否则当作背景

label_from_origin, num_from_origin = measurements.label(im)

im_open = morphology.binary_opening(im, np.ones((9, 5)), iterations=2) #运用了一个9×5全1的结构元素，并连续应用两次开运算
label_from_open, num_from_open = measurements.label(im_open)

#以下是画图
index = 221
plt.subplot(index)
plt.imshow(im)
plt.title("original")
plt.axis("off")

plt.subplot(index + 1)
plt.imshow(label_from_origin)
plt.title("%d objects" % num_from_origin)
plt.axis("off")

plt.subplot(index + 2)
plt.imshow(im_open)
plt.title("apply opening")
plt.axis("off")

plt.subplot(index + 3)
plt.imshow(label_from_open)
plt.title("%d objects" % num_from_open)
plt.axis("off")

#plt.gray()  #为了更好的看出对象的分离，故意不用灰度显示
plt.show()

效果图如下，第二组（即第二行）是应用开运算之后的图像及计算结果，跟第一组相比，对象计数增加了，我在第二组图中圈出了应用开运算之后的主要变化之处：

上面介绍的用于二值图的一些函数，也有其对应的用于灰度图像的函数，包括：

grey_erosion()

grey_dilation()

grey_opening()

grey_closing()

下一节学习图像去噪。
你还可以查看其它笔记。

图像的膨胀与腐蚀
数学形态学基本操作及其应用
《计算机视觉特征提取与图像处理（第三版）》