双边滤波器

最新推荐文章于 2024-01-26 18:14:11 发布

lemianli

最新推荐文章于 2024-01-26 18:14:11 发布

阅读量1k

点赞数 1

分类专栏：立体匹配资源整合文章标签：计算机视觉算法

资源整合同时被 2 个专栏收录

39 篇文章

订阅专栏

立体匹配

11 篇文章

订阅专栏

本文介绍了双边滤波器的工作原理及其在图像处理中的应用。双边滤波是一种能有效去除噪声同时保持图像边缘细节的滤波方法。文章详细阐述了其数学模型，并提供了C++实现代码示例。

1.双边滤波

双边滤波很有名，使用广泛，简单的说就是一种同时考虑了像素空间差异与强度差异的滤波器，因此具有保持图像边缘的特性。

先看看我们熟悉的高斯滤波器

其中W是权重，i和j是像素索引，K是归一化常量。公式中可以看出，权重只和像素之间的空间距离有关系，无论图像的内容是什么，都有相同的滤波效果。

再来看看双边滤波器，它只是在原有高斯函数的基础上加了一项，如下

其中 I 是像素的强度值，所以在强度差距大的地方（边缘），权重会减小，滤波效应也就变小。总体而言，在像素强度变换不大的区域，双边滤波有类似于高斯滤波的效果，而在图像边缘等强度梯度较大的地方，可以保持梯度。

一、原理

双边滤波（Bilateral filter）是一种可以去噪保边的滤波器。之所以可以达到此效果，是因为滤波器是由两个函数构成：一个函数是由几何空间距离决定滤波器系数，另一个由像素差值决定滤波器系数。

原理示意图如下：

双边滤波器中，输出像素的值依赖于邻域像素的值的加权组合，

权重系数w(i,j,k,l)取决于 定义域核

和 值域核

的乘积

二、C++实现

2.1 OpenCV调用方法：

[cpp]view plaincopy 
    
 cvSmooth(m_iplImg, dstImg, CV_BILATERAL, 2 * r + 1, 0, sigma_r, sigma_d);  

2.2 MATLAB版代码：

http://www.mathworks.com/matlabcentral/fileexchange/12191-bilateral-filtering/content/Bilateral%20Filtering/bfilter2.m

调用方法参见资料[1]

2.3 C++代码

[cpp]view plaincopy 
    
 void CImageObj::Bilateral_Filter(int r, double sigma_d, double sigma_r)  
 {  
     int i, j, m, n, k;  
     int nx = m_width, ny = m_height;  
     int w_filter = 2 * r + 1; // 滤波器边长  
   
     double gaussian_d_coeff = -0.5 / (sigma_d * sigma_d);  
     double gaussian_r_coeff = -0.5 / (sigma_r * sigma_r);  
   
     double** d_metrix = NewDoubleMatrix(w_filter, w_filter);  // spatial weight  
     double r_metrix[256];  // similarity weight  
   
     // copy the original image  
     double* img_tmp = new double[m_nChannels * nx * ny];  
     for (i = 0; i < ny; i++)  
         for (j = 0; j < nx; j++)  
             for (k = 0; k < m_nChannels; k++)  
             {  
                 img_tmp[i * m_nChannels * nx + m_nChannels * j + k] = m_imgData[i * m_nChannels * nx + m_nChannels * j + k];  
             }  
   
     // compute spatial weight  
     for (i = -r; i <= r; i++)  
         for (j = -r; j <= r; j++)  
         {  
             int x = j + r;  
             int y = i + r;  
   
             d_metrix[y][x] = exp((i * i + j * j) * gaussian_d_coeff);  
         }  
   
     // compute similarity weight  
     for (i = 0; i < 256; i++)  
     {  
         r_metrix[i] = exp(i * i * gaussian_r_coeff);  
     }  
   
     // bilateral filter  
     for (i = 0; i < ny; i++)  
         for (j = 0; j < nx; j++)  
         {  
             for (k = 0; k < m_nChannels; k++)  
             {  
                 double weight_sum, pixcel_sum;  
                 weight_sum = pixcel_sum = 0.0;  
   
                 for (m = -r; m <= r; m++)  
                     for (n = -r; n <= r; n++)  
                     {  
                         if (m*m + n*n > r*r) continue;  
   
                         int x_tmp = j + n;  
                         int y_tmp = i + m;  
   
                         x_tmp = x_tmp < 0 ? 0 : x_tmp;  
                         x_tmp = x_tmp > nx - 1 ? nx - 1 : x_tmp;   // 边界处理，replicate  
                         y_tmp = y_tmp < 0 ? 0 : y_tmp;  
                         y_tmp = y_tmp > ny - 1 ? ny - 1 : y_tmp;  
   
                         int pixcel_dif = (int)abs(img_tmp[y_tmp * m_nChannels * nx + m_nChannels * x_tmp + k] - img_tmp[i * m_nChannels * nx + m_nChannels * j + k]);  
                         double weight_tmp = d_metrix[m + r][n + r] * r_metrix[pixcel_dif];  // 复合权重  
   
                         pixcel_sum += img_tmp[y_tmp * m_nChannels * nx + m_nChannels * x_tmp + k] * weight_tmp;  
                         weight_sum += weight_tmp;  
                     }  
   
                 pixcel_sum = pixcel_sum / weight_sum;  
                 m_imgData[i * m_nChannels * nx + m_nChannels * j + k] = (uchar)pixcel_sum;  
                   
             } // 一个通道  
   
         } // END ALL LOOP  
   
     UpdateImage();  
     DeleteDoubleMatrix(d_metrix, w_filter, w_filter);  
     delete[] img_tmp;  
 }  