• opencv中的各种滤波设计

     这篇文章写得太好了 ，感觉自己实在没有办法去补充这方面的知识点
    我打算把高斯滤波和双边滤波还好好补充下
    这篇文章转载自一个美丽的才女：小魏
    连接地址：http://blog.csdn.net/xiaowei_cqu/article/details/7785365
     
    如果想要彻底明白，就看看这位顶级大神的博客：http://blog.csdn.net/poem_qianmo/article/details/21479533
     

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

    邻域滤波（卷积）

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

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

    其中权重核   为“滤波系数”。上面的式子可以简记为：

    【方框滤波】

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

    boxFilter（）函数方框滤波所用的核为：

     

    其实等价于图像与全部元素值为1的核函数进行卷积再进行尺度缩放。
    均值滤波本身存在着固有的缺陷，即它不能很好地保护图像细节，在图像去噪的同时也破坏了图像的细节部分，从而使图像变得模糊，不能很好地去除噪声点

    其中f表示原图，h表示核，g表示目标图，当normalize=true的时候，方框滤波就变成了我们熟悉的均值滤波。也就是说，均值滤波是方框滤波归一化（normalized）后的特殊情况。其中，归一化就是把要处理的量都缩放到一个范围内,比如(0,1)（这个地方需要明白，不要以为归一化就是特征值为一的那种归一化），以便统一处理和直观量化。

    而非归一化（Unnormalized）的方框滤波用于计算每个像素邻域内的积分特性，比如密集光流算法（dense optical flow algorithms）中用到的图像倒数的协方差矩阵（covariance matrices of image derivatives）

    代码

    OpenCV中的 blur函数是进行标准方框滤波：
    [cpp] view plaincopy
     
    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. }  
    6. 第四个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。
    7. 如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心
    而boxFilter函数源码如下：
    [cpp] view plaincopy
     
    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. }  

    参数详解如下：

    • 第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
    • 第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
    • 第三个参数，int类型的ddepth，输出图像的深度，-1代表使用原图深度，即src.depth()。最重要的就是这个地方，一定要理解这点
    • 第四个参数，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，我们一般不去管它。
    这里 blur 和 boxFilter 的区别是，blur是标准化后的 boxFilter，即boxFilter的核函数：
    其中，
    [cpp] view plaincopy
     
    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标准方框滤波后的图像：
          
     

    【高斯滤波】

    高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到。高斯滤波的具体操作是：用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。

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

    2D图像中表示为：
    为了方便说明，就拿我们经常用的高斯滤波来作例子吧。 我们知道，滤波可分低通滤波和高通滤波两种。 而高斯滤波是指用高斯函数作为滤波函数的滤波操作 ，至于是不是模糊，要看是高斯低通还是高斯高通，低通就是模糊，高通就是锐化。
    C++: void GaussianBlur(InputArray src,OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, intborderType=BORDER_DEFAULT )
    • 第一个参数，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，我们一般不去管它。

    代码

    [cpp] view plaincopy
     
    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标准方框滤波后的图像：
          

    非线性滤波

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

    简单的非线性滤波有 中值滤波， -截尾均值滤波，定义域滤波 和值域滤波 。

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

    中值滤波代码

    [cpp] view plaincopy
     
    1. medianBlur ( src, dst, i );  

    中值滤波实验

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

    【双边滤波】

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

    权重系数 取决于定义域核

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

    双边滤波源码

    [cpp] view plaincopy
     
    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 plaincopy
     
    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时效果如下：
           
     


    参考文献：

    Richard Szeliski 《Computer Vision: Algorithms and Applications》
    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

     
  • 相关阅读:
    排序小结
    递推
    基准线
    毫无思绪
    计蒜客A
    尼克的任务
    售货员的难题
    Renting Boats
    工业物联网实践指南----专注生产制造活动
    阿里云单域名免费SSL证书安装
  • 原文地址：https://www.cnblogs.com/haoxing990/p/4581821.html
Copyright © 2020-2023  润新知