程序博客网 > 学通c语言要多久

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

来源：互联网 发布：学通c语言要多久 编辑：程序博客网 时间：2024/05/17 05:04

邻域滤波（卷积）


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


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


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



【方框滤波】

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

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

代码

OpenCV中的 blur函数是进行标准方框滤波：
[cpp] view plaincopyprint?
  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 plaincopyprint?
  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的核函数：
其中，
[cpp] view plaincopyprint?
  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图像中表示为：

代码

[cpp] view plaincopyprint?
  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 constfloat 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 plaincopyprint?
  1. medianBlur ( src, dst, i ); 

中值滤波实验

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


【双边滤波】

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


权重系数 取决于定义域核

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

双边滤波源码

[cpp] view plaincopyprint?
  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 plaincopyprint?
  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


转载请注明出处：http://blog.csdn.net/xiaowei_cqu/article/details/7785365

学通c语言要多久 学通c语言要多久
原创粉丝点击
热门IT博客
java值传递和引用传递java值传递和引用传递
adobe for macadobe for mac
嗅探软件
广州哪里学化妆知乎
linux配置文件目录
python中readline函数
c 11多线程编程实例
apache ftpclient上传
阿里云服务器怎么收费
常州数据分析师事务所
php可以用tomcat
eplan软件 64位
网络新词语 的形态
淘宝客转换淘口令
机械设计网络兼职
数控编程g92
电脑什么软件看跑分
碧欧泉淘宝是正品吗
网络美工是什么
php页面间传递参数
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 折叠软门帘 低温软门帘 做门帘 防蝇软门帘 室内门帘 艺术门帘 门帘棉 窗帘门帘 高档门帘 大门门帘 家用门帘 挂门帘 中式门帘 房门门帘 门帘挂钩 棉布门帘 厕所门帘 超市门帘 环保软门帘 布门帘图案 高档棉门帘 广告门帘 亮人软门帘 塑料珠门帘 自动门帘 门帘怎么挂 北方软门帘 布门帘价格 冬季门帘 办公室门帘 曲别针门帘 门帘设计 百叶门帘 门帘怎么做 门帘珠帘 掀门帘全凭一张嘴打一生肖 纱窗门帘磁性 水晶门帘厂家 歇后语 狗掀门帘 挡空调风的门帘 折叠式软门帘

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里