【OpenCV】邻域滤波：方框、高斯、中值、双边滤波

浅浅的花香味﹌ 2022-08-08 06:15 209阅读 0赞

### 邻域滤波（卷积） ###

邻域算子值利用给定像素周围像素的值决定此像素的最终输出。如图左边图像与中间图像卷积禅城右边图像。目标图像中绿色的像素由原图像中蓝色标记的像素计算得到。

![1343204944_4965.png][]

通用线性邻域滤波是一种常用的邻域算子，输入像素加权得到输出像素：

![1343204835_3910.png][]

其中权重核 ![1343204877_2586.png][] 为“**滤波系数**”。上面的式子可以简记为：

![1343204920_5262.png][]

## 【方框滤波】 ##

最简单的线性滤波是移动平均或方框滤波，用 ![1343205025_1196.png][]窗口中的像素值平均后输出，核函数为：

![1343205109_7080.png][]

其实等价于图像与全部元素值为1的核函数进行卷积再进行尺度缩放。

### 代码 ###

OpenCV中的 blur函数是进行标准方框滤波：

**\[cpp\]** [view plain][] [copy][view plain]

1.  **void** cv::blur( InputArray src, OutputArray dst, 
2.   Size ksize, Point anchor, **int** borderType ) 
3.  \{ 
4.   boxFilter( src, dst, -1, ksize, anchor, **true**, borderType ); 
5.  \}

而boxFilter函数源码如下：

**\[cpp\]** [view plain][] [copy][view plain]

1.  cv::Ptr<cv::FilterEngine> cv::createBoxFilter( **int** srcType, **int** dstType, Size ksize, 
2.   Point anchor, **bool** normalize, **int** borderType ) 
3.  \{ 
4.  **int** sdepth = CV\_MAT\_DEPTH(srcType); 
5.  **int** cn = CV\_MAT\_CN(srcType), sumType = CV\_64F; 
6.  **if**( sdepth <= CV\_32S && (!normalize || 
7.   ksize.width\*ksize.height <= (sdepth == CV\_8U ? (1<<23) : 
8.   sdepth == CV\_16U ? (1 << 15) : (1 << 16))) ) 
9.   sumType = CV\_32S; 
10.  sumType = CV\_MAKETYPE( sumType, cn ); 
11. 
12.  Ptr<BaseRowFilter> rowFilter = getRowSumFilter(srcType, sumType, ksize.width, anchor.x ); 
13.  Ptr<BaseColumnFilter> columnFilter = getColumnSumFilter(sumType, 
14.  dstType, ksize.height, anchor.y, normalize ? 1./(ksize.width\*ksize.height) : 1); 
15. 
16. **return** Ptr<FilterEngine>(**new** FilterEngine(Ptr<BaseFilter>(0), rowFilter, columnFilter, 
17.  srcType, dstType, sumType, borderType )); 
18. \}

这里 blur 和 boxFilter 的区别是，blur是标准化后的 boxFilter，即boxFilter的核函数：

![1343265108_1497.png][]

其中， ![1343265218_9194.png][]

**\[cpp\]** [view plain][] [copy][view plain]

1.  blur( src, dst, Size( 1, 1 ), Point(-1,-1)); 
2.  blur( src, dst, Size( 4, 4 ), Point(-1,-1)); 
3.  blur( src, dst, Size( 8, 8 ), Point(-1,-1)); 
4.  blur( src, dst, Size( 16, 16 ), Point(-1,-1));

### 实验结果 ###

下图是对一幅图像分别用1\*1,4\*4,8\*8,16\*16标准方框滤波后的图像：

![1343265319_9054.png][] ![1343265816_9366.png][] ![1343265832_6378.png][] ![1343265935_1407.png][]

## 【高斯滤波】 ##

高斯滤波器是一类根据高斯函数的形状来选择权值的线性平滑滤波器。它对去除服从正态分布的噪声很有效。  
常用的零均值离散高斯滤波器函数：

![1343205174_7684.png][]

2D图像中表示为：

![1343206042_2421.png][]

### 代码 ###

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\\
2.   Gaussian Blur
3.  \\\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
4.  
5.  cv::Mat cv::getGaussianKernel( **int** n, **double** sigma, **int** ktype ) 
6.  \{ 
7.  **const****int** SMALL\_GAUSSIAN\_SIZE = 7; 
8.  **static****const****float** small\_gaussian\_tab\[\]\[SMALL\_GAUSSIAN\_SIZE\] = 
9.   \{ 
10.  \{1.f\}, 
11.  \{0.25f, 0.5f, 0.25f\}, 
12.  \{0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f\}, 
13.  \{0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f\} 
14.  \}; 
15. 
16. **const****float**\* fixed\_kernel = n % 2 == 1 && n <= SMALL\_GAUSSIAN\_SIZE && sigma <= 0 ? 
17.  small\_gaussian\_tab\[n>>1\] : 0; 
18. 
19.  CV\_Assert( ktype == CV\_32F || ktype == CV\_64F ); 
20.  Mat kernel(n, 1, ktype); 
21. **float**\* cf = (**float**\*)kernel.data; 
22. **double**\* cd = (**double**\*)kernel.data; 
23. 
24. **double** sigmaX = sigma > 0 ? sigma : ((n-1)\*0.5 - 1)\*0.3 + 0.8; 
25. **double** scale2X = -0.5/(sigmaX\*sigmaX); 
26. **double** sum = 0; 
27. 
28. **int** i; 
29. **for**( i = 0; i < n; i++ ) 
30.  \{ 
31. **double** x = i - (n-1)\*0.5; 
32. **double** t = fixed\_kernel ? (**double**)fixed\_kernel\[i\] : std::exp(scale2X\*x\*x); 
33. **if**( ktype == CV\_32F ) 
34.  \{ 
35.  cf\[i\] = (**float**)t; 
36.  sum += cf\[i\]; 
37.  \} 
38. **else**
39.  \{ 
40.  cd\[i\] = t; 
41.  sum += cd\[i\]; 
42.  \} 
43.  \} 
44. 
45.  sum = 1./sum; 
46. **for**( i = 0; i < n; i++ ) 
47.  \{ 
48. **if**( ktype == CV\_32F ) 
49.  cf\[i\] = (**float**)(cf\[i\]\*sum); 
50. **else**
51.  cd\[i\] \*= sum; 
52.  \} 
53. 
54. **return** kernel; 
55. \} 
56. 
57. 
58. cv::Ptr<cv::FilterEngine> cv::createGaussianFilter( **int** type, Size ksize, 
59. **double** sigma1, **double** sigma2, 
60. **int** borderType ) 
61. \{ 
62. **int** depth = CV\_MAT\_DEPTH(type); 
63. **if**( sigma2 <= 0 ) 
64.  sigma2 = sigma1; 
65. 
66. // automatic detection of kernel size from sigma
67. **if**( ksize.width <= 0 && sigma1 > 0 ) 
68.  ksize.width = cvRound(sigma1\*(depth == CV\_8U ? 3 : 4)\*2 + 1)|1; 
69. **if**( ksize.height <= 0 && sigma2 > 0 ) 
70.  ksize.height = cvRound(sigma2\*(depth == CV\_8U ? 3 : 4)\*2 + 1)|1; 
71. 
72.  CV\_Assert( ksize.width > 0 && ksize.width % 2 == 1 && 
73.  ksize.height > 0 && ksize.height % 2 == 1 ); 
74. 
75.  sigma1 = std::max( sigma1, 0. ); 
76.  sigma2 = std::max( sigma2, 0. ); 
77. 
78.  Mat kx = getGaussianKernel( ksize.width, sigma1, std::max(depth, CV\_32F) ); 
79.  Mat ky; 
80. **if**( ksize.height == ksize.width && std::abs(sigma1 - sigma2) < DBL\_EPSILON ) 
81.  ky = kx; 
82. **else**
83.  ky = getGaussianKernel( ksize.height, sigma2, std::max(depth, CV\_32F) ); 
84. 
85. **return** createSeparableLinearFilter( type, type, kx, ky, Point(-1,-1), 0, borderType ); 
86. \} 
87. 
88. 
89. **void** cv::GaussianBlur( InputArray \_src, OutputArray \_dst, Size ksize, 
90. **double** sigma1, **double** sigma2, 
91. **int** borderType ) 
92. \{ 
93.  Mat src = \_src.getMat(); 
94.  \_dst.create( src.size(), src.type() ); 
95.  Mat dst = \_dst.getMat(); 
96. 
97. **if**( borderType != BORDER\_CONSTANT ) 
98.  \{ 
99. **if**( src.rows == 1 ) 
100.  ksize.height = 1; 
101. **if**( src.cols == 1 ) 
102.  ksize.width = 1; 
103.  \} 
104. 
105. **if**( ksize.width == 1 && ksize.height == 1 ) 
106.  \{ 
107.  src.copyTo(dst); 
108. **return**; 
109.  \} 
110. 
111. \#ifdef HAVE\_TEGRA\_OPTIMIZATION
112. **if**(sigma1 == 0 && sigma2 == 0 && tegra::gaussian(src, dst, ksize, borderType)) 
113. **return**; 
114. \#endif
115. 
116.  Ptr<FilterEngine> f = createGaussianFilter( src.type(), ksize, sigma1, sigma2, borderType ); 
117.  f->apply( src, dst ); 
118. \}

###     ###

### 实验结果 ###

下图是对一幅图像分别用1\*1,3\*3,5\*5,9\*9标准方框滤波后的图像：

![1343270908_7137.png][] ![1343270923_5228.png][] ![1343270936_6880.png][] ![1343270948_6384.png][]

##     ##

## 非线性滤波 ##

线性滤波易于构造，且易于从频率响应的角度分析，但如果噪声是散粒噪声而非高斯噪声时线性滤波不能去除噪声。如图像突然出现很大的值，线性滤波只是转换为柔和但仍可见的散粒。这时需要非线性滤波。

简单的非线性滤波有 **中值滤波**， ![1343205243_7367.png][]**-截尾均值滤波**，**定义域滤波** 和**值域滤波** 。

![1343205272_6628.png][]

中值滤波选择每个邻域像素的中值输出； ![1343205243_7367.png][]\-截尾均值滤波是指去掉百分率为![1343205243_7367.png][] 的最小值和最大值；定义域滤波中沿着边界的数字是像素的距离；值域就是去掉值域外的像素值。

### 中值滤波代码 ###

**\[cpp\]** [view plain][] [copy][view plain]

1.  medianBlur ( src, dst, i );

### 中值滤波实验 ###

下图是对一幅图像分别用3\*3,5\*5,7\*7,9\*9（这里必须是奇数）标准方框滤波后的图像：

![1343271115_6888.png][] ![1343271127_6044.png][] ![1343271140_3393.png][] ![1343271151_7825.png][]

##     ##

## 【双边滤波】 ##

双边滤波的思想是抑制与中心像素值差别太大的像素，输出像素值依赖于邻域像素值的加权合：

![1343205356_7329.png][]

权重系数 取决于定义域核

![1343205418_5980.png][]

和依赖于数据的值域核

![1343205447_8715.png][]

的乘积。相乘后会产生依赖于数据的双边权重函数：

![1343205481_5696.png][]

### 双边滤波源码 ###

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\\
2.   Bilateral Filtering
3.  \\\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
4.  
5.  **namespace** cv 
6.  \{ 
7.  
8.  **static****void**
9.  bilateralFilter\_8u( **const** Mat& src, Mat& dst, **int** d, 
10. **double** sigma\_color, **double** sigma\_space, 
11. **int** borderType ) 
12. \{ 
13. **int** cn = src.channels(); 
14. **int** i, j, k, maxk, radius; 
15.  Size size = src.size(); 
16. 
17.  CV\_Assert( (src.type() == CV\_8UC1 || src.type() == CV\_8UC3) && 
18.  src.type() == dst.type() && src.size() == dst.size() && 
19.  src.data != dst.data ); 
20. 
21. **if**( sigma\_color <= 0 ) 
22.  sigma\_color = 1; 
23. **if**( sigma\_space <= 0 ) 
24.  sigma\_space = 1; 
25. 
26. **double** gauss\_color\_coeff = -0.5/(sigma\_color\*sigma\_color); 
27. **double** gauss\_space\_coeff = -0.5/(sigma\_space\*sigma\_space); 
28. 
29. **if**( d <= 0 ) 
30.  radius = cvRound(sigma\_space\*1.5); 
31. **else**
32.  radius = d/2; 
33.  radius = MAX(radius, 1); 
34.  d = radius\*2 + 1; 
35. 
36.  Mat temp; 
37.  copyMakeBorder( src, temp, radius, radius, radius, radius, borderType ); 
38. 
39.  vector<**float**> \_color\_weight(cn\*256); 
40.  vector<**float**> \_space\_weight(d\*d); 
41.  vector<**int**> \_space\_ofs(d\*d); 
42. **float**\* color\_weight = &\_color\_weight\[0\]; 
43. **float**\* space\_weight = &\_space\_weight\[0\]; 
44. **int**\* space\_ofs = &\_space\_ofs\[0\]; 
45. 
46. // initialize color-related bilateral filter coefficients
47. **for**( i = 0; i < 256\*cn; i++ ) 
48.  color\_weight\[i\] = (**float**)std::exp(i\*i\*gauss\_color\_coeff); 
49. 
50. // initialize space-related bilateral filter coefficients
51. **for**( i = -radius, maxk = 0; i <= radius; i++ ) 
52. **for**( j = -radius; j <= radius; j++ ) 
53.  \{ 
54. **double** r = std::sqrt((**double**)i\*i + (**double**)j\*j); 
55. **if**( r > radius ) 
56. **continue**; 
57.  space\_weight\[maxk\] = (**float**)std::exp(r\*r\*gauss\_space\_coeff); 
58.  space\_ofs\[maxk++\] = (**int**)(i\*temp.step + j\*cn); 
59.  \} 
60. 
61. **for**( i = 0; i < size.height; i++ ) 
62.  \{ 
63. **const** uchar\* sptr = temp.data + (i+radius)\*temp.step + radius\*cn; 
64.  uchar\* dptr = dst.data + i\*dst.step; 
65. 
66. **if**( cn == 1 ) 
67.  \{ 
68. **for**( j = 0; j < size.width; j++ ) 
69.  \{ 
70. **float** sum = 0, wsum = 0; 
71. **int** val0 = sptr\[j\]; 
72. **for**( k = 0; k < maxk; k++ ) 
73.  \{ 
74. **int** val = sptr\[j + space\_ofs\[k\]\]; 
75. **float** w = space\_weight\[k\]\*color\_weight\[std::abs(val - val0)\]; 
76.  sum += val\*w; 
77.  wsum += w; 
78.  \} 
79. // overflow is not possible here => there is no need to use CV\_CAST\_8U
80.  dptr\[j\] = (uchar)cvRound(sum/wsum); 
81.  \} 
82.  \} 
83. **else**
84.  \{ 
85.  assert( cn == 3 ); 
86. **for**( j = 0; j < size.width\*3; j += 3 ) 
87.  \{ 
88. **float** sum\_b = 0, sum\_g = 0, sum\_r = 0, wsum = 0; 
89. **int** b0 = sptr\[j\], g0 = sptr\[j+1\], r0 = sptr\[j+2\]; 
90. **for**( k = 0; k < maxk; k++ ) 
91.  \{ 
92. **const** uchar\* sptr\_k = sptr + j + space\_ofs\[k\]; 
93. **int** b = sptr\_k\[0\], g = sptr\_k\[1\], r = sptr\_k\[2\]; 
94. **float** w = space\_weight\[k\]\*color\_weight\[std::abs(b - b0) + 
95.  std::abs(g - g0) + std::abs(r - r0)\]; 
96.  sum\_b += b\*w; sum\_g += g\*w; sum\_r += r\*w; 
97.  wsum += w; 
98.  \} 
99.  wsum = 1.f/wsum; 
100.  b0 = cvRound(sum\_b\*wsum); 
101.  g0 = cvRound(sum\_g\*wsum); 
102.  r0 = cvRound(sum\_r\*wsum); 
103.  dptr\[j\] = (uchar)b0; dptr\[j+1\] = (uchar)g0; dptr\[j+2\] = (uchar)r0; 
104.  \} 
105.  \} 
106.  \} 
107. \}

### 双边滤波调用 ###

**\[cpp\]** [view plain][] [copy][view plain]

1.  bilateralFilter(InputArray src, OutputArray dst, **int** d, **double** sigmaColor, **double** sigmaSpace, 
2.  **int** borderType=BORDER\_DEFAULT )；

d 表示滤波时像素邻域直径，d为负时由 sigaColor计算得到；d>5时不能实时处理。

sigmaColor、sigmaSpace非别表示颜色空间和坐标空间的滤波系数sigma。可以简单的赋值为相同的值。<10时几乎没有效果；>150时为油画的效果。

borderType可以不指定。

### 双边滤波实验 ###

用sigma为10，150,240,480时效果如下：

![1343271581_1185.png][] ![1343271597_9349.png][] ![1343271611_2282.png][] ![1343271633_3045.png][]

### *参考文献：* ###

*Richard Szeliski 《Computer Vision: Algorithms and Applications》  
[http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL\_COPIES/MANDUCHI1/Bilateral\_Filtering.html][http_homepages.inf.ed.ac.uk_rbf_CVonline_LOCAL_COPIES_MANDUCHI1_Bilateral_Filtering.html]  
《The OpenCV Tutorials》 Release 2.4.2  
《The OpenCV Reference Manual 》 Release 2.4.2*

### 转载请注明出处：[http://blog.csdn.net/xiaowei\_cqu/article/details/7785365][http_blog.csdn.net_xiaowei_cqu_article_details_7785365] ###

[1343204944_4965.png]: https://img-my.csdn.net/uploads/201207/25/1343204944_4965.png
[1343204835_3910.png]: https://img-my.csdn.net/uploads/201207/25/1343204835_3910.png
[1343204877_2586.png]: https://img-my.csdn.net/uploads/201207/25/1343204877_2586.png
[1343204920_5262.png]: https://img-my.csdn.net/uploads/201207/25/1343204920_5262.png
[1343205025_1196.png]: https://img-my.csdn.net/uploads/201207/25/1343205025_1196.png
[1343205109_7080.png]: https://img-my.csdn.net/uploads/201207/25/1343205109_7080.png
[view plain]: http://blog.csdn.net/xiaowei_cqu/article/details/7785365#
[1343265108_1497.png]: https://img-my.csdn.net/uploads/201207/26/1343265108_1497.png
[1343265218_9194.png]: https://img-my.csdn.net/uploads/201207/26/1343265218_9194.png
[1343265319_9054.png]: https://img-my.csdn.net/uploads/201207/26/1343265319_9054.png
[1343265816_9366.png]: https://img-my.csdn.net/uploads/201207/26/1343265816_9366.png
[1343265832_6378.png]: https://img-my.csdn.net/uploads/201207/26/1343265832_6378.png
[1343265935_1407.png]: https://img-my.csdn.net/uploads/201207/26/1343265935_1407.png
[1343205174_7684.png]: https://img-my.csdn.net/uploads/201207/25/1343205174_7684.png
[1343206042_2421.png]: https://img-my.csdn.net/uploads/201207/25/1343206042_2421.png
[1343270908_7137.png]: https://img-my.csdn.net/uploads/201207/26/1343270908_7137.png
[1343270923_5228.png]: https://img-my.csdn.net/uploads/201207/26/1343270923_5228.png
[1343270936_6880.png]: https://img-my.csdn.net/uploads/201207/26/1343270936_6880.png
[1343270948_6384.png]: https://img-my.csdn.net/uploads/201207/26/1343270948_6384.png
[1343205243_7367.png]: https://img-my.csdn.net/uploads/201207/25/1343205243_7367.png
[1343205272_6628.png]: https://img-my.csdn.net/uploads/201207/25/1343205272_6628.png
[1343271115_6888.png]: https://img-my.csdn.net/uploads/201207/26/1343271115_6888.png
[1343271127_6044.png]: https://img-my.csdn.net/uploads/201207/26/1343271127_6044.png
[1343271140_3393.png]: https://img-my.csdn.net/uploads/201207/26/1343271140_3393.png
[1343271151_7825.png]: https://img-my.csdn.net/uploads/201207/26/1343271151_7825.png
[1343205356_7329.png]: https://img-my.csdn.net/uploads/201207/25/1343205356_7329.png
[1343205418_5980.png]: https://img-my.csdn.net/uploads/201207/25/1343205418_5980.png
[1343205447_8715.png]: https://img-my.csdn.net/uploads/201207/25/1343205447_8715.png
[1343205481_5696.png]: https://img-my.csdn.net/uploads/201207/25/1343205481_5696.png
[1343271581_1185.png]: https://img-my.csdn.net/uploads/201207/26/1343271581_1185.png
[1343271597_9349.png]: https://img-my.csdn.net/uploads/201207/26/1343271597_9349.png
[1343271611_2282.png]: https://img-my.csdn.net/uploads/201207/26/1343271611_2282.png
[1343271633_3045.png]: https://img-my.csdn.net/uploads/201207/26/1343271633_3045.png
[http_homepages.inf.ed.ac.uk_rbf_CVonline_LOCAL_COPIES_MANDUCHI1_Bilateral_Filtering.html]: http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
[http_blog.csdn.net_xiaowei_cqu_article_details_7785365]: http://blog.csdn.net/xiaowei_cqu/article/details/7785365