sobel和canny边缘检测算子

sobel算子

sobel算子是一种离散微分算子，它通过计算图像亮度值变化的近似梯度，从而识别出图像边缘，近似一阶差分。

步骤

1.高斯平滑；
2.微分求导。

具体过程

1.高斯模糊平滑目的是为了去噪，防止把噪点也检测为边缘。
2.对原图分别进行水平方向和垂直方向的卷积（x和y两个方向求导），来计算某个像素的梯度变化幅值和方向。
3.给定一个阈值就可以得到sobel算子计算出的图像边缘。

代码实现

cv2.Sobel(image,cv2.CV_64F,1,0,ksize=3)

2参数表示图像的深度；3,4参数表示dx和dy方向求导的阶数，0表示这个方向上没有求导，一般为0、1、2；5参数表示内核大小，即Sobel算子的矩阵大小，值必须是1、3、5、7，默认为3。

#进行权重融合
dst=cv2.addWeighted(absX,0.5,absY,0.5,0)

canny算子

步骤

1.高斯平滑；
2.计算梯度幅度和方向（sobel）；

3.根据梯度方向对幅值进行非极大值抑制；
非极大值抑制：保留局部梯度最大的点，就是可能的边缘点。在梯度方向上差值求亚像素来进行比较。

4.用双阈值算法检测和连接边缘。
使用滞后阈值：如果某一像素位置的梯度幅值超过高阈值, 该像素被保留为边缘像素；如果某一像素位置的幅值小于低阈值, 该像素被舍弃；如果某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于高阈值的像素时被保留

opencv代码实现

img = cv2.GaussianBlur(gray,(3,3),0)
canny = cv2.Canny(img, 50, 150)

python代码实现

# 1.灰度化
np.dot(img[..., :3], [0.299, 0.587, 0.114])

# 2.高斯滤波
def gaussian(img, kernel=5, sigma=1.5):
    filter = np.zeros([kernel, kernel])
    pad = kernel//2
    for i in range(-pad, -pad + kernel):
        for j in range(-pad, -pad + kernel):
            filter[i,j] = np.exp( - (i ** 2 + j ** 2) / (2 * sigma * sigma))/(2 * np.pi * sigma * sigma)
    filter/=filter.sum()

    #与图像卷积
    h, w = img.shape
    new_img = np.zeros([h, w])
    img = np.pad(img, (pad,pad), 'constant')
    # new_img[pad: pad + h, pad: pad + w] = img.copy()
    for i in range(h):
        for j in range(w):
            new_img[i, j] = np.sum(img[i:i + kernel, j:j + kernel] * filter)
    return new_img

#3.计算梯度幅值和方向
def grad(img):
    h, w = img.shape
    fx = np.zeros([h-1, w-1])
    fy = np.zeros([h-1, w-1])
    edge = np.zeros([h-1, w-1])
    for i in range(h - 1):
        for j in range(w - 1):
            fx[i, j] = img[i, j + 1] - img[i, j]
            fy[i, j] = img[i + 1, j] - img[i, j]
            edge[i, j] = np.sqrt(np.square(fx[i, j]) + np.square(fy[i, j]))
    return fx, fy, edge

#4.非极大值抑制（利用差值求亚像素来比较）
def nms(fx, fy, img):
    h,w = img.shape
    #图像边缘为不可能的分界点
    for i in range(1, h-1):
        for j in range(1, w-1):
            if img[i,j] == 0:
                img[i,j] = 0
            else:
                gx = fx[i,j]
                gy = fy[i,j]
                dTemp = img[i,j]
                #如果方向导数y分量比x分量大，说明导数方向趋向于y分量
                if np.abs(gy)>np.abs(gx):
                    weight = np.abs(gx)/np.abs(gy)
                    g2 = img[i - 1, j]   #上一行
                    g4 = img[i + 1, j]   #下一行
                    #如果x,y两个方向导数的符号相同
                    #g1 g2
                    #   C
                    #   g4 g3
                    if gx*gy>0:
                        g1 = img[i - 1, j - 1]
                        g3 = img[i + 1, j + 1]
                    #   g2 g1
                    #   C
                    #g3 g4
                    else:
                        g1 = img[i - 1, j + 1]
                        g3 = img[i + 1, j - 1]
                # 如果方向导数x分量比y分量大，说明导数方向趋向于x分量
                else:
                    weight = np.abs(gy) / np.abs(gx)
                    g2 = img[i, j - 1]  #前一列
                    g4 = img[i, j + 1]  #后一列
                    # 如果x,y两个方向导数的符号相同
                    # g1
                    # g2 C g4
                    #      g3
                    if gx * gy > 0:
                        g1 = img[i - 1, j - 1]
                        g3 = img[i + 1, j + 1]
                    #      g3
                    # g2 C g4
                    # g1
                    else:
                        g1 = img[i - 1, j + 1]
                        g3 = img[i + 1, j - 1]
                dTemp1 = weight * g1 + (1 - weight) * g2
                dTemp2 = weight * g3 + (1 - weight) * g4
                if dTemp >= dTemp1 and dTemp >= dTemp2:
                    img[i, j] = dTemp
                else:
                    img[i, j] = 0
    return img

#5.滞后阈值处理
LT = 0.2 * np.max(img)
HT = 0.3 * np.max(img)
h,w = img.shape
nn = np.array(((1., 1., 1.), (1., 0., 1.), (1., 1., 1.)), dtype=np.float32)
for i in range(1, h - 2):
    for j in range(1, w - 2):
        if (img[i, j] < LT):
            img[i, j] = 0
        elif (img[i, j] > HT):
            img[i, j] = 255
        # 把大于LT ，小于HT的点使用8连通区域确定
        elif np.max(img[i - 1:i + 2, j - 1:j + 2] * nn) >= HT:
            img[i, j] = 255
        else:
            img[i, j] = 0

sobel算子和canny算子比较

Canny边缘检测算子最为经典，效果最佳，边缘较细，更加准确；
Sobel边缘检测算子计算量小，并没有将图像的主体与背景严格地区分开来。

效果图对比：