图像细化_八连通法

图像细化

图像细化的方法

八连通-查表法

zhang的快速并行细化算法

八连通-查表法的改进

附上参考链接：https://www.cnblogs.com/xianglan/archive/2011/01/01/1923779.html

这个链接的博主写的很清楚

图像细化

图像的细化主要是针对二值图而言

所谓骨架，可以理解为图像的中轴，长方形的骨架，是它的长方向上的中轴线，圆的骨架是它的圆心，直线的骨架是它自身，孤立点的骨架也是自身。

图像细化的方法

八连通-查表法

判断一个点是否能去掉是以8个相邻点(八连通)的情况来作为判据的，具体判据为：

1，内部点不能删除

2，鼓励点不能删除

3，直线端点不能删除

4，如果P是边界点，去掉P后，如果连通分量不增加，则P可删除

看看上面那些点。

第一个点不能去除，因为它是内部点

第二个点不能去除，它也是内部点

第三个点不能去除，删除后会使原来相连的部分断开

第四个点可以去除，这个点不是骨架

第五个点不可以去除，它是直线的端点

第六个点不可以去除，它是直线的端点

对于所有的这样的点，我们可以做出一张表，来判断这样的点能不能删除

对于黑色的像素点，它周围的8个点，我们赋予不同的价值。若周围某黑色，我们认为其价值为0，为白色则取九宫格中对应的价值。

对于前面那幅图中第一个点，也就是内部点，它周围的点都是黑色，所以他的总价值是0，对应于索引表的第一项。

前面那幅图中第二点，它周围有三个白色点，它的总价值为1+4+32=37，对应于索引表中第三十八项

我们用这种方法，把所有点的情况映射到0～255的索引表中。

我们扫描原图，对于黑色的像素点，根据周围八点的情况计算它的价值，然后查看索引表中对应项来决定是否要保留这一点。

附上代码

import cv2

# 输入需要细化的图片(经过二值化处理的图片)和映射矩阵array

def Thin(image, array):

h, w = image.shape

# height 图像的高度 weight 图像的宽度

iThin = image

for i in range(h):

for j in range(w):

if image[i, j] == 0: # 如果图像的这个点是黑色的点

a = [1] * 9 # 先默认周围八个点都是白色的

for k in range(3): # range(3):0 1 2

for l in range(3):

# 如果3*3矩阵的点不在边界

# 且是黑色的点

# 这一段的难点是用k，l来精确的表示3*3的矩阵

if -1 < (i - 1 + k) < h and -1 < (j - 1 + l) < w and iThin[i - 1 + k, j - 1 + l] == 0:

a[k + 3 * l] = 0

# sum没有a[4]，a[4]刚好就是中心的黑点，不需要加进去计算

sum = a[0] * 1 + a[1] * 2 + a[2] * 4 + a[3] * 8 + a[5] * 16 + a[6] * 32 + a[7] * 64 + a[8] * 128

# 然后根据array表，对iThin的那一点进行赋值。

# 将所有点的总价值映射到[0,255]的表中，返回的结果保存到iThin中

iThin[i, j] = array[sum] * 255

return iThin

# 最简单的二值化函数，阈值根据图片的昏暗程度自己设定，即180这个数字是可以修改的

def Two(image):

w, h = image.shape

# size = (w, h)

iTwo = image

for i in range(w):

for j in range(h):

if image[i, j] < 180:

iTwo[i, j] = 0

else:

iTwo[i, j] = 255

return iTwo

# 映射表

array = [0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, \

1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, \

0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, \

1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, \

1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, \

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, \

1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, \

0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, \

1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, \

1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \

1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, \

1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, \

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

# 读取图片，并显示

img = cv2.imread('testimg/c.png', 0)

cv2.namedWindow("image", cv2.WINDOW_NORMAL) # 解决图片太大，显示不全

cv2.imshow('image', img)

cv2.waitKey(0)

# 获取简单二值化的细化图，并显示

iTwo = Two(img)

iThin_2 = Thin(iTwo, array)

cv2.namedWindow("iTwo_2", cv2.WINDOW_NORMAL) # 解决图片太大，显示不全

cv2.imshow('iTwo_2', iThin_2)

cv2.waitKey(0)

cv2.destroyAllWindows()

zhang的快速并行细化算法

A Fast Parallel Algorithm for Thinning Digital Patterns

八连通-查表法的改进

问题：从上到下，从左到右扫描的时候，遇到第一个点，查表可以删除，遇到第二个点，查表也可以删除，整个第一行都可以删除。扫描第二行时，和第一行一样，也被整个删除了。这样一直到最后一行。

解决办法：在每行水平扫描的过程中，先判断每一点的左右邻居，如果都是黑点，则该点不做处理。另外，如果某个黑店被删除了，则跳过它的右邻居，处理下一点。对矩形这样做完一遍，水平方向会减少两像素。垂直方向扫描方法同理，判断上下邻居。

这样做一次水平扫描和垂直扫描，原图会“瘦”一圈，多次重复上面的步骤，知道图形不在变化为止。

代价：这一改进让算法的复杂度的运行时间增大一个数量级

(代码见第一个链接博主写的代码)

https://www.cnblogs.com/xianglan/archive/2011/01/01/1923779.html

细化后的图像还存在毛刺，还需要对图像细化算法做进一步的优化。