用python提取图片轮廓细节

最新推荐文章于 2024-05-01 15:49:11 发布

星河队长

最新推荐文章于 2024-05-01 15:49:11 发布

阅读量2.3k

点赞数 1

分类专栏： python

原文链接：https://blog.youkuaiyun.com/sodaANDcola/article/details/119821939

版权

python 专栏收录该内容

10 篇文章

订阅专栏

用python提取图片轮廓细节

import math
import numpy as np
import matplotlib.pyplot as plt


# 生成高斯核
def gaussian_create():
    sigma1 = sigma2 = 1
    gaussian_sum = 0
    g = np.zeros([3, 3])
    for i in range(3):
        for j in range(3):
            g[i, j] = math.exp(-1 / 2 * (np.square(i - 1) / np.square(sigma1)
                                         + (np.square(j - 1) / np.square(sigma2)))) / (
                              2 * math.pi * sigma1 * sigma2)
            gaussian_sum = gaussian_sum + g[i, j]
    g = g / gaussian_sum  # 归一化
    return g


# 产生灰度图
def gray_fuc(rgb):
    return np.dot(rgb[..., :3], [0.299, 0.587, 0.114])


# 高斯卷积
def gaussian_blur(gray_img, g):
   #gray_img:灰度图
   #g:高斯核
    gray_img = np.pad(gray_img, ((1, 1), (1, 1)), constant_values=0)  # 填充
    h, w = gray_img.shape
    new_gray_img = np.zeros([h - 2, w - 2])
    for i in range(h - 2):
        for j in range(w - 2):
            new_gray_img[i, j] = np.sum(gray_img[i:i + 3, j:j + 3] * g)
    return new_gray_img



# 求高斯偏导
def partial_derivative(new_gray_img):
    #new_gray_img:高斯卷积后的灰度图
    new_gray_img = np.pad(new_gray_img, ((0, 1), (0, 1)), constant_values=0)  # 填充
    h, w = new_gray_img.shape
    dx_gray = np.zeros([h - 1, w - 1])  # 用来存储x方向偏导
    dy_gray = np.zeros([h - 1, w - 1])  # 用来存储y方向偏导
    df_gray = np.zeros([h - 1, w - 1])  # 用来存储梯度强度
    for i in range(h - 1):
        for j in range(w - 1):
            dx_gray[i, j] = new_gray_img[i, j + 1] - new_gray_img[i, j]
            dy_gray[i, j] = new_gray_img[i + 1, j] - new_gray_img[i, j]
            df_gray[i, j] = np.sqrt(np.square(dx_gray[i, j]) + np.square(dy_gray[i, j]))
    return dx_gray, dy_gray, df_gray


# 非极大值抑制
def non_maximum_suppression(dx_gray, dy_gray, df_gray):
   #dx_gray:x方向梯度矩阵
	#dy_gray:y方向梯度矩阵
	#df_gray:梯度强度矩阵
    df_gray = np.pad(df_gray, ((1, 1), (1, 1)), constant_values=0)  # 填充
    h, w = df_gray.shape
    for i in range(1, h - 1):
        for j in range(1, w - 1):
            if df_gray[i, j] != 0:
                gx = math.fabs(dx_gray[i - 1, j - 1])
                gy = math.fabs(dy_gray[i - 1, j - 1])
                if gx > gy:
                    weight = gy / gx
                    grad1 = df_gray[i + 1, j]
                    grad2 = df_gray[i - 1, j]
                    if gx * gy > 0:
                        grad3 = df_gray[i + 1, j + 1]
                        grad4 = df_gray[i - 1, j - 1]
                    else:
                        grad3 = df_gray[i + 1, j - 1]
                        grad4 = df_gray[i - 1, j + 1]
                else:
                    weight = gx / gy
                    grad1 = df_gray[i, j + 1]
                    grad2 = df_gray[i, j - 1]
                    if gx * gy > 0:
                        grad3 = df_gray[i + 1, j + 1]
                        grad4 = df_gray[i - 1, j - 1]
                    else:
                        grad3 = df_gray[i + 1, j - 1]
                        grad4 = df_gray[i - 1, j + 1]
                t1 = weight * grad1 + (1 - weight) * grad3
                t2 = weight * grad2 + (1 - weight) * grad4
                if df_gray[i, j] > t1 and df_gray[i, j] > t2:
                    df_gray[i, j] = df_gray[i, j]
                else:
                    df_gray[i, j] = 0
    return df_gray


# 双阈值过滤
def double_threshold(df_gray, low, high):

    # df_gray:梯度强度矩阵 low:低阈值 high:高阈值

    h, w = df_gray.shape
    for i in range(1, h - 1):
        for j in range(1, w - 1):
            if df_gray[i, j] < low:
                df_gray[i, j] = 0
            elif df_gray[i, j] > high:
                df_gray[i, j] = 1
            elif (df_gray[i, j - 1] > high) or (df_gray[i - 1, j - 1] > high) or (
                    df_gray[i + 1, j - 1] > high) or (df_gray[i - 1, j] > high) or (df_gray[i + 1, j] > high) or (
                    df_gray[i - 1, j + 1] > high) or (df_gray[i, j + 1] > high) or (df_gray[i + 1, j + 1] > high):
                df_gray[i, j] = 1
            else:
                df_gray[i, j] = 0
    return df_gray




if __name__ == '__main__':
    # 读取图像
    filepath="C:/Users/gdxiaozq/Desktop/chunjie.JPG"
    img = plt.imread(filepath)
    # 生成高斯核
    gaussian = gaussian_create()
    # 生成灰度图
    gray = gray_fuc(img)
    # 高斯卷积
    new_gray = gaussian_blur(gray, gaussian)
    # 求偏导
    d = partial_derivative(new_gray)
    dx = d[0]
    dy = d[1]
    df = d[2]
    # 非极大值抑制
    new_df = non_maximum_suppression(dx, dy, df)
    # 双阈值过滤,并将图像转换成转化二值图
    low_threshold = 0.15 * np.max(new_df)
    high_threshold = 0.2 * np.max(new_df)
    result = double_threshold(new_df, low_threshold, high_threshold)
    # 输出图像
    plt.imshow(result, cmap="gray")
    plt.axis("off")
    plt.show()

处理效果

在这里插入图片描述

细节

在这里插入图片描述
上述代码中采用的双阈值过滤函数，是判断弱边周围是否存在强边，来进而确定该弱边是否是我们所需要的边，是否进行滤除。该方法的缺陷：

强边为H，其上有一点a与弱边相连。该弱边为L，其上有一点b和一点c，b点和a点相连。
如果，在判断弱边是否滤除的时候，先判断b点，后判断c点，得知b点和a点相连，b点设为1值保留，c点和b点相连，因此c点也设为1值保留
如果，先判断c点，后判断b点，那么得出的结论是：c点周围没有1值，丢弃。这将导致我们丢失掉我们想要的点

因此改变双阈值过滤函数的算法思想，判断强边周围是否存在弱边，即通过强边延伸弱边。这样可以使我们提取到的边更加的完整。

# 双阈值过滤
def double_threshold(dx_gray, dy_gray, df_gray, low, high):
	'''
	dx_gray:x方向梯度矩阵
	dy_gray:y方向梯度矩阵
	df_gray:梯度强度矩阵
	low:低阈值
	high:高阈值
	'''
    h, w = df_gray.shape
    for i in range(1, h - 1):
        for j in range(1, w - 1):
            if df_gray[i, j] < low:
                df_gray[i, j] = 0
            elif df_gray[i, j] >= high:
                df_gray[i, j] = 1
                if dy_gray[i-1, j-1] * dx_gray[i-1, j-1] > 0:  # dx，dy同向
                    if df_gray[i - 1, j + 1] > low:
                        df_gray[i - 1, j + 1] = high
                    if df_gray[i + 1, j - 1] > low:
                        df_gray[i + 1, j - 1] = high
                    if dy_gray[i-1, j-1] > dx_gray[i-1, j-1]:
                        if df_gray[i, j + 1] > low:
                            df_gray[i, j + 1] = high
                        if df_gray[i, j - 1] > low:
                            df_gray[i, j - 1] = high
                    else:
                        if df_gray[i - 1, j] > low:
                            df_gray[i - 1, j] = high
                        if df_gray[i + 1, j] > low:
                            df_gray[i + 1, j] = high
                else:
                    if df_gray[i - 1, j - 1] > low:
                        df_gray[i - 1, j - 1] = high
                    if df_gray[i + 1, j + 1] > low:
                        df_gray[i + 1, j + 1] = high
                    if math.fabs(dy_gray[i-1, j-1]) > math.fabs(dx_gray[i-1, j-1]):
                        if df_gray[i, j + 1] > low:
                            df_gray[i, j + 1] = high
                        if df_gray[i, j - 1] > low:
                            df_gray[i, j - 1] = high
                    else:
                        if df_gray[i - 1, j] > low:
                            df_gray[i - 1, j] = high
                        if df_gray[i + 1, j] > low:
                            df_gray[i + 1, j] = high
            else:
                df_gray[i, j] = 0
    return df_gray