【Numpy】图像处理——LOG、DOG、Canny算子

已于 2024-02-20 18:01:47 修改
阅读量993 收藏 11
点赞数 7
分类专栏： 图像护理 文章标签： 计算机视觉 机器学习 人工智能
于 2024-02-19 16:28:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34108802/article/details/136172730
版权

文章目录

前言

  上一篇博客中提到了部分边缘检测算子，不过还有几个更先进的边缘检测算子没有写上。这也是为后续开展图像轮廓等实验做准备。

Marr-Hildreth（LOG算子）

  其实这个算子就是高斯平滑与拉普拉斯的结合。其原理：由于灰度变化与图像尺度无关，因此可以使用不同尺度的微分算子进行边缘检测，大尺度微分算子可以检测模糊的边缘，小尺度微分算子可以检测清晰的细节。

  选择拉普拉斯算子的两个基本思想：（1）算子的高斯部分会模糊图像，导致灰度结构（包括噪声）的尺度减小到远小于 σ \sigma σ。（2）拉普拉斯的二阶导数性质，尽管一阶导数可用于检测灰度突变，但他们是方向性算子。

  另外，拉普拉斯有着各向同性（旋转不变）的重要有点，这不仅符合人的视觉系统特性，而且对任何该方向的灰度变化的响应是相等的，从而避免了使用多个核去计算图像中任意点处的最强响应。

  二维高斯函数： G ( x , y ) = e − x 2 + y 2 2 σ 2 G(x,y)=e^{-\frac{x^2+y^2}{2\sigma^2}} G(x,y)=e−2σ2x2+y2​

  用 ∇ 2 \nabla^2 ∇2表示拉普拉斯，G表示标准差为 δ \delta δ的二维高斯核函数。

G ( x , y ) = ∂ 2 G ( x , y ) ∂ x 2 + ∂ 2 G ( x , y ) ∂ y 2 = ∂ ∂ x ( − x ∂ 2 e − x 2 + y 2 2 ∂ 2 ) + ∂ ∂ y ( − y ∂ 2 e − x 2 + y 2 2 ∂ 2 ) = ( x 2 ∂ 4 − 1 ∂ 2 ) e − x 2 + y 2 2 ∂ 2 + ( y 2 ∂ 4 − 1 ∂ 2 ) e − x 2 + y 2 2 ∂ 2 G(x,y)=\frac{{\partial}^2G(x,y)}{\partial x^2}+\frac{{\partial}^2G(x,y)}{\partial y^2}=\frac{\partial}{\partial x}(\frac{-x}{{\partial}^2}e^{-\frac{x^2+y^2}{2{\partial}^2}})+\frac{\partial}{\partial y}(\frac{-y}{{\partial}^2}e^{-\frac{x^2+y^2}{2{\partial}^2}})=(\frac{x^2}{{\partial}^4}-\frac{1}{{\partial}^2})e^{-\frac{x^2+y^2}{2{\partial}^2}}+(\frac{y^2}{{\partial}^4}-\frac{1}{{\partial}^2})e^{-\frac{x^2+y^2}{2{\partial}^2}} G(x,y)=∂x2∂2G(x,y)​+∂y2∂2G(x,y)​=∂x∂​(∂2−x​e−2∂2x2+y2​)+∂y∂​(∂2−y​e−2∂2x2+y2​)=(∂4x2​−∂21​)e−2∂2x2+y2​+(∂4y2​−∂21​)e−2∂2x2+y2​

∇ 2 G ( x , y ) = ( x 2 + y 2 − 2 ∂ 2 ∂ 4 ) e − x 2 + y 2 2 ∂ 2 {\nabla}^2G(x,y)=(\frac{x^2+y^2-2{\partial}^2}{{\partial}^4})e^{-\frac{x^2+y^2}{2{\partial}^2}} ∇2G(x,y)=(∂4x2+y2−2∂2​)e−2∂2x2+y2​

  这个就是高斯拉普拉斯（LOG）函数。

  算法具体情况如下：首先让LOG核与一幅输入图像卷积。 g ( x , y ) = [ ∇ 2 G ( x , y ) ] ∗ f ( x , y ) g(x,y)=[{\nabla}^2G(x,y)]\ast f(x,y) g(x,y)=[∇2G(x,y)]∗f(x,y)

  然后寻找 g ( x , y ) g(x,y) g(x,y)的过零点来确定 f ( x , y ) f(x,y) f(x,y)中边缘的位置。因为拉普拉斯变换核卷积都是线性于是暖，因此可以将上式写为： g ( x , y ) = [ ∇ 2 G ( x , y ) ∗ f ( x , y ) ] g(x,y)=[{\nabla}^2G(x,y)\ast f(x,y)] g(x,y)=[∇2G(x,y)∗f(x,y)]

  此处星号 ∗ \ast ∗表示卷积运算。

  因此，LOG算子的具体实现：可以先对图像做高斯平滑，再做拉普拉斯变换；也可以利用卷积运算的结合律，先计算高斯拉普拉斯卷积核，再与图像卷积，以提高计算速度。

#先做高斯平滑，再做拉普拉斯变换
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

img = Image.open("go_work.jpg")
plt.title("ni_bu_gan")
plt.imshow(img,cmap="brg")
plt.show()

img_gray = img.convert("L")
plt.title("dao_dan_mao")
plt.imshow(img_gray,cmap="gray")
plt.show()

image = np.array(img_gray)

#高斯平滑
def GaussianBlur(sigma):
    ksize = 2 * (3 * sigma) + 1
    filter = np.ones((ksize,ksize)) / (ksize ** 2)
    for i in range(ksize):
        for j in range(ksize):
            filter[i,j] = np.exp((((i - 3 * sigma) ** 2) + (j - 3 * sigma) ** 2) * (-1)/(sigma ** 2 * 2))
    return filter

#卷积之前的填充
def padding_image(image,h_f,w_f):
    h_img,w_img = image.shape
    h_new,w_new = h_img + h_f - 1,w_img + w_f - 1
    image_padding = np.zeros((h_new,w_new))
    for i in range(h_img):
        for j in range(w_img):
            image_padding[i + int((h_f-1)/2),j + int((w_f-1)/2)] = image[i,j]
    return image_padding

#无论是相关运算，还是卷积运算，经过滤波器核之后的图像输出结果

#空间卷积运算,注意：这里的d一定是偶数
def convolution_operation(image,filter):
    h_img,w_img = image.shape
    h_f,w_f = filter.shape
    filter_convolution = np.flip(filter)#卷积运算所需二维核是对相关运算二维核的翻转。
    image_out = np.zeros((h_img,w_img))
    image_padding = padding_image(image,h_f,w_f)
    
    for i in range(h_img):
        for j in range(w_img):
            image_out[i,j] = np.sum(np.multiply(filter_convolution[:,:],image_padding[i:i+h_f,j:j+w_f]))
    return image_out

#高斯平滑后的图像
def img_Gauss(image,sigma):
    return convolution_operation(image,GaussianBlur(sigma))

#拉普拉斯变换
def img_Laplacian(img_arr):
    h,w = img_arr.shape
    
    img_laplacian_ori = np.zeros((h,w))
    laplacian_ori = np.zeros((h,w))

    filter_laplacian_ori = np.matrix([[1,1,1],[1,-8,1],[1,1,1]])
    for i in range(1,h-1):
        for j in range(1,w-1):
            laplacian_ori[i,j] = abs(np.sum(np.multiply(img_arr[i-1:i+2,j-1:j+2],filter_laplacian_ori)))
            
    return laplacian_ori

#绘图
def draw_convolution(sigma):
    image_convolution = img_Laplacian(img_Gauss(image,sigma))
    image_out = np.uint8(image_convolution)

    plt.title("you_de_shi_pa_lu_gan")
    plt.imshow(image_out,cmap="gray")
    plt.show()
    
if __name__ == "__main__":
    sigma = 2
    draw_convolution(sigma)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  接下来需要徒手写拉普拉斯高斯平滑了，这里面需要注意的是，此处使用的拉普拉斯高斯滤波器的大小不再是预先给定好的，如拉普拉斯滤波器那般。此处滤波器的大小是由 σ \sigma σ值决定的，因为LOG算子规定了滤波器中心点以外的其他点与中心点的距离最大不超过 2 σ \sqrt{2}\sigma 2 ​σ。

  既然如此，那么我们接下来就顶风行事，直接让滤波器的大小为 2 ∗ 3 ∗ σ + 1 2*3*\sigma+1 2∗3∗σ+1。这样一来， σ \sigma σ一定得是正整数了，当然这也是我举个例子，作为特殊情况，大家自己做的时候可以自己定大小，但一定要在 2 ∗ 3 ∗ σ + 1 2*3*\sigma+1 2∗3∗σ+1的范围内。我这里的设置的滤波器中心点的坐标就是 ( 3 σ , 3 σ ) (3\sigma,3\sigma) (3σ,3σ)。

  注意，这里用半径为 3 σ 3\sigma 3σ，是考虑到高斯标准差确定滤波核大小时，三倍的标准差占比比较常用，占比接近100%。

#先计算高斯拉普拉斯卷积核，再与图像卷积
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

img = Image.open("go_work.jpg")
plt.title("ni_bu_gan")
plt.imshow(img,cmap="brg")
plt.show()

img_gray = img.convert("L")
plt.title("dao_dan_mao")
plt.imshow(img_gray,cmap="gray")
plt.show()

image = np.array(img_gray)

#计算高斯拉普拉斯卷积核
def Laplacian_GaussianBlur(sigma):
    ksize = 2 * (3 * sigma) + 1
    filter = np.ones((ksize,ksize)) / (ksize ** 2)
    for i in range(ksize):
        for j in range(ksize):
            filter[i,j] = np.exp(((i - 3 * sigma) ** 2 + (j - 3 * sigma) ** 2) * (-1) /(2 * (sigma ** 2))) * (((i - 3 * sigma) ** 2 + (j - 3 * sigma) ** 2) - 2 * (sigma ** 2)) / (sigma ** 4)
    return filter

#卷积之前的填充
def padding_image(image,h_f,w_f):
    h_img,w_img = image.shape
    h_new,w_new = h_img + h_f - 1,w_img + w_f - 1
    image_padding = np.zeros((h_new,w_new))
    for i in range(h_img):
        for j in range(w_img):
            image_padding[i + int((h_f-1)/2),j + int((w_f-1)/2)] = image[i,j]
    return image_padding

#无论是相关运算，还是卷积运算，经过滤波器核之后的图像输出结果

#空间卷积运算,注意：这里的d一定是偶数
def convolution_operation(image,filter):
    h_img,w_img = image.shape
    h_f,w_f = filter.shape
    filter_convolution = np.flip(filter)#卷积运算所需二维核是对相关运算二维核的翻转。
    image_out = np.zeros((h_img,w_img))
    image_padding = padding_image(image,h_f,w_f)
    
    for i in range(h_img):
        for j in range(w_img):
            image_out[i,j] = np.sum(np.multiply(filter_convolution[:,:],image_padding[i:i+h_f,j:j+w_f]))
    return image_out

#绘图
def draw_convolution(sigma):
    image_convolution = convolution_operation(image,Laplacian_GaussianBlur(sigma))
    image_out = np.uint8(image_convolution)

    plt.title("you_de_shi_pa_lu_gan")
    plt.imshow(image_out,cmap="gray")
    plt.show()
    
if __name__ == "__main__":
    sigma = 2
    draw_convolution(sigma)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

DOG算子

  DOG算子和LOG算子差不多，区别在于使用了两个不同尺度的高斯滤波器进行差分算法，我们称之为高斯差分法（Difference of Gaussian）。这里的“尺度”实际上就是滤波器的标准差。

#先做高斯平滑，再做拉普拉斯变换
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

img = Image.open("go_work.jpg")
plt.title("ni_bu_gan")
plt.imshow(img,cmap="brg")
plt.show()

img_gray = img.convert("L")
plt.title("dao_dan_mao")
plt.imshow(img_gray,cmap="gray")
plt.show()

image = np.array(img_gray)

#高斯平滑
def GaussianBlur(sigma):
    ksize = 2 * (3 * sigma) + 1
    filter = np.ones((ksize,ksize)) / (ksize ** 2)
    for i in range(ksize):
        for j in range(ksize):
            filter[i,j] = np.exp((((i - 3 * sigma) ** 2) + (j - 3 * sigma) ** 2) * (-1)/(sigma ** 2 * 2))
    return filter

#卷积之前的填充
def padding_image(image,h_f,w_f):
    h_img,w_img = image.shape
    h_new,w_new = h_img + h_f - 1,w_img + w_f - 1
    image_padding = np.zeros((h_new,w_new))
    for i in range(h_img):
        for j in range(w_img):
            image_padding[i + int((h_f-1)/2),j + int((w_f-1)/2)] = image[i,j]
    return image_padding

#无论是相关运算，还是卷积运算，经过滤波器核之后的图像输出结果

#空间卷积运算,注意：这里的d一定是偶数
def convolution_operation(image,filter):
    h_img,w_img = image.shape
    h_f,w_f = filter.shape
    filter_convolution = np.flip(filter)#卷积运算所需二维核是对相关运算二维核的翻转。
    image_out = np.zeros((h_img,w_img))
    image_padding = padding_image(image,h_f,w_f)
    
    for i in range(h_img):
        for j in range(w_img):
            image_out[i,j] = np.sum(np.multiply(filter_convolution[:,:],image_padding[i:i+h_f,j:j+w_f]))
    return image_out

#高斯滤波后的图像
def img_Gauss(image,sigma):
    return convolution_operation(image,GaussianBlur(sigma))

#注意sigma1 > sigma2
def DOG(sigma1,sigma2):
    return (img_Gauss(image,sigma1) - img_Gauss(image,sigma2)) / (sigma1 - sigma2)

#拉普拉斯变换
def img_Laplacian(img_arr):
    h,w = img_arr.shape
    
    img_laplacian_ori = np.zeros((h,w))
    laplacian_ori = np.zeros((h,w))

    filter_laplacian_ori = np.matrix([[1,1,1],[1,-8,1],[1,1,1]])
    for i in range(1,h-1):
        for j in range(1,w-1):
            laplacian_ori[i,j] = abs(np.sum(np.multiply(img_arr[i-1:i+2,j-1:j+2],filter_laplacian_ori)))
            
    return laplacian_ori

#绘图
def draw_convolution(sigma1,sigma2):
    image_convolution = img_Laplacian(DOG(sigma1,sigma2))
    image_out = np.uint8(image_convolution)

    plt.title("you_de_shi_pa_lu_gan")
    plt.imshow(image_out,cmap="gray")
    plt.show()
    
if __name__ == "__main__":
    sigma1 = 3
    sigma2  = 2
    draw_convolution(sigma1,sigma2)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

坎尼算子（Canny）

  Canny算子要求在提高边缘敏感性的同时抑制噪声，包括如下三个基本目标：
  (1)低错误率。所有边缘都应该被找到，并且不应有虚假响应。
  (2)边缘点应被很好地定位。检测地边缘点要尽可能地接近实际边缘地中心。有检测算子标记为边缘一点和真实边缘的中心之间的距离应该最小。
  (3)单一边缘有且只有一个准确的响应，并尽可能地抑制虚假边缘。即：对于每一个真实的边缘点，检测算子应只返回一个点。真实边缘周围的局部最大数应是最小的。这意味着检测算子不应识别只存在单个边缘点的多个边缘像素。

  那么，Canny边缘检测算法的基本步骤：
  （1）使用高斯滤波器平滑图像。 G ( x , y ) = e − x 2 + y 2 2 σ 2 G(x,y)=e^{-\frac{x^2+y^2}{2{\sigma}^2}} G(x,y)=e−2σ2x2+y2​
  （2）用一阶有限差分计算梯度和方向。
  （3）对梯度幅值进行非极大值机制（NMS）。
  （4）通过双阈值处理和连通性分析检测和连接边缘。

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread("go_work.jpg",flags=0)  #读出的图像转化为灰度图

plt.title("img_origin")
plt.imshow(img,cmap="gray")
plt.show()

img_Canny = cv2.Canny(img,threshold1=50,threshold2=150)

plt.title("img_Canny")
plt.imshow(img_Canny,cmap="gray")
plt.show()

在这里插入图片描述
在这里插入图片描述

结语

你不干

Cherry Yuan
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
LOG算子的程序代码
07-19
关于Log算子的实现流程和实现代码，很好的模板
numpy-基于numpy实现的图像处理算法之Canny边缘检测.zip
最新发布
06-23
总的来说，"numpy-基于numpy实现的图像处理算法之Canny边缘检测.zip"这个项目旨在通过实践，让你深入学习图像处理和NumPy库的使用，提高你在这一领域的技能。通过这个项目的实施，你不仅可以理解Canny算法的细节，还...
图像处理之边缘检测[微分算子、Canny算子和LOG算子]
qq_44111805的博客
08-20 8130
LOG算子是在经典算子的基础上发展起来的边缘检测算子，根据信噪比求得检测边缘的最优滤波器。边缘总是以强度突变的形式出现，可以定义为图像局部特性的不连续性，如灰度的突变和纹理结构的突变等。图像的边缘包含了物体形状的重要信息，它不仅在分析图像时大幅度地减少了要处理的信息量，而且还保护了目标的边界结构。对于复杂的图像，采用Roberts算子不能较好地得到图像的边缘，而需要采用更加复杂的3X3的算子比如Prewitt算子。对于离散的图像f(x,y)，边缘检测算子是用图像的垂直和水平差分来逼近梯度算子，即。
【NumPy】一文向您详细介绍 np.log()
创作高质量博文，分享知识，共同进步！
04-21 1782
🌟【NumPy探秘】一文解锁np.log()的神奇魅力🌟 一文带您畅游NumPy的海洋，深入探索np.log()的奥秘！从初识到精通，本文详细解读np.log()函数的特性与应用场景，助您轻松驾驭对数运算。更有高级用法和拓展思考，让您的数据处理技能更上一层楼！ 不仅如此，我们还将比较np.log()与其他对数函数的异同，让您在选择函数时更加得心应手。读完本文，您将收获满满，成为对数运算的行家里手！#NumPy #np.log() #对数运算 #数据处理 #机器学习
图像处理之LoG算子（高斯拉普拉斯）
weixin_42491648的博客
07-19 2013
LoG算子是由拉普拉斯算子改进而来。拉普拉斯算子是二阶导数算子，是一个标量，具有线性、位移不变性，其传函在频域空间的原点为0。所有经过拉普拉斯算子滤波的图像具有零平均灰度。但是该算子的缺点是对噪声具有敏感性，因此在实际应用中，一般先要对图像进行平滑滤波，再用拉氏算子进行图像的边缘检测。这就是LoG算子的产生的背景（最后的梯度表达式为高斯函数和原图像卷积，再去二阶微分算子）。
数字图像处理——LoG算子
ingy
08-31 9970
Harris算子的一个缺点是不具有尺度不变性，所以引入了另一种检测算子：高斯拉普拉斯算子。 LoG算子 前面提到过高斯一阶导，其作用是检测边缘（边缘区域高斯一阶导数取得极值），那么对一阶导数继续求导得到二阶导数，可想而知，一阶导数的极值点就是二阶导数的0点。进而可以通过寻找二阶导数的0点（亦或是接近于0的点），去寻找图片的梯度（边缘）。 拉普拉斯算子的表示式： ...
numpy log
易水寒
10-27 1万+
标题1.以10为底的对数 print(np.log10(100)) 10 2.以2为底的对数 print(np.log2(4)) 2 3.以自然对数为底的对数 print(np.log(np.e)) 1 4. 以n为底的对数 print(np.log(9) / np.log(3)) 2 http://www.waitingfy.com/archives/5074 ...
numpy.log(math.log)
热门推荐
Mr_Cat123的博客
12-14 8万+
此处先介绍log常用的两个底数计算（以10为底和以e为底），以后再补充完毕 1以10为底：import numpy as np np.log10(x)如：>>> np.log10(100) 2.0 >>> 2，e为底 log下什么都不写默认是自然对数 如：>>> np.log(np.e) 1.0 >>> np.log(10) 2.3025850929940459
基于opencv和numpy的customtkinter图像处理工具
06-18
程序安装包，点击自动安装exe
Python+OpenCV图像处理——实现轮廓发现
01-19
简介：轮廓发现是基于图像边缘提取的基础寻找对象轮廓的方法，所以边缘提取的阈值选定会影响最终轮廓发现结果。 代码如下： import cv2 as cv import numpy as np def contours_demo(image): dst = cv.Gaussian...
numpy-基于numpy实现的图像处理算法之Swirl.zip
06-23
本主题关注的是如何使用NumPy来实现图像处理算法，特别是Swirl算法，这是一种能够扭曲和旋转图像的特效处理方法。下面我们将深入探讨NumPy与图像处理的关系、Swirl算法的基本原理以及如何使用NumPy来实现这一算法。 ...
numpy-基于numpy实现的图像处理算法之Entropy.zip
06-23
本主题将深入探讨如何利用NumPy实现图像处理中的熵（Entropy）计算，这是图像分析和理解的重要步骤。 熵是信息理论中的一个概念，用于衡量信息的不确定性或信息量。在图像处理中，熵通常用于描述图像的复杂性或纹理...
numpy中的log和ln函数
u011699626的博客
07-18 3万+
每次当我想用python实现ln函数时，下意识的就会输入错误的函数代码，这里特来记录一下关于numpy中的ln和log函数正确的调用方式。 ln函数： import numpy as np class NumpyStudy: def lnFunction(self): const = np.e result = np.log(const) print("函数ln(e)的值为：") print(result) if __name_
python numpy之log()
xiaoyurainzi的博客
07-11 1371
python numpy之log()
NumPy实现Canny算法
m0_46306264的博客
03-19 197
numpy实现canny算法
[Python] 数学基础 - 对数(log)，常用对数，对数的逆运算（自然指数(exp)，）以及在numpy计算针对向量进行对数运算
老狼工作室的博客
01-04 2092
本文主要介绍了什么对数，常用对数，和以及在numpy计算针对向量进行对数运算。
[python] 计算对数：numpy.log()和math.log()
真理无穷，进一步有进一步的欢喜
05-05 1万+
numpy.log()和math.log()都可以进行对数运算。 但math.log()只能对单个数值 (scalar) 进行运算，如果对数组运算则会报错：TypeError: only size-1 arrays can be converted to Python scalars 而numpy.log()则可以对数组进行运算。 建议还是用numpy.log()，少用math.log()。 ...
numpy中的log和ln函数介绍
知识搬运者
11-03 1055
np.log10()指代的便是数学中使用的lg函数。np.log()指代的便是数学中使用的ln函数。
canny算子怎么进行后续处理
06-06
Canny算子是一种常用的边缘检测算法，其输出结果是一幅二值图像，其中白色像素表示检测到的边缘，黑色像素表示没有检测到的边缘。在使用Canny算子进行边缘检测后，可以进行以下后续处理： 1. 边缘细化 Canny算子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cherry Yuan

再多的奖励也换不回失去的头发

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值