图像处理-边缘检测 Canny算子的实现 MATLAB&python

一.背景

Canny边缘检测算子是John F. Canny于1986年开发出来的一个多级边缘检测算法。它的目标是找到一个最优的边缘检测算法，最优边缘检测的含义是：①好的检测- 算法能够尽可能多地标识出图像中的实际边缘。②好的定位- 标识出的边缘要与实际图像中的实际边缘尽可能接近。③最小响应- 图像中的边缘只能标识一次，并且可能存在的图像噪声不应标识为边缘。

二.思路

1.Canny算子的基本步骤
①去噪，图像平滑。
任何边缘检测算法都不可能在未经处理的原始数据上很好地處理，一般采用的方法是利用原始数据与高斯核进行卷积，平滑处理。
②用一阶偏导的有限差分来计算梯度的幅值和方向。
计算一阶偏导用于找出灰度值变化较大的像素点，一般用Sobel算子。
③对梯度幅值进行非极大化抑制。
仅仅得到全局的梯度并不足以确定边缘，因此为确定边缘，必须保留局部梯度最大的点，而抑制非极大值。（non-maxima suppression,NMS）
解决方法：利用梯度的方向。
④边缘连接。
采用双阈值的方法进行边缘连接。

2.具体流程
对canny算子的四个步骤分别采用四个函数编写，最后利用主程序按顺序调用四个函数得到一个canny算子，并在每个过程中展示一次处理的结果，用于体现每个步骤的作用。
①图像平滑处理：
利用高斯滤波器对原始的图像，用高斯核函数：

先对x方向进行卷积，再对y方向进行卷积，得到平滑处理后的图像。

②Sobel边缘检测算子计算一阶偏导有限差分：
先将上一步的图像的上下左右各扩展一圈，为了能处理原始图像的边缘像素；然后设置Sobel算子的x和y方向的梯度模板，分别为：

将图像的每个像素分别与xy模板进行相乘叠加，得到该像素点的x,y梯度值，再将扩展的图像复原。最后，每个像素的梯度幅值为：x,y方向的梯度值得平方和开根号得到，梯度方向为反正切值（y梯度/x梯度），将得到得值输出。

③梯度幅值的非极大值抑制
利用下图的线性插值原理计算在8邻域中中间像素点是否为极大值。

线性插值的公式为：

其中，w为根据梯度的角度决定的权重大小。
由梯度角度的大小得到梯度方向的四分类：y梯度是否大于x梯度，以及，y梯度与x梯度符号是否相同。
由y梯度与x梯度的大小比较：
当y大于x时得到权值的计算公式为：绝对值（x梯度/y梯度），g2=左方梯度值，g4=右方梯度值；且当y与x同号，g1=左上角梯度值，g3=右下角梯度值；当y与x不同号，g1=左下方梯度值，g3=右上方梯度值。
当y小于x时得到权值的计算公式为：绝对值（y梯度/x梯度），g2=上方梯度值，g4=下方梯度值；且当y与x同号，g1=左上角梯度值，g3=右下角梯度值；当y与x不同号，g1=左下方梯度值，g3=右上方梯度值。
最后根据计算得到的g1234和权值w计算梯度方向上的两个值，与中间值进行比较，看是否对中间值进行抑制。

④边缘连接
通过双阈值算法检测，先选出大于最大阈值的梯度对应的像素作为边缘，再利用第二阈值，在大于第二阈值小于最大阈值的像素点中，根据邻域的极大值原理选择适当的像素，也作为边缘点，最终将边缘点全部连接起来，称为边缘的图像。

3.流程图
①主程序流程图为：

②高斯滤波平滑处理流程图为：

③Sobel算子流程图为：

④非极大值抑制的流程图为：

⑤边缘连接流程图为：

三.MATLAB代码

①主程序：cannytest.m

clear;clc;
image=imread('Lena.jpg');
image=rgb2gray(image);  %灰度化
%% 步骤一 添加高斯噪声并用高斯滤波平滑化
image_gaussnoise=imnoise(image,'gaussian',0,0.01); %添加高斯噪声
subplot(2,4,1);
imshow(image_gaussnoise);
title('添加高斯噪声');
image_guassfilter=gaussFilter(image_gaussnoise,2); %卷积核sigma值设为2，平滑效果较好，且不模糊
subplot(2,4,2);
imshow(image_guassfilter);
title('高斯滤波平滑处理');
 
%% 步骤二 求梯度
[grad,gradx,grady,angle]=Sobel_filter(image_guassfilter,3);
subplot(2,4,3);
imshow(gradx);
title('x方向梯度');
subplot(2,4,4);
imshow(grady);
title('y方向梯度');
subplot(2,4,5);
imshow(grad);
title('梯度');
 
%% 步骤三 梯度幅值非极大化抑制
nmsgrad=nms(grad,angle,gradx,grady);
subplot(2,4,6);
imshow(nmsgrad);
title('非极大值抑制后梯度');
 
%% 步骤四 双阈值算法检测和连接边缘
edgee=edge_correct(nmsgrad);
subplot(2,4,7);
imshow(edgee);
title('边缘连接后的canny算子最终结果');
 
%% 用matlab自带的canny算子函数实现边缘检测作为结果的对比
ed = edge(image_gaussnoise,'canny', 0.5);
subplot(2,4,8);
imshow(ed);
title('matlab自带的边缘检测函数');

②步骤一：高斯平滑:gaussFilter.m

%% 高斯平滑滤波函数（利用matlab自带的函数设计）
function output=gaussFilter(image,sigma)
output=image;
ksize=double(uint8(3*sigma)*2+1);%窗口大小一半为3*sigma 
window = fspecial('gaussian', [1,ksize], sigma); %使用1行ksize列的高斯核对图像先进行x方向卷积，再进行y方向卷积
for i = 1:size(image,3)
    ret = imfilter(image(:,:,i),window,'replicate');
    ret = imfilter(ret,window','replicate');
    output(:,:,i) = ret;
end 
end

③步骤二：sobel算子求梯度：Sobel_filter.m

%% Sobel算子计算梯度得到边缘图像
function [output,outputx,outputy,outputangle]=Sobel_filter(image,n)
image=double(image);
[h,w]=size(image);
%% 原灰度图像一圈扩展1个像素
big_image = zeros(h+2,w+2);
for i = 2:h+1
    for j = 2:w+1
        big_image(i,j) = image(i-1,j-1);
    end
end
%% 设置Sobel算子x,y方向模板
Hx = [-1,-2,-1;0,0,0;1,2,1];
Hy = Hx';
%% x,y方向梯度计算
gradx_image = zeros(h+2,w+2);
grady_image = zeros(h+2,w+2);
W = zeros(n,n);%n阶的卷积核
for i = 1:h
    for j = 1:w
        %模板移动窗口
        W = big_image(i:i+2,j:j+2);
        Sx = Hx .* W;
        Sy = Hy .* W;
        gradx_image(i+1,j+1) = sum(sum(Sx));
        grady_image(i+1,j+1) = sum(sum(Sy));
    end
end
%% 将一圈扩展1个像素的图像复原
gradx = zeros(h,w);
grady = zeros(h,w);
for i = 1:h
    for j = 1:w
        gradx(i,j) = gradx_image(i+1,j+1);
        grady(i,j) = grady_image(i+1,j+1);
    end
end
%sobel梯度
angle_grad=atand(grady./gradx); %求梯度方向(角度制）
grad = sqrt(gradx.^2 + grady.^2);  %得到图像的sobel梯度
outputx=uint8(gradx);
outputy=uint8(grady);
output=uint8(grad);
outputangle=angle_grad;
end

④步骤三：非极大值抑制处理：nms.m

%% 梯度幅值非极大值抑制
function output=nms(grad,gradangle,gradx,grady)
grad=double(grad);
[h,w]=size(grad);
%% 处理角度
sector=zeros(h,w);
canny1=zeros(h,w);
sector((gradangle>=45)&(gradangle<=-45))=0;%y方向梯度大于x梯度
sector((gradangle<45)&(gradangle>-45))=1;%y方向梯度小于x梯度
sector(gradangle>=0)=2;%x，y方向梯度符号相同
sector(gradangle<0)=3;%x，y方向梯度符号不同
%% 抑制算法实现，用线性插值算出梯度方向上的梯度值
weight=zeros(h,w); %权重初始化
grad1=zeros(h,w);  %各值初始化
grad2=zeros(h,w);
grad3=zeros(h,w);
grad4=zeros(h,w);
gradTemp1=zeros(h,w);
gradTemp2=zeros(h,w);
for i= 2:(h-1)
    for j = 2:(w-1)
        if grad(i,j)==0 %梯度为0，不是边缘点
            sector(i,j)=0;
        else
        if 0 == sector(h,w) %y大于x
            weight(i,j)=abs(gradx(i,j))/abs(grady(i,j)); %权重的计算
            grad2(i,j)=grad(i-1,j);
            grad4(i,j)=grad(i+1,j);
            if 2 == sector(h,w)
                grad1(i,j)=grad(i-1,j-1);
                grad3(i,j)=grad(i+1,j+1);
            elseif 3 == sector(h,w)
                grad1(i,j)=grad(i-1,j+1);
                grad3(i,j)=grad(i+1,j-1);
            end
        elseif 1 == sector(i,j) 
            weight(i,j)=abs(grady(i,j))/abs(gradx(i,j));
            grad2(i,j)=grad(i,j-1);
            grad4(i,j)=grad(i,j+1);
            if 2 == sector(h,w)
                grad1(i,j)=grad(i+1,j+1);
                grad3(i,j)=grad(i-1,j-1);
            elseif 3 == sector(h,w)
                grad1(i,j)=grad(i-1,j+1);
                grad3(i,j)=grad(i+1,j-1);
            end
        end
         gradTemp1(i,j) = weight(i,j) * grad1(i,j) + (1 - weight(i,j)) * grad2(i,j);  %上方的梯度值
         gradTemp2(i,j) = weight(i,j) * grad3(i,j) + (1 - weight(i,j)) * grad4(i,j);  %下方的梯度值
         if (grad(i,j) >= gradTemp1(i,j) && grad(i,j) >= gradTemp2(i,j))  
                canny1(i,j) = grad(i,j);  %在邻域内为极大值，是边缘点
         else    
                canny1(i,j) = 0;  
         end  
        end        
    end
end
output=uint8(canny1);

⑤步骤四：边缘连接：edge_correct.m

%% 双阈值算法检测和连接边缘
function output=edge_correct(grad)
grad=double(grad);
[h,w]=size(grad);
 
%定义双阈值：EP_MIN、EP_MAX，且EP_MAX = 2 * EP_MIN  
EP_MIN = 50;  
EP_MAX = EP_MIN * 2;  
EdgeLarge = zeros(h,w);%记录真边缘  
EdgeBetween = zeros(h,w);%记录可能的边缘点  
for i = 1:h  
    for j = 1:w  
        if grad(i,j) >= EP_MAX%小于小阈值，不可能为边缘点  
            EdgeLarge(i,j) = grad(i,j)+80;  
        elseif grad(i,j) >= EP_MIN 
                EdgeBetween(i,j) = grad(i,j);  
        end   
    end  
end  
%把EdgeLarge的边缘连成连续的轮廓  
MAXSIZE = 999999;  
Queue = zeros(MAXSIZE,2);%用数组模拟队列  
front = 1;%队头  
rear = 1;%队尾  
edge = zeros(h,w);  
for i = 1:h  
    for j = 1:w  
        if EdgeLarge(i,j) > 0  
            %强点入队  
            Queue(rear,1) = i;  
            Queue(rear,2) = j;  
            rear = rear + 1;  
            edge(i,j) = EdgeLarge(i,j);  
            EdgeLarge(i,j) = 0;%避免重复计算  
        end  
        while front ~= rear%队不空  
            %队头出队  
            temp_i = Queue(front,1);  
            temp_j = Queue(front,2);  
            front = front + 1;  
            %8-连通域寻找可能的边缘点  
            %左上方  
            if EdgeBetween(temp_i - 1,temp_j - 1) > 0 %把在强点周围的弱点变为强点  
                EdgeLarge(temp_i - 1,temp_j - 1) = grad(temp_i - 1,temp_j - 1);  
                EdgeBetween(temp_i - 1,temp_j - 1) = 0;%避免重复计算  
                %入队  
                Queue(rear,1) = temp_i - 1;  
                Queue(rear,2) = temp_j - 1;  
                rear = rear + 1;  
            end  
            %正上方  
            if EdgeBetween(temp_i - 1,temp_j) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i - 1,temp_j) = grad(temp_i - 1,temp_j);  
                EdgeBetween(temp_i - 1,temp_j) = 0;  
                %入队  
                Queue(rear,1) = temp_i - 1;  
                Queue(rear,2) = temp_j;  
                rear = rear + 1;  
            end  
            %右上方  
            if EdgeBetween(temp_i - 1,temp_j + 1) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i - 1,temp_j + 1) = grad(temp_i - 1,temp_j + 1);  
                EdgeBetween(temp_i - 1,temp_j + 1) = 0;  
                %入队  
                Queue(rear,1) = temp_i - 1;  
                Queue(rear,2) = temp_j + 1;  
                rear = rear + 1;  
            end  
            %正左方  
            if EdgeBetween(temp_i,temp_j - 1) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i,temp_j - 1) = grad(temp_i,temp_j - 1);  
                EdgeBetween(temp_i,temp_j - 1) = 0;  
                %入队  
                Queue(rear,1) = temp_i;  
                Queue(rear,2) = temp_j - 1;  
                rear = rear + 1;  
            end  
            %正右方  
            if EdgeBetween(temp_i,temp_j + 1) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i,temp_j + 1) = grad(temp_i,temp_j + 1);  
                EdgeBetween(temp_i,temp_j + 1) = 0;  
                %入队  
                Queue(rear,1) = temp_i;  
                Queue(rear,2) = temp_j + 1;  
                rear = rear + 1;  
            end  
            %左下方  
            if EdgeBetween(temp_i + 1,temp_j - 1) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i + 1,temp_j - 1) = grad(temp_i + 1,temp_j - 1);  
                EdgeBetween(temp_i + 1,temp_j - 1) = 0;  
                %入队  
                Queue(rear,1) = temp_i + 1;  
                Queue(rear,2) = temp_j - 1;  
                rear = rear + 1;  
            end  
            %正下方  
            if EdgeBetween(temp_i + 1,temp_j) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i + 1,temp_j) = grad(temp_i + 1,temp_j);  
                EdgeBetween(temp_i + 1,temp_j) = 0;  
                %入队  
                Queue(rear,1) = temp_i + 1;  
                Queue(rear,2) = temp_j;  
                rear = rear + 1;  
            end  
            %右下方  
            if EdgeBetween(temp_i + 1,temp_j + 1) > 0%把在强点周围的弱点变为强点  
                EdgeLarge(temp_i + 1,temp_j + 1) = grad(temp_i + 1,temp_j + 1);  
                EdgeBetween(temp_i + 1,temp_j + 1) = 0;  
                %入队  
                Queue(rear,1) = temp_i + 1;  
                Queue(rear,2) = temp_j + 1;  
                rear = rear + 1;  
            end  
        end  
    end
end
output=uint8(edge);
end

结果
共得到8张灰度图，对canny算子每个步骤的分析为：
①图二：高斯滤波平滑处理后图像能处理掉一部分噪声，使图像更加平滑，能避免后续处理描绘了噪声的边缘。
②图三为x方向梯度，图四为y方向梯度，图五为梯度幅值：
梯度计算后，轮廓已将基本描绘出，但不太清晰，且有些假轮廓；
③图六：非极大值抑制处理，能去掉假轮廓，仅保留真轮廓边缘。
④图七：边缘连接处理，并加深了轮廓颜色。
⑤图八：利用matlab自带的canny算子函数做边缘检测，作为对比。

四.python代码

1.主程序

# canny算子实现边缘检测
# 主程序

from __future__ import division
from gaussian_filter import gaussian
from gradient import gradient
from nonmax_suppression import maximum
from double_thresholding import thresholding

import numpy as np
import matplotlib.image as imgplt
import matplotlib.pyplot as plt

class tracking:
    def __init__(self, tr):
        self.im = tr[0]
        strongs = tr[1]

        self.vis = np.zeros(im.shape, bool)
        self.dx = [1, 0, -1,  0, -1, -1, 1,  1]
        self.dy = [0, 1,  0, -1,  1, -1, 1, -1]
        for s in strongs:
            if not self.vis[s]:
                self.dfs(s)
        for i in range(self.im.shape[0]):
            for j in range(self.im.shape[1]):
                self.im[i, j] = 1.0 if self.vis[i, j] else 0.0

    def dfs(self, origin):
        q = [origin]
        while len(q) > 0:
            s = q.pop()
            self.vis[s] = True
            self.im[s] = 1
            for k in range(len(self.dx)):
                for c in range(1, 16):
                    nx, ny = s[0] + c * self.dx[k], s[1] + c * self.dy[k]
                    if self.exists(nx, ny) and (self.im[nx, ny] >= 0.5) and (not self.vis[nx, ny]):
                        q.append((nx, ny))
        pass

    def exists(self, x, y):
        return x >= 0 and x < self.im.shape[0] and y >= 0 and y < self.im.shape[1]


if __name__ == '__main__':
    im = imgplt.imread('Lena.jpg')

    plt.subplot(3, 2, 1)
    plt.imshow(im)
    plt.axis('off')
    plt.title('Original')

    im = im[:, :, 0]
    gim = gaussian(im)
    grim, gphase = gradient(gim)
    gmax = maximum(grim, gphase)
    thres = thresholding(gmax)
    edge = tracking(thres)

    plt.gray()

    plt.subplot(3, 2, 2)
    plt.imshow(gim)
    plt.axis('off')
    plt.title('Gaussian')

    plt.subplot(3, 2, 3)
    plt.imshow(grim)
    plt.axis('off')
    plt.title('Gradient')

    plt.subplot(3, 2, 4)
    plt.imshow(gmax)
    plt.axis('off')
    plt.title('Non-Maximum suppression')

    plt.subplot(3, 2, 5)
    plt.imshow(thres[0])
    plt.axis('off')
    plt.title('Double thresholding')

    plt.subplot(3, 2, 6)
    plt.imshow(edge.im)
    plt.axis('off')
    plt.title('Edges')

    plt.show()

2.步骤一：图像平滑

# canny算子步骤1：图像平滑
# 使用gauss函数实现：5*5

from __future__ import division
import numpy as np
import matplotlib.image as imgplt
import matplotlib.pyplot as plt


def gaussian(im):
    b = np.array([[2, 4,  5,  2,  2],
               [4, 9,  12, 9,  4],
               [5, 12, 15, 12, 5],
               [4, 9,  12, 9,  4],
               [2, 4,  5,  4,  2]]) / 156
    kernel = np.zeros(im.shape)
    kernel[:b.shape[0], :b.shape[1]] = b

    fim = np.fft.fft2(im)
    fkernel = np.fft.fft2(kernel)
    fil_im = np.fft.ifft2(fim * fkernel)

    return abs(fil_im).astype(int)


if __name__ == "__main__":

    im = imgplt.imread('Lena.jpg')
    im = im[:, :, 0]
    plt.gray()

    plt.subplot(1, 2, 1)
    plt.imshow(im)
    plt.axis('off')
    plt.title('Original')

    plt.subplot(1, 2, 2)
    plt.imshow(gaussian(im))
    plt.axis('off')
    plt.title('Filtered')

    plt.show()

3.步骤二：梯度计算

# canny算子步骤2：梯度计算

from __future__ import division
from gaussian_filter import gaussian
import numpy as np
import matplotlib.image as imgplt
import matplotlib.pyplot as plt


def gradient(im):
    # Sobel operator
    op1 = np.array([[-1, 0, 1],
                 [-2, 0, 2],
                 [-1, 0, 1]])
    op2 = np.array([[-1, -2, -1],
                 [ 0,  0,  0],
                 [ 1,  2,  1]])
    kernel1 = np.zeros(im.shape)
    kernel1[:op1.shape[0], :op1.shape[1]] = op1
    kernel1 = np.fft.fft2(kernel1)

    kernel2 = np.zeros(im.shape)
    kernel2[:op2.shape[0], :op2.shape[1]] = op2
    kernel2 = np.fft.fft2(kernel2)

    fim = np.fft.fft2(im)
    Gx = np.real(np.fft.ifft2(kernel1 * fim)).astype(float)
    Gy = np.real(np.fft.ifft2(kernel2 * fim)).astype(float)

    G = np.sqrt(Gx**2 + Gy**2)
    Theta = np.arctan2(Gy, Gx) * 180 / np.pi
    return G, Theta


if __name__ == '__main__':

  im = imgplt.imread('Lena.jpg')
  im = im[:, :, 0]
  gim = gaussian(im)
  grim, gphase = gradient(gim)

  plt.gray()

  plt.subplot(2, 2, 1)
  plt.imshow(im)
  plt.axis('off')
  plt.title('Original')

  plt.subplot(2, 2, 2)
  plt.imshow(gim)
  plt.axis('off')
  plt.title('Gaussian')

  plt.subplot(2, 2, 3)
  plt.imshow(grim)
  plt.axis('off')
  plt.title('Gradient')

  plt.show()

4.步骤三：梯度幅值非极大值抑制

# canny算子步骤3：梯度幅值非极大值抑制

from __future__ import division
from gaussian_filter import gaussian
from gradient import gradient
import numpy as np
import matplotlib.image as imgplt
import matplotlib.pyplot as plt


def maximum(det, phase):
    gmax = np.zeros(det.shape)
    for i in range(gmax.shape[0]):
        for j in range(gmax.shape[1]):
            if phase[i][j] < 0:
                phase[i][j] += 360

            if ((j + 1) < gmax.shape[1]) and ((j - 1) >= 0) and ((i + 1) < gmax.shape[0]) and ((i - 1) >= 0):
                # 0 degrees
                if (phase[i][j] >= 337.5 or phase[i][j] < 22.5) or (phase[i][j] >= 157.5 and phase[i][j] < 202.5):
                    if det[i][j] >= det[i][j + 1] and det[i][j] >= det[i][j - 1]:
                        gmax[i][j] = det[i][j]
                # 45 degrees
                if (phase[i][j] >= 22.5 and phase[i][j] < 67.5) or (phase[i][j] >= 202.5 and phase[i][j] < 247.5):
                    if det[i][j] >= det[i - 1][j + 1] and det[i][j] >= det[i + 1][j - 1]:
                        gmax[i][j] = det[i][j]
                # 90 degrees
                if (phase[i][j] >= 67.5 and phase[i][j] < 112.5) or (phase[i][j] >= 247.5 and phase[i][j] < 292.5):
                    if det[i][j] >= det[i - 1][j] and det[i][j] >= det[i + 1][j]:
                        gmax[i][j] = det[i][j]
                # 135 degrees
                if (phase[i][j] >= 112.5 and phase[i][j] < 157.5) or (phase[i][j] >= 292.5 and phase[i][j] < 337.5):
                    if det[i][j] >= det[i - 1][j - 1] and det[i][j] >= det[i + 1][j + 1]:
                        gmax[i][j] = det[i][j]
    return gmax


if __name__ == '__main__':

    im = imgplt.imread('Lena.jpg')
    im = im[:, :, 0]
    gim = gaussian(im)
    grim, gphase = gradient(gim)
    gmax = maximum(grim, gphase)

    plt.gray()
    plt.subplot(2, 2, 1)
    plt.imshow(im)
    plt.axis('off')
    plt.title('Original')

    plt.subplot(2, 2, 2)
    plt.imshow(gim)
    plt.axis('off')
    plt.title('Gaussian')

    plt.subplot(2, 2, 3)
    plt.imshow(grim)
    plt.axis('off')
    plt.title('Gradient')

    plt.subplot(2, 2, 4)
    plt.imshow(gmax)
    plt.axis('off')
    plt.title('Non-Maximum suppression')

    plt.show()

5.步骤四：边缘连接

# canny算子步骤4：边缘连接
# 边缘连接方法为使用双阈值

from __future__ import division
from gaussian_filter import gaussian
from gradient import gradient
from nonmax_suppression import maximum
import numpy as np
import matplotlib.image as imgplt
import matplotlib.pyplot as plt


def thresholding(im):
    thres = np.zeros(im.shape)
    strong = 1.0
    weak = 0.5
    mmax = np.max(im)
    lo, hi = 0.1 * mmax, 0.8 * mmax
    strongs = []
    for i in range(im.shape[0]):
        for j in range(im.shape[1]):
            px = im[i][j]
            if px >= hi:
                thres[i][j] = strong
                strongs.append((i, j))
            elif px >= lo:
                thres[i][j] = weak
    return thres, strongs


if __name__ == '__main__':

    im = imgplt.imread('Lena.jpg')
    im = im[:, :, 0]
    gim = gaussian(im)
    grim, gphase = gradient(gim)
    gmax = maximum(grim, gphase)
    thres = thresholding(gmax)
    plt.gray()

    plt.subplot(3, 2, 1)
    plt.imshow(im)
    plt.axis('off')
    plt.title('Original')

    plt.subplot(3, 2, 2)
    plt.imshow(gim)
    plt.axis('off')
    plt.title('Gaussian')

    plt.subplot(3, 2, 3)
    plt.imshow(grim)
    plt.axis('off')
    plt.title('Gradient')

    plt.subplot(3, 2, 4)
    plt.imshow(gmax)
    plt.axis('off')
    plt.title('Non-Maximum suppression')

    plt.subplot(3, 2, 5)
    plt.imshow(thres[0])
    plt.axis('off')
    plt.title('Double thresholding')

    plt.show()

结果