精华内容
下载资源
问答
  • 这些函数使用高斯平滑和对称差分进行梯度估计。 它们可用于支持例如 Canny 边缘检测器,并可形成许多图像和数据处理操作的初始阶段。 梯度函数接受不同类型的数据: gradients_x: 一个向量 gradients_xy:一个二维...
  • 主要为大家详细介绍了python+opencv实现高斯平滑滤波,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 基于matlab的代码,使用高斯平滑化方法处理图像,去噪声。
  • 图像处理 高斯平滑 C/C++语言实现................................
  • 此函数为直方图实现高斯平滑,然后可用于找到阈值。 它使用 imhist 函数返回的 COUNTS 变量,w 是您要使用的窗口的大小。 它必须是一个奇数。 否则,该功能将无法正常运行。 典型应用: I=imread('blood1','tiff');...
  • 高斯平滑处理高斯核

    2015-05-25 15:37:20
    C++实现高斯平滑处理,建立三维高斯核,对各类图像起到平滑滤波的作用
  • 基于CUDA平台的9点平滑、高斯平滑代码
  • matlab开发-通过频域进行三维高斯平滑卷积的效率。本机傅立叶实现,支持GPU计算和各向异性体素。
  • 自适应高斯平滑滤波算法(adaptive Gaussian smoothing algorithm)在计算机视觉与模式识别以及数字图像处理中应用广泛,是一种对信号局部突变有自适应性的迭代算法
  • Visual c++数字图像处理高斯平滑算法源码
  • 频域中的三维高斯平滑,原生频域实现。 通过更换来实现平滑具有傅立叶系数的空间域卷积乘法。 这也是实现您的目标的一个很好的例子使用原生傅立叶表达式自己的过滤器。 R = gauss3filter(I); R = gauss3filter(I, ...
  • 高斯平滑函数

    2011-12-19 14:09:09
    快速实现高斯平滑处理的函数,用VC程序写的代码。
  • 在讲平滑处理前,先来了解下在OpenCV中平滑处理用到的“滑动窗口”的概念,下面的这个例子中选择了一个ksize=3x3的滑动窗口(或称滤波器模板、kernel),如黄色部分所示。用这个ksize=3x3的窗口作用于原始图像上的每...

    原文链接:http://www.juzicode.com/opencv-python-gaussianblur-bilateralfilter

    返回Opencv-Python教程

    OpenCV-Python教程:均值平滑、中值平滑 一文中介绍了在滑动窗口内均值的方式进行平滑处理,这时窗口中心点和窗口领域内的所有像素的加权系数都是一样的,中值平滑提取中位数时滑动窗口内任一像素出现中值的概率也是相同的。本文要介绍的高斯平滑则根据距离中心点的间距远近其权重会不同,这种方式看起来更符合”惯例”:身边的人对你影响会更大。

    1、高斯平滑GaussianBlur()

    所谓高斯平滑,闻其名就知道和”高斯”这位大神有关,这里实际用到的是高斯分布。我们先来看下一维高斯分布(正态分布)的概率密度函数:

    这是一个以自然常数e为底的二次指数函数,其中μ是均值,σ是标准差,我们可以用matplotlib绘图,设置μ=0,σ=0.8:

    #juzicode.com/vx:桔子code
    import numpy as np
    import matplotlib.pyplot as plt
    plt.rc('font',family='Youyuan',size='9')
    plt.rc('axes',unicode_minus='False')
    mu=0        #均值
    sigma=0.8   #标准差
    x=np.linspace(-3,3,60)  
    y=np.exp((-(x-mu)**2)/(2*(sigma**2)))/(np.sqrt(2*np.pi)*sigma)  
    plt.plot(x,y,"b-",) 
    plt.grid(True)

    因为在OpenCV的高斯平滑中用到的正态分布都是取μ=0,这里就不对比u值差异,只看下取不同的σ的曲线,

    #juzicode.com/vx:桔子code
    import numpy as np
    import matplotlib.pyplot as plt
    plt.rc('font',family='Youyuan',size='9')
    plt.rc('axes',unicode_minus='False')
    
    x=np.linspace(-3,3,100)   
    mu=0     # 均值μ
    sigma=0.3  # 标准差σ
    y=np.exp((-(x-mu)**2)/(2*(sigma**2)))/(np.sqrt(2*np.pi)*sigma) 
    sigma=0.5 
    y2=np.exp((-(x-mu)**2)/(2*(sigma**2)))/(np.sqrt(2*np.pi)*sigma)   
    sigma=1.1
    y3=np.exp((-(x-mu)**2)/(2*(sigma**2)))/(np.sqrt(2*np.pi)*sigma)  
    plt.plot(x,y,"b-",)
    plt.plot(x,y2,"g-",)
    plt.plot(x,y3,"r-",)
    plt.grid(True)

    从高斯分布的曲线可以看到(μ=0时):

    • 当x=0时,f(x)的值最大,当x向两边变化时,f(x)的值越来越小;
    • 这个曲线在x=0的2侧是对称的,f(-1)=f(1),f(-2)=f(2);
    • σ越大,曲线越平坦,x=0时的取值越低。

    因为图像是二维的,实际上在OpenCV中要用到二维高斯分布,可以从一维高斯分布推导出二维高斯分布(这里假设x,y不相关),其中x表示邻域像素距离中心点水平方向的间距,y表示垂直方向的间距:

    用matplotlib绘制二维高斯分布:

    #juzicode.com/vx:桔子code
    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib import cm
    from mpl_toolkits.mplot3d import Axes3D
    
    fig = plt.figure()
    ax = Axes3D(fig) 
    X = np.arange(-3, 3.1, 0.1,dtype=np.float64).reshape(-1,1)
    Y = np.arange(-3, 3.1, 0.1,dtype=np.float64)
    mux,muy=0,0
    sigmax,sigmay = 0.8,0.8
    expont = -0.5*(((X-mux)/sigmax)**2 + ((Y-muy)/sigmay)**2)
    Z=np.exp(expont)/(2*np.pi*sigmax*sigmay)
    ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=cm.viridis)
    plt.show()

    二维高斯分布也具备一维高斯分布类似的特点:在f(0,0)处取值最大(μ=0时),σ越大曲线越平坦。

    有了前面绘制曲线得到的直观感受,下面我们用numpy构造一个5×5大小的高斯核(滑动窗口):

    #juzicode.com/vx:桔子code
    import numpy as np
    X = np.arange(-2, 3, 1,dtype=np.float64).reshape(-1,1)#转置
    Y = np.arange(-2, 3, 1,dtype=np.float64)  #[-2. -1.  0.  1.  2.]
    mux,muy=0,0
    sigmax,sigmay = 0.8,0.8
    expont = -0.5*(((X-mux)/sigmax)**2 + ((Y-muy)/sigmay)**2)
    Z=np.exp(expont)/(2*np.pi*sigmax*sigmay)
    Z=Z/np.sum(Z) #归一化
    print(Z)
    [[0.00048091 0.00501119 0.01094545 0.00501119 0.00048091]  
    [0.00501119 0.0522178  0.11405416 0.0522178  0.00501119]  
    [0.01094545 0.11405416 0.2491172  0.11405416 0.01094545]  
    [0.00501119 0.0522178  0.11405416 0.0522178  0.00501119]  
    [0.00048091 0.00501119 0.01094545 0.00501119 0.00048091]]

    从这个5×5大小的矩阵也能看到,位于正中心的点取值为0.2491172是最大值的点,紧邻着正中心距离为1的周围4个点的值0.11405416是第2大的点,依次越往外取值越小。

    GaussianBlur()的接口形式:

    dst=cv2.GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]])
    • 参数含义:
    • src:通道数任意,实际处理是分通道处理;图像深度只能是CV_8U, CV_16U, CV_16S, CV_32F or CV_64F;
    • ksize:元组类型,窗口大小,宽度和高度可以不一样,但是必须是正的奇数;如果设置为0,则根据sigma计算得到。
    • sigmaX:图像X方向的标准差,对应前述二维高斯分布的σ1;
    • sigmaY:图像Y方向的标准差,对应前述二维高斯分布的σ2,如果传入0,会等于sigmaX,如果sigmaX和sigmaY都传入0,sigmaX和sigmaX则根据ksize计算;
    • borderType:边界处理方式;

    注意:GaussianBlur的首字母是大写的G,和其他大多数OpenCV函数名称采用小驼峰命名风格稍有差异。

    因为都是以滑动窗口中心点为原点,为了保证中心点(x,y)=(0,0)的权重为最大值,所以在OpenCV的高斯平滑中μ1和μ2都设置为0,这样在调用高斯平滑函数时只需要传入σ1(sigmaX)和σ2(sigmaY)。

    下面是用不同的ksize进行高斯平滑的例子:

    import matplotlib.pyplot as plt 
    import cv2
    
    print('VX公众号: 桔子code / juzicode.com')
    print('cv2.__version__:',cv2.__version__)
    plt.rc('font',family='Youyuan',size='9')
    
    img = cv2.imread('..\\lena.jpg')
    img_ret1 = cv2.GaussianBlur(img,(3,3),0)
    img_ret2 = cv2.GaussianBlur(img,(5,5),0)
    img_ret3 = cv2.GaussianBlur(img,(11,11),0)
    
    #显示图像
    fig,ax = plt.subplots(2,2)
    ax[0,0].set_title('VX:桔子code  原图')
    ax[0,0].imshow(cv2.cvtColor(img,cv2.COLOR_BGR2RGB)) #matplotlib显示图像为rgb格式
    ax[0,1].set_title('GaussianBlur ksize=3')
    ax[0,1].imshow(cv2.cvtColor(img_ret1,cv2.COLOR_BGR2RGB))
    ax[1,0].set_title('GaussianBlur ksize=5')
    ax[1,0].imshow(cv2.cvtColor(img_ret2,cv2.COLOR_BGR2RGB))
    ax[1,1].set_title('GaussianBlur ksize=11') 
    ax[1,1].imshow(cv2.cvtColor(img_ret3,cv2.COLOR_BGR2RGB))
    ax[0,0].axis('off');ax[0,1].axis('off');ax[1,0].axis('off');ax[1,1].axis('off')#关闭坐标轴显示
    plt.show() 

    从运行结果看,ksize越大,图像越模糊。

    下面是ksize保持不变,sigmaX变化的例子(sigmaY不传入默认等于sigmaX):

    
    import matplotlib.pyplot as plt 
    import cv2
    
    print('VX公众号: 桔子code / juzicode.com')
    print('cv2.__version__:',cv2.__version__)
    plt.rc('font',family='Youyuan',size='9')
    
    img = cv2.imread('..\\lena.jpg')
    img_ret1 = cv2.GaussianBlur(img,(5,5),0.5)
    img_ret2 = cv2.GaussianBlur(img,(5,5),10)
    img_ret3 = cv2.GaussianBlur(img,(5,5),25)
    
    #显示图像
    fig,ax = plt.subplots(2,2)
    ax[0,0].set_title('VX:桔子code  原图')
    ax[0,0].imshow(cv2.cvtColor(img,cv2.COLOR_BGR2RGB)) #matplotlib显示图像为rgb格式
    ax[0,1].set_title('GaussianBlur ksize=5 sigma=0.5')
    ax[0,1].imshow(cv2.cvtColor(img_ret1,cv2.COLOR_BGR2RGB))
    ax[1,0].set_title('GaussianBlur ksize=5 sigma=10')
    ax[1,0].imshow(cv2.cvtColor(img_ret2,cv2.COLOR_BGR2RGB))
    ax[1,1].set_title('GaussianBlur ksize=5 sigma=25') 
    ax[1,1].imshow(cv2.cvtColor(img_ret3,cv2.COLOR_BGR2RGB))
    ax[0,0].axis('off');ax[0,1].axis('off');ax[1,0].axis('off');ax[1,1].axis('off')#关闭坐标轴显示
    plt.show() 

    对应到高斯分布曲线的特性,当sigma越大时,原点的取值越小,周围点的取值更大,对应到图像上中心点的权重越低,周围点权重越高,所以sigma越大图像越模糊。

    2、双边平滑bilateralFilter()

    均值、中值、高斯平滑的去躁是一种“无差别攻击”,所有的像素都受到同一个加权系数的影响,所以在平滑过程中也会影响到图像的边沿(像素值突变的地方),接下来要介绍的双边滤波则可以在去除噪声的同时又能保持图像的边沿,也就是传说中的”去噪保边”。

    双边平滑使用的加权系数如下:

    第1个exp()函数是空间距离加权系数的简化,1)前面的1/2πσ1σ2系数没有了,因为该系数在σ1和σ2确定后最后归一化的时候是会被消除掉的;2)双边平滑x和y方向用的σ1=σ2,所以用一个σs代替;3)u值在高斯平滑中也一直设置为0,这里也直接去掉了。其中x和y分别表示邻域像素和中心点X和Y方向的距离。

    第2个exp()函数也是高斯函数,v(x0,y0)表示中心点的像素值,v(x,y)表示距离中心点距离为(x,y)的像素值,所以这部分的值就和像素差值有关。如果像素差值为0,这部分系数的值就为1,所以就等价于高斯平滑的系数;如果2个像素差值非常大,这个部分exp()系数就向0靠拢,最后的f(x,y)就向0靠拢,这时该像素值对中心点的影响就非常小。所以如果2个像素值差异非常大时,这时新生成图像的像素值就不会被这个差异极大的像素受影响,从而保持该差异,达到“保边”的效果。

    2个exp()函数就是双边平滑的“双边”的含义,它并不是指图像的X和Y(行、列)2个方向,而是指在像素差和空间距离的2个“边”。

    bilateralFilter()的接口形式:

    dst=cv2.bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]])
    • 参数含义:
    • src:8bit或浮点类型;1或3通道;
    • d:窗口大小,如果为非正数,根据sigmaSpace计算;d>5时速度会比较慢,当噪声比较严重时可以选择d>=9,但是此时不适合对时间敏感的处理;
    • sigmaColor:亮度差的sigma参数;
    • sigmaSpace:空间距离的sigma参数,同时作用于图像的X和Y(行、列)2个方向;
    • borderType:边界处理方式;

    在表示滑动窗口大小的参数里,高斯平滑的ksize参数是一个宽高可以不等的元组,但是双边平滑用的参数d是一个整型类型,这也决定了其滑动窗口宽高是相等的。另外d的大小在源码中是这样设置的:

        if( d <= 0 )
            radius = cvRound(sigma_space*1.5);
        else
            radius = d/2;
        radius = MAX(radius, 1);
        d = radius*2 + 1;

    如果d小于0,用sigma_space*1.5后取整得到半径,如果d大于0则先除以2得到半径radius,然后用半径radius和1比较取其中更大的值,最后乘以2加1,这样的得到的d可以保证是不小于3的奇数。

    sigmaColor和sigmaSpace参数比较小的时候(<10),平滑的效果不是很明显,当参数比较大或者多次平滑后的图像看起来会比较卡通化,详情可阅读:论如何把自己变成卡通人物(OpenCV制作卡通化头像)

    下面的是一个高斯平滑和双边平滑对比的例子,取相同的滑动窗口大小以及相同的sigma值,观察平滑后的差异,以及在平滑后取ksize=3计算sobel边沿:

    import matplotlib.pyplot as plt 
    import cv2
    print('VX公众号: 桔子code / juzicode.com')
    print('cv2.__version__:',cv2.__version__)
    plt.rc('font',family='Youyuan',size='9')
    
    img = cv2.imread('..\\samples\\picture\\streak.jpeg')  
    img_ret1 = cv2.GaussianBlur(img,(7,7),10)
    img_ret2 = cv2.bilateralFilter(img,7,10,10)
    img_ret3 = cv2.bilateralFilter(img,7,25,25)
    fig,ax = plt.subplots(2,2)
    ax[0,0].set_title('VX:桔子code  原图')
    ax[0,0].imshow(cv2.cvtColor(img,cv2.COLOR_BGR2RGB)) #matplotlib显示图像为rgb格式
    ax[0,1].set_title('GaussianBlur ksize=7 sigma=10')
    ax[0,1].imshow(cv2.cvtColor(img_ret1,cv2.COLOR_BGR2RGB))
    ax[1,0].set_title('bilateralFilter ksize=7 sigma=10')
    ax[1,0].imshow(cv2.cvtColor(img_ret2,cv2.COLOR_BGR2RGB))
    ax[1,1].set_title('bilateralFilter ksize=7 sigma=25') 
    ax[1,1].imshow(cv2.cvtColor(img_ret3,cv2.COLOR_BGR2RGB))
    ax[0,0].axis('off');ax[0,1].axis('off');ax[1,0].axis('off');ax[1,1].axis('off')#关闭坐标轴显示
     
    img_edge1=cv2.Sobel(img_ret1,cv2.CV_8U,1,0,ksize=3)
    img_edge2=cv2.Sobel(img_ret2,cv2.CV_8U,1,0,ksize=3)
    img_edge3=cv2.Sobel(img_ret3,cv2.CV_8U,1,0,ksize=3)
    fig2,ax2 = plt.subplots(2,2)
    ax2[0,0].set_title('VX:桔子code  原图')
    ax2[0,0].imshow(cv2.cvtColor(img,cv2.COLOR_BGR2RGB)) #matplotlib显示图像为rgb格式
    ax2[0,1].set_title('GaussianBlur ksize=7 sigma=10')
    ax2[0,1].imshow(cv2.cvtColor(img_edge1,cv2.COLOR_BGR2RGB))
    ax2[1,0].set_title('bilateralFilter ksize=7 sigma=10')
    ax2[1,0].imshow(cv2.cvtColor(img_edge2,cv2.COLOR_BGR2RGB))
    ax2[1,1].set_title('bilateralFilter ksize=7 sigma=25') 
    ax2[1,1].imshow(cv2.cvtColor(img_edge3,cv2.COLOR_BGR2RGB))
    ax2[0,0].axis('off');ax2[0,1].axis('off');ax2[1,0].axis('off');ax2[1,1].axis('off')#关闭坐标轴显示
    plt.show() 
    

    平滑后的对比:

    取sobel边沿对比:

    从运行结果可看到,在颜色突然变化的地方(边沿),高斯平滑只保留了一半左右的边界,而双边平滑几乎将所有的边界保留下来,而且高斯平滑的边界亮度平均值也没有双边平滑高。

    小结:高斯平滑对比均值和中值平滑其取值更符合“惯例”,在空间距离上距离越近的像素用来计算新像素的值其权重越大。均值平滑、中值平滑和高斯平滑会对整幅图像实现无差别的平滑,一个固定系数的滑动窗口作用于整个图像,所以平滑后的图像虽然处理掉了噪声,但是边沿部分也会被削弱。而双边平滑在高斯平滑使用的系数基础上乘以像素差值的高斯函数,和中心点像素差值越大整个系数值越小,最后就能达到去躁保边的效果。

    扩展阅读:

    1. OpenCV-Python教程
    2. 论如何把自己变成卡通人物
    3. 有了这款神器,什么吃灰文件都统统现形

    4. 一行代码深度定制你的专属二维码(amzqr)

    5. 编码: 一个隐藏了30多年的bug,Windows含蓄说过某通不行?

    展开全文
  • 精明的边缘检测包括高斯卷积,sobel 操作。除了图像读取之外,整个代码没有任何内置的 matlab 函数。必须根据图像和要提取的特征更改阈值。 请查看更新的高斯卷积文件,它比前一个更准确 请注意代码执行时间较短。...
  • 高斯平滑

    千次阅读 2015-03-23 16:47:11
    高斯平滑 Common Names: Gaussian smoothing 简述: 高斯平滑操作是一种2-D的卷积操作,应用于模糊图像中,去除细节和噪声。从这个意思上说,它类似于均值滤波器,但是使用的是不同的内核,表示高斯驼峰形状...
    

    高斯平滑

    Common Names: Gaussian smoothing

    简述:

    高斯平滑操作是一种2-D的卷积操作,应用于模糊图像中,去除细节和噪声。从这个意思上说,它类似于均值滤波器,但是使用的是不同的内核,表示高斯驼峰形状(钟形)。这个内核具有一些特殊的性质,具体说明如下:

    如何实现:

    一维高斯分布形式:

    Eqn:eqngaus1

    Eqn:eqnsigma是分布的标准偏差,我们也可以假设分布的均值为0,(即,它的中心位于线x = 0上)。图1可以说明其分布情况。

    Figure 1 1-D Gaussian distribution with mean 0 andEqn:eqnsigma=1

    在二维情况下,同向高斯公式(即圆对称)为:

    Eqn:eqngaus2

    分布情况如图2所示:


    Figure 2 2-D Gaussian distribution with mean (0,0) andEqn:eqnsigma=1

    高斯平滑的思想就是使用2维分布作为点扩展函数,可以通过卷积实现。因为图像存储为离散像素的集合,因此,在执行卷积之前,需要把高斯函数进行离散近似。理论上,高斯分布在任何地方都是非零的,这需要无限大的卷积核,实际中,0值比平均的三个标准差更为有效,所以在这一点上我们可以缩短内核。图3示出了一个合适的整数值卷积核,近似于Eqn:eqnsigma=1.0 时的高斯分布。这并不能明显的表示如何挑选近似高斯分布表面值。唯一可以用到的是高斯表面中央像素值,但是,这是不精确的,因为像素值对于高斯变化是非线性的。整合所有像素上的高斯值(求和高斯在0.001增量) 。积分不是整体:重新调整数组的值,使角点的取值为1。最终,表面上所有点的像素值的和为273.

    Figure 3 Discrete approximation to Gaussian function withEqn:eqnsigma=1.0

    一旦计算出合适的核,高斯平滑可以利用标准的卷积方法实现。事实上,卷积可以快速的实现,2维同向高斯公式如上面显示,可以分为x和y方向上的分量。2维卷积可以首先通过x方向上求卷积,然后在y方向上求卷积执行得到。(事实上,高斯平滑就是完整的园对称操作按同样的方式进行分解。)图4示出了一维x分量内核,图可以生成如图3所示的完整的内核。


    Gaussian Smoothing

    Common Names: Gaussian smoothing

    Brief Description

    The Gaussian smoothing operator is a 2-D convolution operator that is used to `blur' images andremove detail and noise. In this sense it is similar to themean filter, but it uses a differentkernel that represents the shape of a Gaussian (`bell-shaped') hump. This kernel has some special properties which are detailed below.

    How It Works

    The Gaussian distribution in 1-D has the form:

    Eqn:eqngaus1

    where Eqn:eqnsigma is the standard deviation of the distribution. We have also assumed that the distribution has a mean of zero (i.e. it is centered on the line x=0). The distribution is illustrated in Figure 1.




    Figure 1 1-D Gaussian distribution with mean 0 and Eqn:eqnsigma=1


    In 2-D, an isotropic (i.e. circularly symmetric) Gaussian has the form:

    Eqn:eqngaus2

    This distribution is shown in Figure 2.




    Figure 2 2-D Gaussian distribution with mean (0,0) and Eqn:eqnsigma=1


    The idea of Gaussian smoothing is to use this 2-D distribution as a `point-spread' function, and this is achieved by convolution. Since the image is stored as a collection of discrete pixels we need to produce a discrete approximation to the Gaussian function before we can perform the convolution. In theory, the Gaussian distribution is non-zero everywhere, which would require an infinitely large convolution kernel, but in practice it is effectively zero more than about three standard deviations from the mean, and so we can truncate the kernel at this point. Figure 3 shows a suitable integer-valued convolution kernel that approximates a Gaussian with aEqn:eqnsigma of 1.0. It is not obvious how to pick the values of the mask to approximate a Gaussian. One could use the value of the Gaussian at the centre of a pixel in the mask, but this is not accurate because the value of the Gaussian varies non-linearly across the pixel. We integrated the value of the Gaussian over the whole pixel (by summing the Gaussian at 0.001 increments). The integrals are not integers: we rescaled the array so that the corners had the value 1. Finally, the 273 is the sum of all the values in the mask.




    Figure 3 Discrete approximation to Gaussian function with Eqn:eqnsigma=1.0


    Once a suitable kernel has been calculated, then the Gaussian smoothing can be performed using standardconvolution methods. The convolution can in fact be performed fairly quickly since the equation for the 2-D isotropic Gaussian shown above is separable intox andy components. Thus the 2-D convolution can be performed by first convolving with a 1-D Gaussian in thex direction, and then convolving with another 1-D Gaussian in they direction. (The Gaussian is in fact theonly completely circularly symmetric operator which can be decomposed in such a way.) Figure 4 shows the 1-Dx component kernel that would be used to produce the full kernel shown in Figure 3 (after scaling by 273, rounding and truncating one row of pixels around the boundary because they mostly have the value 0. This reduces the 7x7 matrix to the 5x5 shown above.). They component is exactly the same but is oriented vertically.




    Figure 4 One of the pair of 1-D convolution kernels used to calculate the full kernel shown in Figure 3 more quickly.


    A further way to compute a Gaussian smoothing with a large standard deviation is to convolve an image several times with a smaller Gaussian. While this is computationally complex, it can have applicability if the processing is carried out using a hardware pipeline.

    The Gaussian filter not only has utility in engineering applications. It is also attracting attention from computational biologists because it has been attributed with some amount of biological plausibility,e.g. some cells in the visual pathways of the brain often have an approximately Gaussian response.

    Guidelines for Use

    The effect of Gaussian smoothing is to blur an image, in a similar fashion to themean filter. The degree of smoothing is determined by the standard deviation of the Gaussian. (Larger standard deviation Gaussians, of course, require larger convolution kernels in order to be accurately represented.)

    The Gaussian outputs a `weighted average' of each pixel's neighborhood, with the average weighted more towards the value of the central pixels. This is in contrast to the mean filter's uniformly weighted average. Because of this, a Gaussian provides gentler smoothing and preserves edges better than a similarly sized mean filter.

    One of the principle justifications for using the Gaussian as a smoothing filter is due to itsfrequency response. Most convolution-based smoothing filters act aslowpass frequency filters. This means that their effect is to remove high spatial frequency components from an image. The frequency response of a convolution filter,i.e. its effect on different spatial frequencies, can be seen by taking theFourier transform of the filter. Figure 5 shows the frequency responses of a 1-D mean filter with width 5 and also of a Gaussian filter withEqn:eqnsigma = 3.




    Figure 5 Frequency responses of Box ( i.e. mean) filter (width 5 pixels) and Gaussian filter ( Eqn:eqnsigma = 3 pixels). The spatial frequency axis is marked in cycles per pixel, and hence no value above 0.5 has a real meaning.


    Both filters attenuate high frequencies more than low frequencies, but the mean filter exhibits oscillations in its frequency response. The Gaussian on the other hand shows no oscillations. In fact, the shape of the frequency response curve is itself (half a) Gaussian. So by choosing an appropriately sized Gaussian filter we can be fairly confident about what range of spatial frequencies are still present in the image after filtering, which is not the case of the mean filter. This has consequences for some edge detection techniques, as mentioned in the section on zero crossings. (The Gaussian filter also turns out to be very similar to the optimal smoothing filter for edge detection under the criteria used to derive the Canny edge detector.)

    We use

    ben2

    to illustrate the effect of smoothing with successively larger and larger Gaussian filters.

    The image

    ben2gau1

    shows the effect of filtering with a Gaussian of Eqn:eqnsigma = 1.0 (and kernel size 5×5).

    The image

    ben2gau2

    shows the effect of filtering with a Gaussian of Eqn:eqnsigma = 2.0 (and kernel size 9×9).

    The image

    ben2gau3

    shows the effect of filtering with a Gaussian of Eqn:eqnsigma = 4.0 (and kernel size 15×15).

    We now consider using the Gaussian filter for noise reduction. For example, consider the image

    fce5noi4

    which has been corrupted by Gaussian noise with a mean of zero and Eqn:eqnsigma = 8. Smoothing this with a 5×5 Gaussian yields

    fce5gsm1

    (Compare this result with that achieved by the mean and median filters.)

    Salt and pepper noise is more challenging for a Gaussian filter. Here we will smooth the image

    sta2noi2

    which has been corrupted by 1% salt and pepper noise (i.e. individual bits have been flipped with probability 1%). The image

    sta2gsm1

    shows the result of Gaussian smoothing (using the same convolution as above). Compare this with the original

    sta2

    Notice that much of the noise still exists and that, although it has decreased in magnitude somewhat, it has been smeared out over a larger spatial region. Increasing the standard deviation continues to reduce/blur the intensity of the noise, but also attenuates high frequency detail (e.g. edges) significantly, as shown in

    sta2gsm2

    This type of noise is better reduced using median filtering, conservative smoothing or Crimmins Speckle Removal.

    Interactive Experimentation

    You can interactively experiment with this operator by clicking here.

    Exercises

    1. Starting from the Gaussian noise (mean 0, Eqn:eqnsigma = 13) corrupted image
      fce5noi5

      compute both mean filter and Gaussian filter smoothing at various scales, and compare each in terms of noise removal vs loss of detail.

    2. At how many standard deviations from the mean does a Gaussian fall to 5% of its peak value? On the basis of this suggest a suitable square kernel size for a Gaussian filter withEqn:eqnsigma =s.

    3. Estimate the frequency response for a Gaussian filter by Gaussian smoothing an image, and taking itsFourier transform both before and afterwards. Compare this with the frequency response of amean filter.

    4. How does the time taken to smooth with a Gaussian filter compare with the time taken to smooth with amean filterfor a kernel of the same size? Notice that in both cases the convolution can be speeded up considerably by exploiting certain features of the kernel.

    References

    E. Davies Machine Vision: Theory, Algorithms and Practicalities, Academic Press, 1990, pp 42 - 44.

    R. Gonzalez and R. Woods Digital Image Processing, Addison-Wesley Publishing Company, 1992, p 191.

    R. Haralick and L. Shapiro Computer and Robot Vision, Addison-Wesley Publishing Company, 1992, Vol. 1, Chap. 7.

    B. Horn Robot Vision, MIT Press, 1986, Chap. 8.

    D. Vernon Machine Vision, Prentice-Hall, 1991, pp 59 - 61, 214.

    Local Information

    Specific information about this operator may be found here.

    More general advice about the local HIPR installation is available in the Local Information introductory section.

    
    展开全文
  • 1.高斯平滑 (1)高斯卷积核的构建 假设构造宽(列数)为、高(行数)为的高斯卷积算子,其中和均为奇数,锚点的位置在,步骤如下: 第一步:计算高斯矩阵。 其中 r,c代表位置索引,其中,,且r,c均为...

    1.高斯平滑

    (1)高斯卷积核的构建

    假设构造宽(列数)为W、高(行数)为H的高斯卷积算子\mathbf{gaussKernel}_{H\times W}其中WH均为奇数,锚点的位置在(\frac{H-1}{2},\frac{W-1}{2}),步骤如下:

    第一步:计算高斯矩阵。

                  \mathbf{gaussMatrix}_{H\times W}=\begin{bmatrix} gauss(r,c,\sigma ) \end{bmatrix}_{0\leqslant r\leqslant H-1, 0\leqslant c\leqslant W-1,r,c\in N }

                  其中        gauss(r,c,\sigma )= \frac{1}{2\pi\sigma^2}e^{-\frac{(r-\frac{H-1}{2})^2+(c-\frac{W-1}{2})^2}{2\sigma^2}}

                  r,c代表位置索引,其中0\leqslant r\leqslant H-10\leqslant c\leqslant W-1,且r,c均为整数。

    第二步:计算高斯矩阵的和。

                 sum(\mathbf{gaussMatrix}_{H\times W})

    第三步:高斯矩阵除以其本身的和,即归一化,得到的便是高斯卷积算子。

                  \mathbf{gaussKernel}_{H\times W} = \mathbf{gaussMatrix}/sum( \mathbf{gaussMatrix})

    利用以上三个步骤构建高斯卷积算子的Python实现代码如下:

    def getGaussKernel(sigma, H, W):
        # 第一步:构建高斯矩阵
        gaussMatrix = np.zeros([H, W], np.float32)
        # 得到中心点的位置
        cH = (H - 1) / 2
        cW = (W - 1) / 2
        # 计算gauss(sigma, r, c)
        for r in range(H):
            for c in range(W):
                norm2 = math.pow(r - cH, 2) + math.pow(c - cH, 2)
                gaussMatrix[r][c] = math.exp(-norm2 / (2 * math.pow(sigma, 2)))
        # 第二步:计算高斯矩阵的和
        sumGM = np.sum(gaussMatrix)
        # 第三步:归一化
        gaussKernel = gaussMatrix / sumGM
        return gaussKernel

    因为最后要归一化,所以在代码实现中可以去掉高斯函数中的系数\frac{1}{2\pi \sigma^2}。高斯卷积算子翻转180^{\circ}和本身是相同的。

    高斯卷积算子是可分离卷积核,因为e^{-\frac{(r-\frac{H-1}{2})^2+(c-\frac{W-1}{2})^2}{2\sigma^2}}=e^{-\frac{(r-\frac{H-1}{2})^2}{2\sigma^2}}\ast e^{-\frac{(c-\frac{W-1}{2})^2}{2\sigma^2}},所以高斯卷积核可分离成一维水平方向上的高斯核和一维垂直方向上的高斯核,或者反过来,即:

    \mathbf{gaussKernel}_{H\times W} = \mathbf{gaussKernel}_{1\times W} \bigstar \mathbf{gaussKernel}_{H\times 1}=\mathbf{gaussKernel}_{H\times 1} \bigstar \mathbf{gaussKernel}_{1\times W}

    基于这种分离性,OpenCV只给出了构建一维垂直方向上的高斯卷积核的函数:

    retval=cv.getGaussianKernel(ksize, sigma[, ktype])

    参数解释
    ksize一维垂直方向上高斯核的行数,而且是正奇数
    sigma标准差
    ktype返回值的数值类型为CV_32F或CV_64F,默认是CV_64F

    返回值就是一个ksize\times 1的垂直方向上的高斯核,而对于一维水平方向上的高斯核,只需对垂直方向上的高斯核进行转置就可以了。

    import cv2 as cv
    from scipy import signal
    # 垂直方向上的卷积核
    gk_y = cv.getGaussianKernel(5, 2, cv.CV_64F)
    # 水平方向上的卷积核
    gk_x = gk_y.T
    print(gk_x)
    print(gk_y)
    # 高斯卷积核
    gk = signal.convolve2d(gk_y, gk_x, mode="full")
    print(gk)
    '''
    [[ 0.15246914  0.2218413   0.25137912  0.2218413   0.15246914]]
    [[ 0.15246914]
     [ 0.2218413 ]
     [ 0.25137912]
     [ 0.2218413 ]
     [ 0.15246914]]
    [[ 0.02324684  0.03382395  0.03832756  0.03382395  0.02324684]
     [ 0.03382395  0.04921356  0.05576627  0.04921356  0.03382395]
     [ 0.03832756  0.05576627  0.06319146  0.05576627  0.03832756]
     [ 0.03382395  0.04921356  0.05576627  0.04921356  0.03382395]
     [ 0.02324684  0.03382395  0.03832756  0.03382395  0.02324684]]
    '''
    

    (2)Python实现

    def gaussBlur(img, sigma, H, W, _boundary='fill', _fillvalue=0):
        # 构建水平方向上的高斯卷积核
        gaussKernel_x = cv.getGaussianKernel(W, sigma, cv.CV_64F)
        # 转置
        gaussKernel_x = np.transpose(gaussKernel_x)
        # 图像矩阵与水平高斯核卷积
        gaussBlur_x = signal.convolve2d(img, gaussKernel_x, mode="same",
                                        boundary=_boundary, fillvalue=_fillvalue)
        # 构建垂直方向上的高斯卷积核
        gaussKernel_y = cv.getGaussianKernel(H, sigma, cv.CV_64F)
        # 与垂直方向上的高斯卷核
        gaussBlur_xy = signal.convolve2d(gaussBlur_x, gaussKernel_y, mode="same",
                                         boundary=_boundary, fillvalue=_fillvalue)
        return gaussBlur_xy
    
    img = cv.imread("../testImages/5/img3.jpg", 0)
    cv.imshow("img", img)
    # 高斯平滑(使用自己的函数)
    blurImg = gaussBlur(img, 2, 9, 9, "symm")
    # 对blurImg进行灰度级显示
    blurImg = np.round(blurImg)
    blurImg = blurImg.astype(np.uint8)
    # 高斯平滑(使用OpenCv提供的函数)
    blurImg2 = cv.GaussianBlur(img, (9, 9), 2)
    cv.imshow("blur", blurImg)
    cv.imshow("blur2", blurImg2)
    cv.waitKey()

    上述示例使用了OpenCV提供的高斯平滑函数,下面来看看OpenCV提供的高斯平滑函数:

    dst=cv.GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]])

    参数解释
    src输入矩阵
    dst输出矩阵,大小和数据类型与src相同
    ksize高斯卷积核的大小,宽、高均为奇数,且可以不同
    sigmaX一维水平方向高斯卷积核的标准差
    sigmaY一维垂直方向高斯卷积核的标准差,默认值为0,表示与sigmaX相同
    borderType边界扩充方式

    从参数的设置可以看出,GaussianBlur也是通过分离的高斯卷积核实现的,也可以令水平方向和垂直方向上的标准差不同,但是一般会取相同的标准差。当平滑窗口比较小时,对标准差的变化不是很敏感,得到的高斯平滑效果差别不大;相反,当平滑窗口较大时,对标准差的变化很敏感,得到的高斯平滑效果差别较大。

    下图显示了使用不同尺寸标准差的高斯核对图(a)进行高斯平滑的结果,随着卷积核尺寸和标准差的增大,平滑效果越来越明显,图像变得越来越模糊,只能显示大概的轮廓。

    (a)原图                             (b)9x9,sigma=2                           (c)11x11,sigma=3                             (d)25x25,sigma=9

    2.均值平滑

    (1)均值卷积核的构建

    高为H、宽为W的均值卷积算子的构建方法很简单,令所有元素均为\frac{1}{W*H}即可,记:

                                                       \mathbf{meanKernel}_{H\times W}=\frac{1}{H*W}\begin{bmatrix} 1 \end{bmatrix}_{H\times W}

    其中WH均为奇数,锚点的位置在(\frac{H-1}{2},\frac{W-1}{2})

    均值平滑算子是可分离卷积核,即:

    \mathbf{meanKernel}_{H\times W} = \mathbf{meanKernel}_{1\times W} \bigstar \mathbf{meanKernel}_{H\times 1}=\mathbf{meanKernel}_{H\times 1} \bigstar \mathbf{meanKernel}_{1\times W}

    均值平滑,图像中每一个位置的邻域的平均值作为该位置的输出值,代码实现与分离的高斯卷积是类似的,只需将高斯算子替换成均值算子即可。利用卷积核的分离性和卷积的结合律,虽然减少了运算量,但是随着卷积核窗口的增加,计算量仍会继续增大,可以利用图像的积分,实现时间复杂度为O(1)的快速均值平滑。

    (2)快速均值平滑

    先来介绍一下图像的积分,RC列的图像矩阵I的积分Integral由以下定义计算:

    Integral(r,c)=\sum_{r}^{i=0} \sum_{c}^{j=0}I(r,c),0\leqslant r<R, 0\leqslant c<C

    即任意一个位置的积分等于该位置左上角所有值的和。举例如下图:

    利用矩阵的积分可以计算出矩阵中任意矩形区域的和:

                        \small \sum_{r=rTop}^{rBottom} \sum_{c=cLeft}^{cRight}=\mathbf{Integral}(rBottom,cRight)+\mathbf{Integral}(rTop-1,cLeft-1)

                                              \small -\mathbf{Integral}(rBottom,cLeft-1)-\mathbf{Integral}(rTop-1,cRight)

    举例:计算\small I的以\small (2,2)为中心,从左上角\small (rTop,cLeft)=(1,1)至右下角\small (rBottom,cRight)=(3,3)的矩形区域的和:

    可以从积分后的图像矩阵中找到对应的值计算:

                     \small \sum_{r=1}^{3} \sum_{c=1}^{3}=\mathbf{Integral}(3,3)+\mathbf{Integral}(0,0)- \mathbf{Integral}(3,0)-\mathbf{Integral}(0,3)

               即:\small 5+1+7+1+5+9+2+6+2=54+1-9-8

           均值平滑的原理本质上是计算任意一个点的邻域的平均值,而平均值是由该邻域的和除以邻域的面积得到的。这样无论怎样改变平滑窗口的大小,都可以利用图像的积分快速计算每个邻域的和。接下来利用图像的积分实现图像的均值平滑。

    (3)Python实现

           对于图像的积分的实现,可以分两步完成:先对图像矩阵按行积分,然后在按列积分;或者反过来,先列积分后行积分。为了在快速均值平滑中省去判断边界的问题,所以对积分后图像矩阵的上边和左边进行补零操作,尺寸为\small (R+1)\times (C+1),代码如下:

    def integral(img):
        rows, cols = img.shape
        # 行积分运算
        inteImageC = np.zeros(img.shape, np.float32)
        for r in range(rows):
            for c in range(cols):
                if c == 0:
                    inteImageC[r][c] = img[r][c]
                else:
                    inteImageC[r][c] = inteImageC[r][c - 1] + img[r][c]
        # 列积分计算
        inteImage = np.zeros(img.shape, np.float32)
        for c in range(cols):
            for r in range(rows):
                if r == 0:
                    inteImage[r][c] = inteImageC[r][c]
                else:
                    inteImage[r][c] = inteImage[r - 1][c] + inteImageC[r][c]
        # 上边和左边进行补零
        inteImage_0 = np.zeros((rows + 1, cols + 1), np.float32)
        inteImage_0[1:rows + 1, 1:cols + 1] = inteImage
        return inteImage_0
    

    对于积分,OpenCV也提供了计算的函数

    integral()

    
    void cv::integral ( InputArray   src,
    		    OutputArray  sum,
    		    OutputArray  sqsum,
    		    OutputArray  tilted,
    		    int  	 sdepth = -1,
    		    int  	 sqdepth = -1 
    	            ) 		
    //Python:
    sum                = cv.integral(src[, sum[, sdepth]])
    sum, sqsum         = cv.integral2(src[, sum[, sqsum[, sdepth[, sqdepth]]]])
    sum, sqsum, tilted = cv.integral3(src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]])

    实现了图像的积分后,来实现均值平滑,如果在图像的边界进行的是补零操作,那么随着窗口的增大,平滑后黑色边界会越来越明显, 所以在进行均值平滑处理时,比较理想的边界扩充类型是镜像扩充。代码如下:

    def fastMeanBlur(img, winSize, borderType=cv.BORDER_DEFAULT):
        halfH = int((winSize[0] - 1) / 2)
        halfW = int((winSize[1] - 1) / 2)
        ratio = 1.0 / (winSize[0] * winSize[1])
        # 边界扩充
        paddImage = cv.copyMakeBorder(img, halfH, halfH, halfW, halfW, borderType)
        # 图像积分
        paddIntegral = integral(paddImage)
        # 图像的高、宽
        rows, cols = img.shape
        # 均值滤波后的结果
        meanBlurImage = np.zeros(img.shape, np.float32)
        r, c = 0, 0
        for h in range(halfH, halfH + rows, 1):
            for w in range(halfW, halfW + cols, 1):
                meanBlurImage[r][c] = (paddIntegral[h + halfH + 1][w + halfW + 1] +
                                       paddIntegral[h - halfH][w - halfW] -
                                       paddIntegral[h + halfH + 1][w - halfW] -
                                       paddIntegral[h - halfH][w + halfW + 1]) * ratio
                c += 1
            r += 1
            c = 0
        return meanBlurImage
    img = cv.imread("../testImages/5/img2.png", 0)
    cv.imshow("img", img)
    # 使用自己的函数
    blur = fastMeanBlur(img, (5, 5))
    blur = np.round(blur)
    blur = blur.astype(np.uint8)
    # # 使用OpenCV提供的函数
    # blur2 = cv.blur(img, (5, 5))
    cv.imshow("blur", blur)
    # cv.imshow("blur2", blur2)
    cv.waitKey()
    
    

    函数fastMeanBlur返回的结果是浮点型,如果输入的是8位图,则需要使用astype(numpu.uint8)将结果转换为8位图。下图显示的是不同尺寸的均值平滑算子对图(a)平滑的效果,显然随着均值平滑算子窗口的增大,处理细节部分越来越不明显,只是显示了大概轮廓。

    (a)原图                          (b)5x5均值平滑                       (c)7x7均值平滑                     (d)11x11均值平滑

           对于快速均值平滑,OpenCV提供了boxFilter和blur两个函数来实现该功能,而且这两个函数均可以处理多通道图像矩阵,本质上是对图像的每一个通道分别进行均值平滑。

    dst = cv.boxFilter(src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]])

    参数解释
    src输入矩阵
    dst输出矩阵,其大小和数据类型与src相同
    ddepth位深
    ksize平滑窗口的尺寸
    normalize是否归一化

    dst=cv.blur(src, ksize[, dst[, anchor[, borderType]]])

    参数解释
    src输入矩阵
    dst输出矩阵,其大小和数据类型与src相同
    ksize均值算子的尺寸,Size(宽,高)
    anchor锚点,如果高、宽为奇数,则Point(-1,-1)表示中心点
    borderType边界扩充方式

    显然,函数  boxFilter(src, src.dtype(), ksize, anchor=Point(-1,-1), normalize=True, borderType=cv.BORDER_DEFAULT)  与函数blur的作用是一样的。示例如下:

    img = cv.imread("../testImages/5/img2.png", 0)
    cv.imshow("img", img)
    # 使用OpenCV提供的函数
    blur2 = cv.blur(img, (5, 5))
    cv.imshow("blur2", blur2)
    cv.waitKey()

     

    这篇文章主要了解了高斯平滑和均值平滑的原理以及他们各自使用的函数,都是基于卷积运算的图像平滑算法。

     

    展开全文
  • 高斯平滑操作是一个二维卷积操作,用于**“模糊”**图像,去除细节和噪音。它类似于均值滤波器(假如3X3,则全部相加取均值,即成为中间点的像素值),但它使用不同的核表示高斯驼峰的形状。 二维高斯公式 平均值(0...

    高斯平滑操作是一个二维卷积操作,用于**“模糊”**图像,去除细节和噪音。它类似于均值滤波器(假如3X3,则全部相加取均值,即成为中间点的像素值),但它使用不同的核表示高斯驼峰的形状。

    • 二维高斯公式
      在这里插入图片描述
    • 平均值(0,0) 和σ=1
      在这里插入图片描述
      高斯平滑的思想就是使用2维分布作为点扩展函数,可以通过卷积实现。因为图像存储为离散像素的集合,因此,在执行卷积之前,需要把高斯函数进行离散近似。理论上,高斯分布在任何地方都是非零的,这需要无限大的卷积核,实际中,0值比平均的三个标准差更为有效,所以在这一点上我们可以缩短内核。
      下图为一个整数值卷积核,近似于σ=1时的高斯分布。
      在这里插入图片描述
      一旦计算出合适的核,高斯平滑可以利用标准的卷积方法实现。事实上,卷积可以快速的实现,2维同向高斯公式如上面显示,可以分为x和y方向上的分量。2维卷积可以首先通过x方向上求卷积,然后在y方向上求卷积执行得到。(事实上,高斯平滑就是完整的园对称操作按同样的方式进行分解。)图4示出了一维x分量内核,图可以生成如图3所示的完整的内核
    展开全文
  • python 实现对三维点的高斯平滑(gaussion smooth), 主要是使用 Python中的 scipy.stats 这个统计函数。
  • 数字图像处理 利用C/C++实现图像的高斯平滑效果 并测试
  • C++: 1、构建垂直方向上的高斯卷积算子;...OpenCV实现的高斯平滑函数:GaussianBlur() #include <opencv2/opencv.hpp> #include <iostream> #include <cmath> using namespace std; using names...
  • 滤波是信号处理中的概念,指的是将信号中特定波段频率滤除的操作。在图像处理中,和通过傅里叶变化实现的频域下的滤波是等效的,所以也称为滤波。首先要学习的是空间域滤波,...最最简单的就是平滑模板,是下方公式...
  • 使用高斯平滑对图像进行平滑处理,把包导入,图片路径换了就可以运次,高斯平滑大概原理就是连续函数离散化,用二项分布去近似高斯函数,高斯核是可分离的所以就行和列分开卷积,图像多且大时,分开卷积可以降低时间...
  • 高斯平滑的思考

    千次阅读 2018-09-21 15:10:23
    最开始在学习数字图像处理的时候,遇到类如高斯平滑的问题,即使知道它是在频域上进行滤波,但还是习惯于从时域的角度思考问题。当现在因为考研而学习信号与系统时,我不禁重新审视起高斯函数为何能做到图像平滑这一...
  • 高斯平滑模版函数代码(matlab)

    千次阅读 2020-10-13 19:14:45
    高斯平滑模版函数(matlab代码) function result = Gaussian_mode(sigma) % f(x,y) = 1/(2*pi*sigma*sigma)*(1/exp((x*x+y*y)/(2*sigma*sigma))); function J = f(x,y) J = 1/(2*pi*sigma*sigma)*(1/exp((x*x+y*y)/...
  • (三)对图像进行Gauss高斯平滑处理

    千次阅读 2020-06-24 10:13:02
    对图像进行Gauss高斯平滑处理 高斯平滑处理(Gaussian Smoothing)后的图像虽然肉眼上看会模糊,但是图像处理时有去除高频噪声的功能。 图像平滑是局部图像预处理的一种技术。图像经过灰度化、二值处理之后,可能存在...
  • 在很多领域里,我们有时候都要对图像进行一定的光滑处理。而有的时候只需对图像的指定...另外本人最近有学习一点GPU的知识,于是将CPU下的高斯九点平滑进行了一定程度上的改写,在误差允许范围内,进行了一定的加速。
  • 精通系列\精通Visual C++数字图像处理技术与工程案例\chap01\高斯平滑处理.rar
  • 图像的高斯平滑

    2013-11-14 16:07:49
    这是一个基于OpenCV的图像的高斯平滑程序,分别显示原图和平滑后的图像,运行没问题
  • 一:高斯平滑  通过以上步骤我们写一个构建高斯卷积算子的代码 def getGaussKernel(sigma, H, W): # 第一步:构建高斯矩阵 gaussMatrix = np.zeros([H, W], np.float32) # 得到中心点的位置 cH = (H - ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,940
精华内容 11,976
关键字:

高斯平滑