2.6.4 图像过滤

局部过滤器: 通过临近像素值的函数来替换像素的值。

邻居: 方块 (选择大小)、 硬盘、或者更复杂的结构化元素。

2.6.4 图像过滤 - 图1

2.6.4.1 模糊 / 光滑

高斯过滤器 来自 scipy.ndimage:

In [29]:

  1. from scipy import misc
  2. face = misc.face(gray=True)
  3. blurred_face = ndimage.gaussian_filter(face, sigma=3)
  4. very_blurred = ndimage.gaussian_filter(face, sigma=5)

均匀过滤器

In [30]:

  1. local_mean = ndimage.uniform_filter(face, size=11)

2.6.4 图像过滤 - 图2

[Python source code]

2.6.4.2 锐化

锐化模糊的图像:

In [31]:

  1. from scipy import misc
  2. face = misc.face(gray=True).astype(float)
  3. blurred_f = ndimage.gaussian_filter(face, 3)

通过添加Laplacian的近似值来增加边缘的权重:

In [32]:

  1. filter_blurred_f = ndimage.gaussian_filter(blurred_f, 1)
  2. alpha = 30
  3. sharpened = blurred_f + alpha * (blurred_f - filter_blurred_f)

2.6.4 图像过滤 - 图3

[Python source code]

2.6.4.3 降噪

有噪音的脸:

In [33]:

  1. from scipy import misc
  2. f = misc.face(gray=True)
  3. f = f[230:290, 220:320]
  4. noisy = f + 0.4 * f.std() * np.random.random(f.shape)

高斯过滤器光滑了噪音… 以及边缘:

In [34]:

  1. gauss_denoised = ndimage.gaussian_filter(noisy, 2)

绝大多数局部线性各向同性过滤器模糊图像 (ndimage.uniform_filter)

中位数过滤器更好的保留的边缘:

In [35]:

  1. med_denoised = ndimage.median_filter(noisy, 3)

2.6.4 图像过滤 - 图4

[Python source code]

中位数过滤器: 对直边缘的结果更好 (低曲度):

In [37]:

  1. im = np.zeros((20, 20))
  2. im[5:-5, 5:-5] = 1
  3. im = ndimage.distance_transform_bf(im)
  4. im_noise = im + 0.2 * np.random.randn(*im.shape)
  5. im_med = ndimage.median_filter(im_noise, 3)

2.6.4 图像过滤 - 图5

[Python source code]

其他排名过滤器：ndimage.maximum_filter、ndimage.percentile_filter

其他的局部非线性过滤器: Wiener (scipy.signal.wiener) 等等.

非局部过滤器

练习: 降噪

  • 创建一个带有一些对象 (圆形、椭圆、正方形或随机形状) 的二元图像 (0 和 1) .
  • 添加一些噪音 (例如, 20% 的噪音)
  • 用两种不同的降噪方法来降噪这个图像: 高斯过滤器和中位数过滤器。
  • 比较两种不同降噪方法的直方图。哪一个与原始图像（无噪音）的直方图最接近?

也看一下： 在skimage.denoising中有更多的的降噪过滤器可用，见教程Scikit-image: 图像处理.

2.6.4.4 数学形态学

看一下wikipedia上的数学形态学定义。

探索一个简单形状 (结构化的元素) 的图像，然后根据这个形状是如何局部适应或不适应这个图像来修改这个图像。

结构化元素:

In [38]:

  1. el = ndimage.generate_binary_structure(2, 1)
  2. el

Out[38]:

  1. array([[False,  True, False],
  2.        [ True,  True,  True],
  3.        [False,  True, False]], dtype=bool)

In [39]:

  1. el.astype(np.int)

Out[39]:

  1. array([[0, 1, 0],
  2.        [1, 1, 1],
  3.        [0, 1, 0]])

2.6.4 图像过滤 - 图6

风化(Erosion) = 最小值过滤器。用结构化元素所覆盖的最小值来替换像素的值。:

In [41]:

  1. a = np.zeros((7,7), dtype=np.int)
  2. a[1:6, 2:5] = 1
  3. a

Out[41]:

  1. array([[0, 0, 0, 0, 0, 0, 0],
  2.        [0, 0, 1, 1, 1, 0, 0],
  3.        [0, 0, 1, 1, 1, 0, 0],
  4.        [0, 0, 1, 1, 1, 0, 0],
  5.        [0, 0, 1, 1, 1, 0, 0],
  6.        [0, 0, 1, 1, 1, 0, 0],
  7.        [0, 0, 0, 0, 0, 0, 0]])

In [42]:

  1. ndimage.binary_erosion(a).astype(a.dtype)

Out[42]:

  1. array([[0, 0, 0, 0, 0, 0, 0],
  2.        [0, 0, 0, 0, 0, 0, 0],
  3.        [0, 0, 0, 1, 0, 0, 0],
  4.        [0, 0, 0, 1, 0, 0, 0],
  5.        [0, 0, 0, 1, 0, 0, 0],
  6.        [0, 0, 0, 0, 0, 0, 0],
  7.        [0, 0, 0, 0, 0, 0, 0]])

In [43]:

  1. #风化删除了比结构小的对象
  2. ndimage.binary_erosion(a, structure=np.ones((5,5))).astype(a.dtype)

Out[43]:

  1. array([[0, 0, 0, 0, 0, 0, 0],
  2.        [0, 0, 0, 0, 0, 0, 0],
  3.        [0, 0, 0, 0, 0, 0, 0],
  4.        [0, 0, 0, 0, 0, 0, 0],
  5.        [0, 0, 0, 0, 0, 0, 0],
  6.        [0, 0, 0, 0, 0, 0, 0],
  7.        [0, 0, 0, 0, 0, 0, 0]])

2.6.4 图像过滤 - 图7

扩大(Dilation)：最大值过滤器：

In [44]:

  1. a = np.zeros((5, 5))
  2. a[2, 2] = 1
  3. a

Out[44]:

  1. array([[ 0.,  0.,  0.,  0.,  0.],
  2.        [ 0.,  0.,  0.,  0.,  0.],
  3.        [ 0.,  0.,  1.,  0.,  0.],
  4.        [ 0.,  0.,  0.,  0.,  0.],
  5.        [ 0.,  0.,  0.,  0.,  0.]])

In [45]:

  1. ndimage.binary_dilation(a).astype(a.dtype)

Out[45]:

  1. array([[ 0.,  0.,  0.,  0.,  0.],
  2.        [ 0.,  0.,  1.,  0.,  0.],
  3.        [ 0.,  1.,  1.,  1.,  0.],
  4.        [ 0.,  0.,  1.,  0.,  0.],
  5.        [ 0.,  0.,  0.,  0.,  0.]])

对于灰度值图像同样适用:

In [46]:

  1. np.random.seed(2)
  2. im = np.zeros((64, 64))
  3. x, y = (63*np.random.random((2, 8))).astype(np.int)
  4. im[x, y] = np.arange(8)
  5. bigger_points = ndimage.grey_dilation(im, size=(5, 5), structure=np.ones((5, 5)))
  6. square = np.zeros((16, 16))
  7. square[4:-4, 4:-4] = 1
  8. dist = ndimage.distance_transform_bf(square)
  9. dilate_dist = ndimage.grey_dilation(dist, size=(3, 3), structure=np.ones((3, 3)))

2.6.4 图像过滤 - 图8

[Python source code]

Opening: erosion + dilation:

In [48]:

  1. a = np.zeros((5,5), dtype=np.int)
  2. a[1:4, 1:4] = 1; a[4, 4] = 1
  3. a

Out[48]:

  1. array([[0, 0, 0, 0, 0],
  2.        [0, 1, 1, 1, 0],
  3.        [0, 1, 1, 1, 0],
  4.        [0, 1, 1, 1, 0],
  5.        [0, 0, 0, 0, 1]])

In [49]:

  1. # Opening 删除小对象
  2. ndimage.binary_opening(a, structure=np.ones((3,3))).astype(np.int)

Out[49]:

  1. array([[0, 0, 0, 0, 0],
  2.        [0, 1, 1, 1, 0],
  3.        [0, 1, 1, 1, 0],
  4.        [0, 1, 1, 1, 0],
  5.        [0, 0, 0, 0, 0]])

In [50]:

  1. # Opening 也可以光滑转角
  2. ndimage.binary_opening(a).astype(np.int)

Out[50]:

  1. array([[0, 0, 0, 0, 0],
  2.        [0, 0, 1, 0, 0],
  3.        [0, 1, 1, 1, 0],
  4.        [0, 0, 1, 0, 0],
  5.        [0, 0, 0, 0, 0]])

应用: 去除噪音:

In [51]:

  1. square = np.zeros((32, 32))
  2. square[10:-10, 10:-10] = 1
  3. np.random.seed(2)
  4. x, y = (32*np.random.random((2, 20))).astype(np.int)
  5. square[x, y] = 1
  6. open_square = ndimage.binary_opening(square)
  7. eroded_square = ndimage.binary_erosion(square)
  8. reconstruction = ndimage.binary_propagation(eroded_square, mask=square)

2.6.4 图像过滤 - 图9

[Python source code]

Closing: dilation + erosion 许多其他的数学形态学操作: hit 和 miss 转换、tophat等等。

2.6.5.2 分割

  • 直方图分割 (没有空间信息)

In [52]:

  1. n = 10
  2. l = 256
  3. im = np.zeros((l, l))
  4. np.random.seed(1)
  5. points = l*np.random.random((2, n**2))
  6. im[(points[0]).astype(np.int), (points[1]).astype(np.int)] = 1
  7. im = ndimage.gaussian_filter(im, sigma=l/(4.*n))
  8. mask = (im > im.mean()).astype(np.float)
  9. mask += 0.1 * im
  10. img = mask + 0.2*np.random.randn(*mask.shape)
  11. hist, bin_edges = np.histogram(img, bins=60)
  12. bin_centers = 0.5*(bin_edges[:-1] + bin_edges[1:])
  13. binary_img = img > 0.5

2.6.4 图像过滤 - 图10[Python source code]

用数学形态学来清理结果:

In [53]:

  1. # 删除小白色区域
  2. open_img = ndimage.binary_opening(binary_img)
  3. # 删除小黑洞
  4. close_img = ndimage.binary_closing(open_img)

2.6.4 图像过滤 - 图11[Python source code]

练习

检查重建操作 (erosion + propagation) 生成一个比opening/closing更好的结果:

In [55]:

  1. eroded_img = ndimage.binary_erosion(binary_img)
  2. reconstruct_img = ndimage.binary_propagation(eroded_img, mask=binary_img)
  3. tmp = np.logical_not(reconstruct_img)
  4. eroded_tmp = ndimage.binary_erosion(tmp)
  5. reconstruct_final = np.logical_not(ndimage.binary_propagation(eroded_tmp, mask=tmp))
  6. np.abs(mask - close_img).mean()

Out[55]:

  1. 0.0072783654884356133

In [56]:

  1. np.abs(mask - reconstruct_final).mean()

Out[56]:

  1. 0.00059502552803868841

练习

检查第一步降噪 (例如，中位数过滤器) 如何影响直方图，检查产生的基于直方图的分割是否更加准确。

也可以看一下：更高级分割算法可以在scikit-image中找到: 见Scikit-image: 图像处理。

也可以看一下：其他科学计算包为图像处理提供的算法。在这个例子中，我们使用scikit-learn中的谱聚类函数以便分割黏在一起的对象。

In [57]:

  1. from sklearn.feature_extraction import image
  2. from sklearn.cluster import spectral_clustering
  4. l = 100
  5. x, y = np.indices((l, l))
  7. center1 = (28, 24)
  8. center2 = (40, 50)
  9. center3 = (67, 58)
  10. center4 = (24, 70)
  11. radius1, radius2, radius3, radius4 = 16, 14, 15, 14
  13. circle1 = (x - center1[0])**2 + (y - center1[1])**2 < radius1**2
  14. circle2 = (x - center2[0])**2 + (y - center2[1])**2 < radius2**2
  15. circle3 = (x - center3[0])**2 + (y - center3[1])**2 < radius3**2
  16. circle4 = (x - center4[0])**2 + (y - center4[1])**2 < radius4**2
  18. # 4个圆形
  19. img = circle1 + circle2 + circle3 + circle4
  20. mask = img.astype(bool)
  21. img = img.astype(float)
  23. img += 1 + 0.2*np.random.randn(*img.shape)
  24. # 将图像转化为边缘带有坡度值的图。
  25. graph = image.img_to_graph(img, mask=mask)
  27. # 用一个梯度递减函数: 我们用它轻度依赖于接近voronoi的梯度细分
  28. graph.data = np.exp(-graph.data/graph.data.std())
  30. labels = spectral_clustering(graph, n_clusters=4, eigen_solver='arpack')
  31. label_im = -np.ones(mask.shape)
  32. label_im[mask] = labels

2.6.4 图像过滤 - 图12