目录

1、2D滤波器cv2.filter2D( )

2、均值滤波blur

3、方框滤波boxFilter

4、高斯模糊模板

5、中值滤波模板

6、双边滤波

7、联合双边滤波(未测试)

8、导向滤波

运用它，首先就要了解它，什么是平滑滤波？

      平滑滤波是低频增强的空间域滤波技术。它的目的有两类：一类是模糊；另一类是消除噪音。空间域的平滑滤波一般采用简单平均法进行，就是求邻近像元点的平均亮度值。邻域的大小与平滑的效果直接相关，邻域越大平滑的效果越好，但邻域过大，平滑会使边缘信息损失的越大，从而使输出的图像变得模糊，因此需合理选择邻域的大小。

在看一下滤波的目的：

滤波的本义是指信号有各种频率的成分,滤掉不想要的成分,即为滤掉常说的噪声,留下想要的成分.这即是滤波的过程,也是目的。


	
抽出对象的特征作为图像识别的特征模式；
	
	

	
为适应图像处理的要求，消除图像数字化时所混入的噪声。
	
1、2D滤波器cv2.filter2D( )

Opencv提供的一个通用的2D滤波函数为cv2.filter2D()，滤波函数的使用需要一个核模板，对图像的滤波操作过程为：将和模板放在图像的一个像素A上，求与之对应的图像上的每个像素点的和，核不同，得到的结果不同，而滤波的使用核心也是对于这个核模板的使用，需要注意的是，该滤波函数是单通道运算的，也就是说对于彩色图像的滤波，需要将彩色图像的各个通道提取出来，对各个通道分别滤波才行。

对于2D图像可以进行低通或者高通滤波操作

　　　　低通滤波（LPF）：有利于去噪，模糊图像

　　　　高通滤波（HPF）：有利于找到图像边界

使用自定义内核对图像进行卷积。该功能将任意线性滤波器应用于图像。支持就地操作。当光圈部分位于图像外部时，该功能会根据指定的边框模式插入异常像素值。

cv2.filter2D(src,dst,ddepth,kernel,anchor=(-1,-1),delta=0,borderType=cv2.BORDER_DEFAULT)
        src: 输入图像对象矩阵
        dst:输出图像矩阵
        ddepth:输出矩阵的数值类型
        kernel:卷积核
        anchor：卷积核锚点，默认(-1,-1)表示卷积核的中心位置
        delat:卷积完后相加的常数
        borderType:填充边界类型

参数：

参数
			
描述
		
src
			
原图像
		
dst
			
目标图像，与原图像尺寸和通过数相同
		
ddepth
			
输出图像深度（通道数），-1表示和原图像一致
		
kernel
			
卷积核（或相当于相关核），单通道浮点矩阵;如果要将不同的内核应用于不同的通道，请使用拆分将图像拆分为单独的颜色平面，然后单独处理它们。
		
anchor
			
内核的锚点，指示内核中过滤点的相对位置;锚应位于内核中;默认值（-1，-1）表示锚位于内核中心。
		
detal
			
在将它们存储在dst中之前，将可选值添加到已过滤的像素中。类似于偏置。
		
borderType
			
像素外推法，参见BorderTypes
		
# encoding: utf-8

import cv2
import matplotlib.pyplot as plt
import math
import copy
import numpy as np


path = r"lena.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
gray1 = np.float32(gray) #转化数值类型

kernel = np.ones((5,5),np.float32)/25
dst = cv2.filter2D(gray,-1,kernel)
#cv2.filter2D(src,dst,kernel,auchor=(-1,-1))函数：
#输出图像与输入图像大小相同
#中间的数为-1，输出数值格式的相同plt.figure()

plt.subplot(1,2,1),plt.imshow(gray1,'gray')#默认彩色，另一种彩色bgr
plt.subplot(1,2,2),plt.imshow(dst,'gray')
plt.show()




2、均值滤波blur

OpenCV中有一个专门的平均滤波模板供使用------归一化卷积模板，所有的滤波模板都是使卷积框覆盖区域所有像素点与模板相乘后得到的值作为中心像素的值。OpenCV中均值模板可以用 cv2.blur 和 cv2.boxFilter ,比如一个3*3的模板其实就可以如下表示；



模板大小m*n是可以设置的。如果不想要前面的1/9，可以使用非归一化模板cv2.boxFitter。

cv2.blur(src,ksize,dst,anchor,borderType)
        src: 输入图像对象矩阵,可以为单通道或多通道
        ksize:高斯卷积核的大小，格式为(宽，高)
        dst:输出图像矩阵,大小和数据类型都与src相同
        anchor：卷积核锚点，默认(-1,-1)表示卷积核的中心位置
        borderType:填充边界类型

 

# encoding: utf-8

import cv2
import matplotlib.pyplot as plt
import math
import copy
import numpy as np


path = r"lena.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

blur = cv2.blur(gray,(10,10))

plt.figure()
plt.subplot(1,2,1),plt.imshow(gray,'gray')#默认彩色，指定为gray
plt.subplot(1,2,2),plt.imshow(blur,'gray')

plt.show()



3、方框滤波boxFilter

cv2.boxFilter(src,ddepth,ksize,dst,anchor,normalize,borderType)
        src: 输入图像对象矩阵,
        ddepth:输出图像深度（通道数），-1表示和原图像一致
        ksize:高斯卷积核的大小，格式为(宽，高)
        dst:输出图像矩阵,大小和数据类型都与src相同
        anchor：卷积核锚点，默认(-1,-1)表示卷积核的中心位置
        normalize:是否归一化 （若卷积核3*5，归一化卷积核需要除以15）
        borderType:填充边界类型

# encoding: utf-8

import cv2
import matplotlib.pyplot as plt
import math
import copy
import numpy as np

path = r"lena.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

box = cv2.boxFilter(gray,-1,(10,10),normalize=True)

plt.figure()
plt.subplot(1,2,1),plt.imshow(gray,'gray')#默认彩色，指定为gray
plt.subplot(1,2,2),plt.imshow(box,'gray')

plt.show()



4、高斯模糊模板

现在把卷积模板中的值换一下，不是全1了，换成一组符合高斯分布的数值放在模板里面，比如这时中间的数值最大，往两边走越来越小，构造一个小的高斯包。实现的函数为cv2.GaussianBlur()。

对于高斯模板，我们需要制定的是高斯核的高和宽（奇数），沿 x 与 y 方向的标准差(如果只给x，y=x，如果都给0，那么函数会自己计算)。高斯核可以有效的出去图像的高斯噪声。当然也可以自己构造高斯核

cv2.Guassianblur(img, (3, 3), 1) 表示进行高斯滤波， 

参数说明:

1表示σ， x表示与当前值得距离，计算出的G(x)表示权重值



卷积核大小是奇数

dst = cv2.GaussianBlur(src,ksize,sigmaX,sigmay,borderType)
        src: 输入图像矩阵,可为单通道或多通道，多通道时分别对每个通道进行卷积
        dst:输出图像矩阵,大小和数据类型都与src相同
        ksize:高斯卷积核的大小，宽，高都为奇数，且可以不相同
        sigmaX: 一维水平方向高斯卷积核的标准差
        sigmaY: 一维垂直方向高斯卷积核的标准差，默认值为0，表示与sigmaX相同
        borderType:填充边界类型

# encoding: utf-8

import cv2
import matplotlib.pyplot as plt
import math
import copy
import numpy as np

path = r"lena.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# 添加点噪声
for i in range(2000):  
    temp_x = np.random.randint(0, gray.shape[0])
    temp_y = np.random.randint(0, gray.shape[1])
    gray[temp_x][temp_y] = 255

gauss = cv2.GaussianBlur(gray,(5,5),0)
plt.figure()
plt.subplot(1,2,1),plt.imshow(gray,'gray')#默认彩色，指定为gray
plt.subplot(1,2,2),plt.imshow(gauss,'gray')

plt.show()


5、中值滤波模板

中值滤波模板就是用卷积框中像素的中值代替中心值，达到去噪声的目的。这个模板一般用于去除椒盐噪声。前面的滤波器都是用计算得到的一个新值来取代中心像素的值，而中值滤波是用中心像素周围（也可以使他本身）的值来取代他，卷积核的大小也是个奇数。

 cv2.medianBlur(src,ksize,dst)
        src: 输入图像对象矩阵,可以为单通道或多通道
        ksize:核的大小，格式为 3      #注意不是（3,3）
        dst:输出图像矩阵,大小和数据类型都与src相同

# encoding: utf-8

import cv2
import matplotlib.pyplot as plt
import math
import copy
import numpy as np

def show_img(name="test",img=None):
    plt.figure()
    plt.imshow(img)
    plt.title(name)
    plt.show()

path = r"lena.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# 添加点噪声
for i in range(2000):
    temp_x = np.random.randint(0, gray.shape[0])
    temp_y = np.random.randint(0, gray.shape[1])
    gray[temp_x][temp_y] = 255

medina = cv2.medianBlur(gray,5)
plt.figure()
plt.subplot(1,2,1),plt.imshow(gray,'gray')#默认彩色，指定为gray
plt.subplot(1,2,2),plt.imshow(medina,'gray')

plt.show()



6、双边滤波

相比于上面几种平滑算法，双边滤波在平滑的同时还能保持图像中物体的轮廓信息。

双边滤波在高斯平滑的基础上引入了灰度值相似性权重因子，所以在构建其卷积核核时，要同时考虑空间距离权重和灰度值相似性权重。在进行卷积时，每个位置的邻域内，根据和锚点的距离d构建距离权重模板，根据和锚点灰度值差异r构建灰度值权重模板，结合两个模板生成该位置的卷积核。

opencv中的bilateralFilter()函数实现了双边滤波，其参数对应如下：

dst = cv2.bilateralFilter(src,d,sigmaColor,sigmaSpace,borderType)
        src: 输入图像对象矩阵,可以为单通道或多通道
        d:用来计算卷积核的领域直径，如果d<=0，从sigmaSpace计算d
        sigmaColor：颜色空间滤波器标准偏差值，决定多少差值之内的像素会被计算（构建灰度值模板）
        sigmaSpace:坐标空间中滤波器标准偏差值。如果d>0，设置不起作用，否则根据它来计算d值（构建距离权重模板）

双边滤波函数后面的两个参数设置的越大，图像的去噪越多，但随之而来的是图像ji将变得模糊，所以根据需要调整好后两个参数的大小。

# encoding: utf-8

import cv2
import matplotlib.pyplot as plt
import math
import copy
import numpy as np

path = r"lena.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# 添加点噪声
for i in range(2000):
    temp_x = np.random.randint(0, gray.shape[0])
    temp_y = np.random.randint(0, gray.shape[1])
    gray[temp_x][temp_y] = 255
#9---滤波领域直径
#后面两个数字：空间高斯函数标准差，灰度值相似性标准差
bilater = cv2.bilateralFilter(gray,9,75,75)

plt.figure()
plt.subplot(1,2,1),plt.imshow(gray,'gray')#默认彩色，指定为gray
plt.subplot(1,2,2),plt.imshow(bilater,'gray')

plt.show()

7、联合双边滤波(未测试)

双边滤波是根据原图中不同位置灰度相似性来构建相似性权重模板，而联合滤波是先对原图进行高斯平滑，然后根据平滑后的图像灰度值差异建立相似性模板，再与距离权重模板相乘得到最终的卷积核，最后再对原图进行处理。所以相比于双边滤波，联合双边滤波只是建立灰度值相似性模板的方法不一样。

联合双边滤波作为边缘保留滤波算法时，进行joint的图片即为自身原图片，如果将joint换为其他引导图片，联合双边滤波算法还可以用来实现其他功能。opencv 2中不支持联合双边滤波，opencv 3中除了主模块，还引入了contrib，其中的ximgproc模块包括了联合双边滤波的算法。因此如果需要使用opencv的联合双边滤波，需要安装opencv-contrib-python包。

安装opencv主模块和contrib附加模块步骤：
　　pip uninstall opencv-python （如果已经安装opencv-python包，先卸载）
　　pip install opencv-contrib-python

联合双边滤波: cv2.xmingproc.jointBilateralFilter(), 其相关参数如下：

dst = cv2.xmingproc.jointBilateralFilter(joint,src,d,sigmaColor,sigmaSpace,borderType)
        joint: 进行联合滤波的导向图像，可以为单通道或多通道，保持边缘的滤波算法时常采用src
        src: 输入图像对象矩阵,可以为单通道或多通道
        d:用来计算卷积核的领域直径，如果d<0，从sigmaSpace计算d
        sigmaColor：颜色空间滤波器标准偏差值，决定多少差值之内的像素会被计算（构建灰度值模板）
        sigmaSpace:坐标空间中滤波器标准偏差值。如果d>0，设置不起作用，否则根据它来计算d值（构建距离权重模板）

下面是联合双边滤波的使用代码和效果：（采用src的高斯平滑图片作为joint）

#coding:utf-8
import cv2 as cv
import matplotlib.pyplot as plt
import numpy as np
import random
import math

src = cv.imread(r"C:\Users\Administrator\Desktop\timg.jpg")
joint  = cv.GaussianBlur(src,(7,7),1,0)
dst = cv.ximgproc.jointBilateralFilter(joint,src,33,2,0)
# dst = cv.ximgproc.jointBilateralFilter(src,src,33,2,0) #采用src作为joint

cv.imshow("img",src)
cv.imshow("joint",joint)
cv.imshow("dst",dst)
cv.waitKey(0)
cv.destroyAllWindows()

cv2.ximgproc.jointBilateralFilter()

8、导向滤波

导向滤波也是需要一张图片作为引导图片，来表明边缘，物体等信息，作为保持边缘滤波算法，可以采用自身作为导向图片。opencv 2中也暂不支持导向滤波, 同样在opencv-contrib-python包的ximgproc模块提供了导向滤波函。

导向滤波具体原理可以参考：https://blog.csdn.net/baimafujinji/article/details/74750283

opencv中导向滤波cv2.ximgproc.guidedFilter()的参数如下：

导向滤波
    cv2.ximgproc.guidedFilter(guide,src,radius,eps,dDepth)
        guide: 导向图片，单通道或三通道
        src: 输入图像对象矩阵,可以为单通道或多通道
        radius:用来计算卷积核的领域直径
        eps:规范化参数， eps的平方类似于双边滤波中的sigmaColor（颜色空间滤波器标准偏差值）
       (regularization term of Guided Filter. eps2 is similar to the sigma 
         in the color space into bilateralFilter.)
        dDepth: 输出图片的数据深度

#coding:utf-8
import cv2 as cv

src = cv.imread(r"C:\Users\Administrator\Desktop\timg.jpg")
dst = cv.ximgproc.guidedFilter(src,src,33,2,-1)
cv.imshow("img",src)
cv.imshow("dst",dst)
cv.waitKey(0)
cv.destroyAllWindows()

cv2.ximgproc.guidedFilter

 

图像平滑与滤波

运用它，首先就要了解它，什么是平滑滤波？

      平滑滤波是低频增强的空间域滤波技术。它的目的有两类：一类是模糊；另一类是消除噪音。空间域的平滑滤波一般采用简单平均法进行，就是求邻近像元点的平均亮度值。邻域的大小与平滑的效果直接相关，邻域越大平滑的效果越好，但邻域过大，平滑会使边缘信息损失的越大，从而使输出的图像变得模糊，因此需合理选择邻域的大小。

在看一下滤波的目的：

滤波的本义是指信号有各种频率的成分,滤掉不想要的成分,即为滤掉常说的噪声,留下想要的成分.这即是滤波的过程,也是目的。

 

一是抽出对象的特征作为图像识别的特征模式；（在我未来将要进行的一个项目中将会用的到）
	
另一个是为适应图像处理的要求，消除图像数字化时所混入的噪声。
有关平滑与滤波更多的介绍，可以查看百度词条：平滑与滤波

里面有对平滑与滤波详细的解释，我就不一 一介绍了，感谢词条的贡献者，感谢分享，非常感谢。

 

对于2D图像可以进行低通或者高通滤波操作，低通滤波（LPF）有利于去噪，模糊图像，高通滤波（HPF）有利于找到图像边界。

（一）2D滤波器cv2.filter2D( )

img = cv2.imread('kenan.jpg', 0)
kernel = np.ones((5, 5), np.float32)/25

dst = cv2.filter2D(img, -1, kernel)
cv2.imshow('dst', dst)
cv2.imshow('yuantu', img)
cv2.waitKey(0)
cv2.destroyAllWindows()



（二）均值滤波

 OpenCV中有一个专门的平均滤波模板供使用------归一化卷积模板，所有的滤波模板都是使卷积框覆盖区域所有像素点与模板相乘后得到的值作为中心像素的值。OpenCV中均值模板可以用cv2.blur和cv2.boxFilter,比如一个3*3的模板其实就可以如下表示；



模板大小m*n是可以设置的。如果不想要前面的1/9，可以使用非归一化模板cv2.boxFitter。

cv2.blur()是一个通用的2D滤波函数，它的使用需要一个核模板。该滤波函数是单通道运算的，
如果是彩色图像，那么需要将彩色图像的各个通道提取出来，然后分别对各个通道滤波。

如果不想使用归一化模板，那么应该使用cv2.boxFilter(), 并且传入参数normalize=False

img = cv2.imread('kenan.jpg', 0)
blur = cv2.blur(img, (3, 5))  # 模板大小为3*5, 模板的大小是可以设定的
box = cv2.boxFilter(img, -1, (3, 5))
cv2.imshow('gray', img)
cv2.imshow('gray_new', blur)
cv2.imshow('gray_new2', box)
cv2.waitKey(0)
cv2.destroyAllWindows()



（三）高斯模糊模板

在上一目录中，我们的卷积模板中的值全是1，现在把卷积模板中的值换一下，不全是1了，换成一组符合高斯分布的数值放在模板里，这时模板中的数值将会中间的数值最大，往两边走越来越小，构造一个小的高斯包。这样可以减少原始图像信息的丢失。



在OpenCV实现的函数为cv2.GaussianBlur()。对于高斯模板，我们需要制定的是高斯核的高和宽（奇数），沿x与y方向的标准差（如果只给x，y=x，如果都给0，那么函数会自己计算）。高斯 核可以有效的去除图像的高斯噪声。当然也可以自己构造高斯核，相关函数为：cv2.GaussianKernel()。

# 高斯模糊模板
img = cv2.imread('kenan.jpg', 0)
for i in range(2000):  # 在图像中加入点噪声
    _x = np.random.randint(0, img.shape[0])
    _y = np.random.randint(0, img.shape[1])
    img[_x, _y] = 255
blur = cv2.GaussianBlur(img, (5, 5), 0)  # （5,5）表示的是卷积模板的大小，0表示的是沿x与y方向上的标准差
cv2.imshow('img', img)
cv2.imshow('blur', blur)
cv2.waitKey(0)
cv2.destroyAllWindows()

运行结果为：



（四）中值滤波模板

中值滤波模板就是用卷积框中像素的中值代替中心值，达到去噪声的目的。这个模板一般用于去除椒盐噪声。前面的滤波器都是用计算得到的一个新值来取代中心像素的值，而中值滤波是用中心像素周围（也可以使他本身）的值来取代他，卷积核的大小也是个奇数。

# 中值滤波模板
img = cv2.imread('kenan.jpg', 0)
for i in range(2000):  # 加入椒盐噪声
    _x = np.random.randint(0, img.shape[0])
    _y = np.random.randint(0, img.shape[1])
    img[_x][_y] = 255
blur = cv2.medianBlur(img, 5)  # 中值滤波函数
cv2.imshow('img', img)
cv2.imshow('medianblur_img', blur)
cv2.waitKey(0)
cv2.destroyAllWindows()

结果为：



可以看到，中值滤波对于这些白点噪声的去除，效果是非常好的。

（五）双边滤波

双边滤波（Bilateral  filter）是一种可以保证边界清晰的去噪的滤波器。之所以可以达到此去噪声效果，是因为滤波器是由两个函数构成。一个函数是由几何空间距离决定滤波器系数。另一个由像素差决定滤波器系数。它的构造比较复杂，即考虑了图像的空间关系，也考虑图像的灰度关系。双边滤波同时使用了空间高斯权重和灰度相似性高斯权重，确保了边界不会被模糊掉。

cv2.bilateralFilter(img, d, 'p1', 'p2')函数有四个参数需要，d是领域的直径，后面两个参数是空间高斯函数标准差和灰度值相似性高斯函数标准差。

# 双边滤波
img = cv2.imread('rose1.jpg', 0)
for i in range(2000):  # 添加椒盐噪声
    _x = np.random.randint(0, img.shape[0])
    _y = np.random.randint(0, img.shape[1])
    img[_x][_y] = 255
# 9表示的是滤波领域直径，后面的两个数字：空间高斯函数标准差，灰度值相似性标准差
blur = cv2.bilateralFilter(img, 9, 80, 80)
cv2.imshow('img', img)
cv2.imshow('blur_img', blur)
cv2.waitKey(0)
cv2.destroyAllWindows()

结果为：



双边滤波函数后面的两个参数设置的越大，图像的去噪越多，但随之而来的是图像ji将变得模糊，所以根据需要调整好后两个参数的大小。

1、图像平滑(smooth)也称为“模糊处理”，最常见的smooth的用法是减少图像上的噪声或者失真。
2、图像滤波
什么是图像滤波呢？就是在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制。图像滤波的目的就是消除图像的噪声和抽出对象的特征，图像滤波的要求是：不能损坏图像的重要特征信息(如轮廓和边缘)，还需要使得滤波处理后的图像更加清晰。
对于平滑滤波来说，他的目的有两类：(1)、模糊(2)、消噪
空间域内的平滑滤波采用平均法，就是求邻近像素域内的平均亮度值，所以邻域的大小与平滑的效果直接相关，邻域越大，平滑的效果越好，但是需要注意的是，邻域过大的话，平滑处理会使得边缘信息损失得越大。从而使输出的图像变得模糊。
那滤波器是什么呢？
我们可以将滤波器想象成一个包含加权系数的窗口，当使用这个滤波器平滑处理图像时，就把这个窗口放在图像之上，透过这个窗口来看我们得到的图像。
下面是一些滤波器：
方框滤波–> boxblur函数来实现 –>线性滤波
均值滤波(邻域平均滤波)–> blur函数 –>线性滤波
高斯滤波–>GaussianBlur函数 –>线性滤波
中值滤波–>medianBlur函数 –>非线性滤波
双边滤波–>bilateralFilter函数 –>非线性滤波
-- PART A  线性滤波器介绍 --
1
–>什么叫做线性滤波器呢？
线性滤波器常用于剔除输入信号中不想要的频率或者从许多频率中选择一个想要的频率。
下面是几种常见的线性滤波器：
(1)、允许低频率通过的低通滤波器
(2)、允许高频率通过的高通滤波器
(3)、允许一定区域的频率通过的带通滤波器
(4)、阻止一定范围内的频率并且允许其他频率通过的带阻滤波器
(5)、仅仅改变相位的全通滤波器
(6)、阻止一个狭窄频率范围通过的特殊带阻滤波器，陷波滤波器
–>关于滤波和模糊
滤波是将信号中的特定波段频率过滤掉的操作，是为了抑制和防止干扰的措施。
比如高斯滤波，可以分为高斯低通滤波和高斯高通滤波，这个要看高斯函数，低通就是模糊，高通就是锐化。
高斯滤波就是指用高斯函数作为滤波函数的滤波操作，
同样的，高斯模糊就是高斯低通滤波，高斯锐化就是高斯高通滤波。
—–>关于方框滤波
void boxFilter(InputArray src,OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), boolnormalize=true, int borderType=BORDER_DEFAULT )
1
—->参数介绍
第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
第三个参数，int类型的ddepth，输出图像的深度，-1代表使用原图深度，即src.depth()。
第四个参数，Size类型(对Size类型稍后有讲解)的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size(3,3)就表示3x3的核大小，Size(5,5)就表示5x5的核大小
第五个参数，Point类型的anchor，表示锚点(即被平滑的那个点)，注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第六个参数，bool类型的normalize，默认值为true，一个标识符，表示内核是否被其区域归一化(normalized)了。
第七个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
–>均值滤波
均值滤波是最简单的一种滤波操作，输出图像的每一个像素是窗口内的输入图像对应的像素的平均值，也就是归一化后的方框滤波，它的实现也是使用方框滤波来实现的。
实现算法：对于每个像素点，用窗口内的平均像素来替换。
但是均值滤波会破坏图像的细节，从而使得图像变得模糊。
void blur(InputArray src, OutputArraydst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT )
1

第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，Size类型(对Size类型稍后有讲解)的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size(3,3)就表示3x3的核大小，Size(5,5)就表示5x5的核大小
第四个参数，Point类型的anchor，表示锚点(即被平滑的那个点)，注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第五个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
–>高斯滤波
高斯滤波是一种线性滤波，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值都由其本身和邻域内的其他像素值经过加权平均后得到的，他的具体操作方式为：
用一个模板(卷积，掩模)扫描图像中的每一个像素点，用模板确定的邻域内的像素的加权平均值取替换模板中心像素点的值。
void GaussianBlur(InputArray src,OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, intborderType=BORDER_DEFAULT )
1
· 第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。它可以是单独的任意通道数的图片，但需要注意，图片深度应该为CV_8U,CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
· 第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
· 第三个参数，Size类型的ksize高斯内核的大小。其中ksize.width和ksize.height可以不同，但他们都必须为正数和奇数。或者，它们可以是零的，它们都是由sigma计算而来。
· 第四个参数，double类型的sigmaX，表示高斯核函数在X方向的的标准偏差。
· 第五个参数，double类型的sigmaY，表示高斯核函数在Y方向的的标准偏差。若sigmaY为零，就将它设为sigmaX，如果sigmaX和sigmaY都是0，那么就由ksize.width和ksize.height计算出来。
· 为了结果的正确性着想，最好是把第三个参数Size，第四个参数sigmaX和第五个参数sigmaY全部指定到。
· 第六个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
下面是二维高斯函数：
/*
这是进行方框滤波操作的函数，也就是boxFilter
Author:hujian
Time:2016/4/5
*/
void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
Size ksize, Point anchor,
bool normalize, int borderType )
{
CV_OCL_RUN(_dst.isUMat(), ocl_boxFilter(_src, _dst, ddepth, ksize, anchor, borderType, normalize))
//src是操作的图形矩阵
//
Mat src = _src.getMat();
//得到原始图像的类型和深度等信息
//
int stype = src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype);
//-1代表使用原始图像的深度，所以给他赋值为原始图像的深度吧
//
if( ddepth < 0 )
ddepth = sdepth;
//创建和初始化输出图像
//
_dst.create( src.size(), CV_MAKETYPE(ddepth, cn) );
//然后一如既往的我们只操作dst
//
Mat dst = _dst.getMat();
if( borderType != BORDER_CONSTANT && normalize && (borderType & BORDER_ISOLATED) != 0 )
{
if( src.rows == 1 )
ksize.height = 1;
if( src.cols == 1 )
ksize.width = 1;
}
//调用滤波引擎，开始滤波操作
//
Ptrf = createBoxFilter( src.type(), dst.type(),
ksize, anchor, normalize, borderType );
f->apply( src, dst );
}
上面的boxfilter用到了一个叫做滤波引擎的东西，也就是FilterEngine,现在我们来分析一下这个引擎。
class FilterEngine
{
public:
//! the default constructor
FilterEngine();
//! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
FilterEngine(const Ptr& _filter2D,
const Ptr& _rowFilter,
const Ptr& _columnFilter,
int srcType, int dstType, int bufType,
int _rowBorderType = BORDER_REPLICATE,
int _columnBorderType = -1,
const Scalar& _borderValue = Scalar());
//! the destructor
virtual ~FilterEngine();
//! reinitializes the engine. The previously assigned filters are released.
void init(const Ptr& _filter2D,
const Ptr& _rowFilter,
const Ptr& _columnFilter,
int srcType, int dstType, int bufType,
int _rowBorderType = BORDER_REPLICATE,
int _columnBorderType = -1,
const Scalar& _borderValue = Scalar());
//! starts filtering of the specified ROI of an image of size wholeSize.
virtual int start(Size wholeSize, Rect roi, int maxBufRows = -1);
//! starts filtering of the specified ROI of the specified image.
virtual int start(const Mat& src, const Rect& srcRoi = Rect(0,0,-1,-1),
bool isolated = false, int maxBufRows = -1);
//! processes the next srcCount rows of the image.
virtual int proceed(const uchar* src, int srcStep, int srcCount,
uchar* dst, int dstStep);
//! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.
virtual void apply( const Mat& src, Mat& dst,
const Rect& srcRoi = Rect(0,0,-1,-1),
Point dstOfs = Point(0,0),
bool isolated = false);
//! returns true if the filter is separable
bool isSeparable() const { return !filter2D; }
//! returns the number
int remainingInputRows() const;
int remainingOutputRows() const;
int srcType;
int dstType;
int bufType;
Size ksize;
Point anchor;
int maxWidth;
Size wholeSize;
Rect roi;
int dx1;
int dx2;
int rowBorderType;
int columnBorderType;
std::vector borderTab;
int borderElemSize;
std::vector ringBuf;
std::vector srcRow;
std::vector constBorderValue;
std::vector constBorderRow;
int bufStep;
int startY;
int startY0;
int endY;
int rowCount;
int dstY;
std::vector rows;
Ptr filter2D;
Ptr rowFilter;
Ptr columnFilter;
};
虽然不明白，但是上面的源码有很明确的注释呢！
–> blur函数源码
//这是均值滤波的函数
//我们可以看到它仅仅调用了方框滤波函数，然后将归一化设置为true
//也就是说，均值滤波就是归一化后的方框滤波
//
void cv::blur( InputArray src, OutputArray dst,
Size ksize, Point anchor, int borderType )
{
boxFilter( src, dst, -1, ksize, anchor, true, borderType );
}
–>高斯滤波源码分析
//下面就是高斯滤波函数源码
//
void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
double sigma1, double sigma2,
int borderType )
{
//得到原始图像的信息，根据这些信息创建输出函数
//
int type = _src.type();
Size size = _src.size();
_dst.create( size, type );
//处理特殊情况
//
if( borderType != BORDER_CONSTANT && (borderType & BORDER_ISOLATED) != 0 )
{
if( size.height == 1 )
ksize.height = 1;
if( size.width == 1 )
ksize.width = 1;
}
//这还能干吗呢？只是纯粹为了优化而加了这句吧！
//
if( ksize.width == 1 && ksize.height == 1 )
{
//直接复制，没什么可以做的
_src.copyTo(_dst);
return;
}
//创建高斯函数内核，进行滤波
//注意没有调用滤波引起啊！可能是因为效率不如这样做好吧！
Mat kx, ky;
createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2);
sepFilter2D(_src, _dst, CV_MAT_DEPTH(type), kx, ky, Point(-1,-1), 0, borderType );
}
下面就是线性滤波函数的使用了->
//this file will contain the usage of linaer filter in opencv
//
//the first function is boxFilter
//
void usage_boxFilter()
{
Mat img = imread("./smimage/1.jpg");
namedWindow("BoxFilter_SRC");
namedWindow("BoxFilter_RES");
imshow("BoxFilter_SRC", img);
//filter in boxfilter
//
Mat res;
boxFilter(img, res, -1, Size(5, 5));
//show the res image
//
imshow("BoxFilter_RES", res);
waitKey(0);
}
上面的函数运行结果应该是原来的图像经过boxfilter之后变得更见暧昧与朦胧了。
//usage of blur filter
//
void usage_blur()
{
//read the image and show the src image
//
Mat image = imread("./smimage/1.jpg");
namedWindow("SRC");
imshow("SRC", image);
Mat res;
blur(image, res, Size(5, 5));
namedWindow("RES");
imshow("RES", res);
waitKey(0);
}
上面的结果应该是更加暧昧了，和boxfilter好像没什么差别
define  Filter_Linear
ifdef   Filter_Linear
//this file will contain the usage of linaer filter in opencv
//
//the first function is boxFilter
//
void usage_boxFilter()
{
Mat img = imread("./smimage/1.jpg");
namedWindow("BoxFilter_SRC");
namedWindow("BoxFilter_RES");
imshow("BoxFilter_SRC", img);
//filter in boxfilter
//
Mat res;
boxFilter(img, res, -1, Size(5, 5));
//show the res image
//
imshow("BoxFilter_RES", res);
waitKey(0);
}
//usage of blur filter
//
void usage_blur()
{
//read the image and show the src image
//
Mat image = imread("./smimage/1.jpg");
namedWindow("SRC");
imshow("SRC", image);
Mat res;
blur(image, res, Size(5, 5));
namedWindow("RES");
imshow("RES", res);
waitKey(0);
}
//usage of GaussianBlur
//
void usage_GaussianBlur()
{
//read the image and show the src image
//
Mat image = imread("./smimage/1.jpg");
namedWindow("SRC");
imshow("SRC", image);
Mat res;
GaussianBlur(image, res, Size(5,5),0,0);
namedWindow("RES");
imshow("RES", res);
waitKey(0);
}
//this is a sum function,and include boxfilter,blur,gaussianblur
//
Mat  src_image, dst_image_box, dst_image_blur, dst_image_gauss;
int   boxFilterValue = 3; //boxfilter
int   blurValue = 3; //blur
int   gaussianValue = 3;
//this is the callback function SET
//
void onBoxFilter(int v, void* d)
{
//do boxfilter
//
boxFilter(src_image, dst_image_box, -1, Size(boxFilterValue, boxFilterValue));
//show this image
//
imshow("BoxFilter", dst_image_box);
}
void onBlur(int v, void* d)
{
//do boxfilter
//
blur(src_image, dst_image_box,Size(blurValue,blurValue));
//show this image
//
imshow("Blur", dst_image_box);
}
void onGauss(int v, void* d)
{
//do boxfilter
//
GaussianBlur(src_image, dst_image_box,Size(gaussianValue, gaussianValue),0,0);
//show this image
//
imshow("GaussianBlur", dst_image_box);
}
void boxFilter_blur_gaussianblur()
{
//ok,imread the src image
//
src_image = imread("./smimage/1.jpg");
if (src_image.empty()){
printf("This is a empty image or file\n");
return;
}
//show the src image
//
imshow("SRC", src_image);
//boxfilter part
//
namedWindow("BoxFilter");
createTrackbar("Value", "BoxFilter",&boxFilterValue,30, onBoxFilter);
onBoxFilter(0, 0);
//blur part
//
namedWindow("Blur");
createTrackbar("Value", "Blur", &blurValue, 30, onBlur);
onBlur(0, 0);
//gaussian  part
//
namedWindow("GaussianBlur");
createTrackbar("Value", "GaussianBlur", &gaussianValue, 30, onGauss);
onGauss(0, 0);
waitKey(0);
return;
}
endif //end of filter linear part a
—PART B 非线性滤波器介绍—-
–>中值滤波
首先介绍的是中值滤波：就像他的名字一样，他的思想就是用像素点邻域中的灰度的中值来代替该像素点的灰度值，中值滤波在去除脉冲噪声、椒盐噪声的同时还能保留图像的边缘细节。
那中值滤波和均值滤波之间的差别是什么呢？
中值滤波是用中值来替代目标像素，而均值则是用均值来替代。
所以很明显在均值滤波中，所有邻域内的像素点都参与了计算，对输出图像产生了影响，但是中值滤波用的是中值来代替目标像素点，所以噪声像素很难参与到目标图像中去，所以在去除噪声方面，中值滤波更科学合理一些，但是这样的代价是所花费的时间要比均值滤波要多，因为要做排序等处理。
–>双边滤波
这是一种可以保留边界特征去除噪声的滤波器。滤波器由两个函数构成，一个函数是由几何空间距离来决定滤波器系数，另一个则由像素差决定滤波器系数。
下面是双边滤波器的滤波函数：
其中，加权系数W(i,j,k,l)取决于定义域核和值域核的乘积。
定义域核表示如下：
值域核表示如下：
所以双边滤波权重系数可得如下：
void medianBlur(InputArray src,OutputArray dst, int ksize)
1
第一个参数，InputArray类型的src，函数的输入参数，填1、3或者4通道的Mat类型的图像；当ksize为3或者5的时候，图像深度需为CV_8U，CV_16U，或CV_32F其中之一，而对于较大孔径尺寸的图片，它只能是CV_8U。
第二个参数，OutputArray类型的dst，即目标图像，函数的输出参数，需要和源图片有一样的尺寸和类型。我们可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，int类型的ksize，孔径的线性尺寸(aperture linear size)，注意这个参数必须是大于1的奇数，比如：3，5，7，9 …
//usage of medianblur
//
void usage_medianBlur()
{
Mat image = imread("./smimage/18.jpg");
imshow("SRC", image);
//medianblur
//
Mat res;
medianBlur(image, res, 3);
imshow("RES", res);
waitKey(0);
}
双边滤波：
void bilateralFilter(InputArray src, OutputArraydst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
1
·
第一个参数，InputArray类型的src，输入图像，即源图像，需要为8位或者浮点型单通道、三通道的图像。
· 第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
· 第三个参数，int类型的d，表示在过滤过程中每个像素邻域的直径。如果这个值我们设其为非正数，那么OpenCV会从第五个参数sigmaSpace来计算出它来。
· 第四个参数，double类型的sigmaColor，颜色空间滤波器的sigma值。这个参数的值越大，就表明该像素邻域内有更宽广的颜色会被混合到一起，产生较大的半相等颜色区域。
· 第五个参数，double类型的sigmaSpace坐标空间中滤波器的sigma值，坐标空间的标注方差。他的数值越大，意味着越远的像素会相互影响，从而使更大的区域足够相似的颜色获取相同的颜色。当d>0，d指定了邻域大小且与sigmaSpace无关。否则，d正比于sigmaSpace。
· 第六个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。注意它有默认值BORDER_DEFAULT。
//usage of bilateralFilter
//
void usage_bilateralFilter()
{
Mat src = imread("./smimage/18.jpg");
imshow("SRC", src);
Mat res;
bilateralFilter(src, res, 20, 50, 10);
imshow("RES", res);
waitKey(0);
}

图像平滑处理-中值滤波
1.什么是滤波？
2.平滑处理的目的
3.平滑处理的应用
4.中值滤波的处理方法
5.中值滤波的示意图
椒盐噪声
6.椒盐处理和中值滤波的效果展示
7.代码（面向过程）
8.程序演示（面向对象）

1.什么是滤波？
图像滤波：即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，是图像预处理中不可缺少的操作，其处理效果的好坏将直接影响到后续图像处理和分析的有效性和可靠性。
消除图像中的噪声成分叫作图像的平滑化或滤波操作。信号或图像的能量大部分集中在幅度谱的低频和中频段是很常见的，而在较高频段，感兴趣的信息经常被噪声淹没。因此一个能降低高频成分幅度的滤波器就能够减弱噪声的影响。
2.平滑处理的目的
图像滤波的目的有两个:
一是抽出对象的特征作为图像识别的特征模式;

另一个是为适应图像处理的要求，消除图像数字化时所混入的噪声。
而对滤波处理的要求也有两条:
一是不能损坏图像的轮廓及边缘等重要信息;

二是使图像清晰视觉效果好。
3.平滑处理的应用
关于滤波器，一种形象的比喻法是：

我们可以把滤波器想象成一个包含加权系数的窗口，当使用这个滤波器平滑处理图像时，就把这个窗口放到图像之上，透过这个窗口来看我们得到的图像。
举一个滤波在我们生活中的应用：

美颜的磨皮功能。如果将我们脸上坑坑洼洼比作是噪声的话，那么滤波算法就是来取出这些噪声，使我们自拍的皮肤看起来很光滑。
4.中值滤波的处理方法
中值滤波是一种典型的非线性滤波，是基于排序统计理论的一种能够有效抑制噪声的非线性信号处理技术，基本思想是用像素点邻域灰度值的中值来代替该像素点的灰度值，让周围的像素值接近真实的值从而消除孤立的噪声点。该方法在取出脉冲噪声、椒盐噪声的同时能保留图像的边缘细节。这些优良特性是线性滤波所不具备的。
中值滤波首先也得生成一个滤波模板，将该模板内的各像素值进行排序，生成单调上升或单调下降的二维数据序列，二维中值滤波输出为

g(x, y)=medf{f(x-k, y-1),(k, l∈w)}

	其中f(x,y)和g(x,y)分别是原图像和处理后图像, w为输入的二维模板，能够在整幅图像上滑动，通常尺寸为3*3或5*5区域，也可以是不同的形状如线状、圆形、十字形、圆环形等。通过从图像中的二维模板取出奇数个数据进行排序，用排序后的中值取代要处理的数据即可。 

5.中值滤波的示意图
首先，我们复习中值。在一连串数字｛1，4，6，8，9｝中，数字6就是这串数字的中值。由此我们可以应用到图像处理中。依然我们在图像中去3*3的矩阵，里面有9个像素点，我们将9个像素进行排序，最后将这个矩阵的中心点赋值为这九个像素的中值。


椒盐噪声
椒盐噪声（salt-and-pepper noise）是由图像传感器，传输信道，解码处理等产生的黑白相间的亮暗点噪声。

　　所谓椒盐，椒就是黑，盐就是白，椒盐噪声就是在图像上随机出现黑色白色的像素。椒盐噪声是一种因为信号脉冲强度引起的噪声，产生该噪声的算法也比较简单。

　　椒盐噪声往往由图像切割引起，去除脉冲干扰及椒盐噪声最常用的算法是中值滤波。大量的实验研究发现，由摄像机拍摄得到的图像受离散的脉冲、椒盐噪声和零均值的高斯噪声的影响较严重。噪声给图像处理带来很多困难，对图像分割、特征提取、图像识别等具有直接影响。因此，实时采集的图像需进行滤波处理。消除图像中的噪声成份叫做图像的平滑化或滤波操作。滤波的目的有两个：一是抽出对象的特征作为图像识别的特征模式；二是为适应计算机处理的要求，消除图像数字化时所混入的噪声。对滤波处理的要求有两条：一是不能损坏图像轮廓及边缘等重要信息；二是使图像清晰，视觉效果好。
我们使用信噪比（Signal NoiseRate）衡量图像噪声，图象的信噪比应该等于信号与噪声的功率谱之比，但通常功率谱难以计算，有一种方法可以近似估计图象信噪比，即信号与噪声的方差之比（其实在均值为零的情况下，功率就是方差）。首先计算图象所有像素的局部方差，将局部方差的最大值认为是信号方差，最小值是噪声方差，求出它们的比值，再转成dB数，最后用经验公式修正。
6.椒盐处理和中值滤波的效果展示

7.代码（面向过程）
#%matplotlib inline
from matplotlib import pyplot as plt
import cv2
import numpy as np
from copy import deepcopy


filename = input("请输入图像名称：")
winname = "figure"
img = cv2.imread(filename)

def add_salt_noise(img, snr=0.5):
    # 指定信噪比
    SNR = snr
    # 获取总共像素个数
    size = img.size
    print(size)
    # 因为信噪比是 SNR ，所以噪声占据百分之10，所以需要对这百分之10加噪声
    noiseSize = int(size * (1 - SNR))
    # 对这些点加噪声
    for k in range(0, noiseSize):
        # 随机获取 某个点
        xi = int(np.random.uniform(0, img.shape[1]))
        xj = int(np.random.uniform(0, img.shape[0]))
        # 增加噪声
        if img.ndim == 2:
            img[xj, xi] = 255
        elif img.ndim == 3:
            img[xj, xi] = 0
    return img

img_demo = deepcopy(img)
snr = float(input("请输入一个信噪比（小数表示）："))
img_salt = add_salt_noise(img_demo, snr)
img_medianblur = cv2.medianBlur(img, 11)

img_all = np.hstack([
    img, img_salt, img_medianblur
])

plt.figure(figsize=(20,10))
plt.imshow(img_all[:,:,::-1])
plt.show()


8.程序演示（面向对象）
用tkinter 做的界面化处理操作

完整代码（码云）：码云分享

完整代码（github）：github分享
觉得不错的朋友，可以与我交流关注，以及去码云和github点星，真的感谢！～