? ? 邊緣檢測(cè)是一種將圖片中關(guān)鍵信息表現(xiàn)出來(lái)的一種圖片技術(shù)，它的結(jié)果并不是字面意思上的獲取圖片邊緣，而是將圖片有用的信息勾勒出來(lái)，類似素描的結(jié)果，但是已經(jīng)去掉了很多信息。如下所示，一張?jiān)嫉膱D片是這樣的：

? ??

? ? 通過(guò)邊緣檢測(cè)算法，我們最終得到的圖片可能是這樣的：

? ? 雖然丟掉了顏色和很多細(xì)節(jié)，但是這張圖片從輪廓山仍然可以看出是模特lenna。

? ? 邊緣檢測(cè)算法有很多實(shí)現(xiàn)方式，結(jié)果也不盡相同，其中最常見的就是Canny算子的邊緣檢測(cè)算法，Canny邊緣檢測(cè)算法大致描述如下：? ?.

1. ? ? ?灰度化
2. ? ? ?應(yīng)用高斯濾波去除噪聲
3. ? ? ?計(jì)算圖像強(qiáng)度梯度和方向
4. ? ? ?非極大值抑制 non-max-suppresion
5. ? ? ?雙閾值跟蹤邊界

? ? opencv庫(kù)提供了Canny算法，可以很方便的進(jìn)行邊緣檢測(cè)，代碼如下：

import cv2
import matplotlib.pyplot as plt

img = cv2.imread('lenna.png', 0)
# 灰度
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# 高斯濾波 卷積 3 * 3
img_blur = cv2.GaussianBlur(img_gray, (3, 3), 0)
# x梯度
xgrad = cv2.Sobel(img_blur, cv2.CV_16SC1, 1, 0)
# y梯度
ygrad = cv2.Sobel(img_blur, cv2.CV_16SC1, 0, 1)
# 使用梯度參數(shù)進(jìn)行邊緣檢測(cè) 閾值 50 ~ 150
edge1 = cv2.Canny(xgrad, ygrad, 50, 150)
# 直接用高斯濾波結(jié)果進(jìn)行邊緣檢測(cè) 閾值 50 ~ 150
edge2 = cv2.Canny(img_blur, 50, 150)
cv2.imshow('origin image', img)
cv2.imshow('edge image', edge1)
cv2.imshow('edge image2', edge2)
cv2.waitKey()

? ? 這段代碼大致意思是先加載lenna.png，然后轉(zhuǎn)灰度，高斯濾波平滑圖片，計(jì)算梯度，使用Canny算法邊緣檢測(cè)。

? ? 算法運(yùn)行結(jié)果：

? ?根據(jù)上面提到的算法步驟，以及一些理論公式，其實(shí)這個(gè)有很多直接使用python代碼實(shí)現(xiàn)的Canny算子邊緣檢測(cè)算法，如下所示，這些函數(shù)分別都是根據(jù)上面的算法步驟進(jìn)行整理的：

import numpy as np
import math
import cv2


# 灰度化
def gray(img_path):
    """
    計(jì)算公式：
    Gray(i,j) = 0.299 * R(i,j) + 0.587 * G(i,j) + 0.114 * B(i,j)
    """

    # 讀取圖片
    img = cv2.imread(img_path, 0)
    # BGR 轉(zhuǎn)換成 RGB 格式
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    # 灰度化
    img_gray = np.dot(img_rgb[..., :3], [0.299, 0.587, 0.114])
    return img_gray


# 去除噪音 - 使用 5x5 的高斯濾波器
def smooth(img_gray):
    # 生成高斯濾波器
    """
    要生成一個(gè) (2k+1)x(2k+1) 的高斯濾波器，濾波器的各個(gè)元素計(jì)算公式如下：
    H[i, j] = (1/(2*pi*sigma**2))*exp(-1/2*sigma**2((i-k-1)**2 + (j-k-1)**2))
    """
    sigma1 = sigma2 = 1.4
    gau_sum = 0
    gaussian = np.zeros([5, 5])
    for i in range(5):
        for j in range(5):
            gaussian[i, j] = math.exp((-1 / (2 * sigma1 * sigma2)) * (np.square(i - 3) + np.square(j - 3))) / (
                    2 * math.pi * sigma1 * sigma2)
            gau_sum = gau_sum + gaussian[i, j]

    # 歸一化處理
    gaussian = gaussian / gau_sum

    # 高斯濾波
    W, H = img_gray.shape
    new_gray = np.zeros([W - 5, H - 5])

    for i in range(W - 5):
        for j in range(H - 5):
            new_gray[i, j] = np.sum(img_gray[i:i + 5, j:j + 5] * gaussian)

    return new_gray


# 計(jì)算梯度幅值
def gradients(new_gray):
    """
    :type: image which after smooth
    :rtype:
        dx: gradient in the x direction
        dy: gradient in the y direction
        M: gradient magnitude
        theta: gradient direction
    """
    W, H = new_gray.shape
    dx = np.zeros([W - 1, H - 1])
    dy = np.zeros([W - 1, H - 1])
    M = np.zeros([W - 1, H - 1])

    for i in range(W - 1):
        for j in range(H - 1):
            dx[i, j] = new_gray[i + 1, j] - new_gray[i, j]
            dy[i, j] = new_gray[i, j + 1] - new_gray[i, j]
            # 圖像梯度幅值作為圖像強(qiáng)度值
            M[i, j] = np.sqrt(np.square(dx[i, j]) + np.square(dy[i, j]))
    return dx, dy, M


def NMS(M, dx, dy):
    d = np.copy(M)
    W, H = M.shape
    NMS = np.copy(d)
    NMS[0, :] = NMS[W - 1, :] = NMS[:, 0] = NMS[:, H - 1] = 0
    for i in range(1, W - 1):
        for j in range(1, H - 1):
            # 如果當(dāng)前梯度為0，該點(diǎn)就不是邊緣點(diǎn)
            if M[i, j] == 0:
                NMS[i, j] = 0
            else:
                gradX = dx[i, j]  # 當(dāng)前點(diǎn) x 方向?qū)?shù)
                gradY = dy[i, j]  # 當(dāng)前點(diǎn) y 方向?qū)?shù)
                gradTemp = d[i, j]  # 當(dāng)前梯度點(diǎn)

                # 如果 y 方向梯度值比較大，說(shuō)明導(dǎo)數(shù)方向趨向于 y 分量
                if np.abs(gradY) > np.abs(gradX):
                    weight = np.abs(gradX) / np.abs(gradY)  # 權(quán)重
                    grad2 = d[i - 1, j]
                    grad4 = d[i + 1, j]

                    # 如果 x, y 方向?qū)?shù)符號(hào)一致
                    # 像素點(diǎn)位置關(guān)系
                    # g1  g2
                    #     c
                    #     g4  g3

                    if gradX * gradY > 0:
                        grad1 = d[i - 1, j - 1]
                        grad3 = d[i + 1, j + 1]

                    # 如果 x，y 方向?qū)?shù)符號(hào)相反
                    # 像素點(diǎn)位置關(guān)系
                    #     g2  g1
                    #     c
                    # g3  g4

                    else:
                        grad1 = d[i - 1, j + 1]
                        grad3 = d[i + 1, j - 1]

                # 如果 x 方向梯度值比較大
                else:
                    weight = np.abs(gradY) / np.abs(gradX)
                    grad2 = d[i, j - 1]
                    grad4 = d[i, j + 1]

                    # 如果 x, y 方向?qū)?shù)符號(hào)一致
                    # 像素點(diǎn)位置關(guān)系
                    #      g3
                    # g2 c g4
                    # g1
                    if gradX * gradY > 0:
                        grad1 = d[i + 1, j - 1]
                        grad3 = d[i - 1, j + 1]

                    # 如果 x，y 方向?qū)?shù)符號(hào)相反
                    # 像素點(diǎn)位置關(guān)系
                    # g1
                    # g2 c g4
                    #      g3
                    else:
                        grad1 = d[i - 1, j - 1]
                        grad3 = d[i + 1, j + 1]

                # 利用 grad1-grad4 對(duì)梯度進(jìn)行插值
                gradTemp1 = weight * grad1 + (1 - weight) * grad2
                gradTemp2 = weight * grad3 + (1 - weight) * grad4

                # 當(dāng)前像素的梯度是局部的最大值，可能是邊緣點(diǎn)
                if gradTemp >= gradTemp1 and gradTemp >= gradTemp2:
                    NMS[i, j] = gradTemp
                else:
                    # 不可能是邊緣點(diǎn)
                    NMS[i, j] = 0

    return NMS


def double_threshold(NMS):
    W, H = NMS.shape
    DT = np.zeros([W, H])

    # 定義高低閾值
    TL = 0.1 * np.max(NMS)
    TH = 0.3 * np.max(NMS)

    for i in range(1, W - 1):
        for j in range(1, H - 1):
            # 雙閾值選取
            if (NMS[i, j] < TL):
                DT[i, j] = 0
            elif (NMS[i, j] > TH):
                DT[i, j] = 1
            # 連接
            elif (NMS[i - 1, j - 1:j + 1] < TH).any() or (
                    NMS[i + 1, j - 1:j + 1].any() or (NMS[i, [j - 1, j + 1]] < TH).any()):
                DT[i, j] = 1
    return DT


def canny(img):
    img_gray = gray(img)
    new_gray = smooth(img_gray)
    dx, dy, M = gradients(new_gray)
    nms = NMS(M, dx, dy)
    return double_threshold(nms)


if __name__ == '__main__':
    img_url = 'lenna.png'
    img = cv2.imread(img_url)
    edgedetect = canny(img_url)
    img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
    img_blur = cv2.GaussianBlur(img_gray, (3, 3), 0)
    cv2.imshow('origin img', img)
    opencvedge = cv2.Canny(img_blur, 50, 150)
    cv2.imshow('opencv edge', opencvedge)
    cv2.imshow('python edge', edgedetect)
    cv2.waitKey()

? ? 算法運(yùn)行結(jié)果;

? ? 我們通過(guò)python算法實(shí)現(xiàn)的邊緣檢測(cè)，線條好像不是很光滑，雖然輪廓是出來(lái)了，但是線條很糙。這其實(shí)是代碼里面一個(gè)計(jì)算梯度的地方正好寫反了。

? ? 我們調(diào)整代碼如下：

dx[i, j] = new_gray[i, j + 1] - new_gray[i, j]
dy[i, j] = new_gray[i + 1, j] - new_gray[i, j]

執(zhí)行結(jié)果如下;

雖然結(jié)果與opencv Canny算法結(jié)果有些差別，但是線條明顯光滑了很多，比之前的結(jié)果要好。?文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-473639.html

到了這里，關(guān)于python實(shí)現(xiàn)Canny算子邊緣檢測(cè)算法的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！