IIR递归高斯滤波总结

2024-08-25 23:48
文章标签 总结 递归 高斯 滤波 iir

本文主要是介绍IIR递归高斯滤波总结,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

本文主要总结递归高斯算法的基本原理,分析,实现,指令优化实现等


原始高斯滤波算法计算量很大,网上资料很多,不赘述了,自行search

二维高斯滤波在图像处理中非常非常重要,最常见的是高斯模糊,做模糊滤镜,其本质是空域的低通滤波器,在本人另外的两篇博客同态滤波和MSRCR中有提及。对于同态滤波,需要对对数变换后的结果进行高通滤波,常规是变换到频域进行处理,也可以不进行频域变换,直接进行空域高斯滤波实现低通滤波,然后再用减法实现高通滤波。对于MSRCR算法,每个颜色通道需要进行三个强度的高斯滤波,复杂度可想而知。而且常规的高斯滤波需要考虑滤波窗大小,可以自己参考opencv里面的高斯滤波,可以自己搜一下复杂度分析,对于视频等实时处理,原始算法显然没什么实用性。

后面有人提出先进行水平一维滤波,然后再进行竖直方向一维滤波,对于一个点的滤波,计算数据量由NxN减少为2*N,但还是和窗口大小N有关


有看到一种递归减半滤波平面大小的递归实现,原理不太清楚,可参考如下资料,文中fastFilter函数的定义:

http://blog.csdn.net/smallstones/article/details/41787079


然后是本文主要介绍的IIR递归高斯滤波,这个滤波器能近似接近高斯滤波器,也是分成两次一维滤波,关键是不需要设定滤波窗口大小,复杂度跟窗口大小无关,对于一维滤波先进行一次正向滤波,然后进行一次逆向滤波,所以对于大小为NXN大小的二维矩阵,计算复杂度为O(NXN)

计算公式参考:

http://www.cnblogs.com/ImageVision/archive/2012/06/11/2545555.html


实现代码:

GIMP中有代码:http://gimp.sourcearchive.com/documentation/2.6.1/contrast-retinex_8c-source.html

[html]  view plain copy
  1. typedef struct  
  2. {  
  3.   gint     scale;  
  4.   gint     nscales;  
  5.   gint     scales_mode;  
  6.   gfloat   cvar;  
  7. } RetinexParams;  
  8.   
  9.   
  10. /*  
  11.  * Calculate the coefficients for the recursive filter algorithm  
  12.  * Fast Computation of gaussian blurring.  
  13.  */  
  14. static void  
  15. compute_coefs3 (gauss3_coefs *c, gfloat sigma)  
  16. {  
  17.   /*  
  18.    * Papers:  "Recursive Implementation of the gaussian filter.",  
  19.    *          Ian T. Young , Lucas J. Van Vliet, Signal Processing 44, Elsevier 1995.  
  20.    * formula: 11b       computation of q  
  21.    *          8c        computation of b0..b1  
  22.    *          10        alpha is normalization constant B  
  23.    */  
  24.   gfloat q, q2, q3;  
  25.   
  26.   q = 0;  
  27.   
  28.   if (sigma >= 2.5)  
  29.     {  
  30.       q = 0.98711 * sigma - 0.96330;  
  31.     }  
  32.   else if ((sigma >= 0.5) && (sigma < 2.5))  
  33.     {  
  34.       q = 3.97156 - 4.14554 * (gfloat) sqrt ((double) 1 - 0.26891 * sigma);  
  35.     }  
  36.   else  
  37.     {  
  38.       q = 0.1147705018520355224609375;  
  39.     }  
  40.   
  41.   q2 = q * q;  
  42.   q3 = q * q2;  
  43.   c->b[0] = (1.57825+(2.44413*q)+(1.4281 *q2)+(0.422205*q3));  
  44.   c->b[1] = (        (2.44413*q)+(2.85619*q2)+(1.26661 *q3));  
  45.   c->b[2] = (                   -((1.4281*q2)+(1.26661 *q3)));  
  46.   c->b[3] = (                                 (0.422205*q3));  
  47.   c->B = 1.0-((c->b[1]+c->b[2]+c->b[3])/c->b[0]);  
  48.   c->sigma = sigma;  
  49.   c->N = 3;  
  50.   
  51. /*  
  52.   g_printerr ("q %f\n", q);  
  53.   g_printerr ("q2 %f\n", q2);  
  54.   g_printerr ("q3 %f\n", q3);  
  55.   g_printerr ("c->b[0] %f\n", c->b[0]);  
  56.   g_printerr ("c->b[1] %f\n", c->b[1]);  
  57.   g_printerr ("c->b[2] %f\n", c->b[2]);  
  58.   g_printerr ("c->b[3] %f\n", c->b[3]);  
  59.   g_printerr ("c->B %f\n", c->B);  
  60.   g_printerr ("c->sigma %f\n", c->sigma);  
  61.   g_printerr ("c->N %d\n", c->N);  
  62. */  
  63. }  
  64.   
  65. static void  
  66. gausssmooth (gfloat *in, gfloat *out, gint size, gint rowstride, gauss3_coefs *c)  
  67. {  
  68.   /*  
  69.    * Papers:  "Recursive Implementation of the gaussian filter.",  
  70.    *          Ian T. Young , Lucas J. Van Vliet, Signal Processing 44, Elsevier 1995.  
  71.    * formula: 9a        forward filter  
  72.    *          9b        backward filter  
  73.    *          fig7      algorithm  
  74.    */  
  75.   gint i,n, bufsize;  
  76.   gfloat *w1,*w2;  
  77.   
  78.   /* forward pass */  
  79.   bufsize = size+3;  
  80.   size -1;  
  81.   w1 = (gfloat *) g_try_malloc (bufsize * sizeof (gfloat));  
  82.   w2 = (gfloat *) g_try_malloc (bufsize * sizeof (gfloat));  
  83.   w1[0] = in[0];  
  84.   w1[1] = in[0];  
  85.   w1[2] = in[0];  
  86.   for ( i = 0 , n=3; i <= size ; i++, n++)  
  87.     {  
  88.       w1[n] = (gfloat)(c->B*in[i*rowstride] +  
  89.                        ((c->b[1]*w1[n-1] +  
  90.                          c->b[2]*w1[n-2] +  
  91.                          c->b[3]*w1[n-3] ) / c->b[0]));  
  92.     }  
  93.   
  94.   /* backward pass */  
  95.   w2[size+1]= w1[size+3];  
  96.   w2[size+2]= w1[size+3];  
  97.   w2[size+3]= w1[size+3];  
  98.   for (i = sizen = i; i >= 0; i--, n--)  
  99.     {  
  100.       w2[n]= out[i * rowstride] = (gfloat)(c->B*w1[n] +  
  101.                                            ((c->b[1]*w2[n+1] +  
  102.                                              c->b[2]*w2[n+2] +  
  103.                                              c->b[3]*w2[n+3] ) / c->b[0]));  
  104.     }  
  105.   
  106.   g_free (w1);  
  107.   g_free (w2);  
  108. }  
[html]  view plain copy
  1.   

[cpp]  view plain copy
  1. /* 
  2.  @function: 1channel 2D gauss filter 
  3.  */  
  4. void gausssmooth1ch(float *src, float *dst, int width, int height, gauss3_coefs *c)  
  5. {  
  6.     for (int y=0; y<height; y++) {  
  7.         gausssmooth(src+y*width, dst+y*width, width, 1, c);  
  8.     }  
  9.       
  10.     for (int x=0; x<width; x++) {  
  11.         gausssmooth(dst+x, dst+x, height, width, c);  
  12.     }  
  13.       
  14. }  




加速实现:

intel有详细的介绍和SSE实现:https://software.intel.com/en-us/articles/iir-gaussian-blur-filter-implementation-using-intel-advanced-vector-extensions

总而言之,这个算法非常非常实用



这篇关于IIR递归高斯滤波总结的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1106969

相关文章

HarmonyOS学习(七)——UI(五)常用布局总结

自适应布局 1.1、线性布局(LinearLayout) 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列,Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距,达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式,且在各类尺寸屏幕上表现一致,其中交叉轴为垂直时,取值为Vert

学习hash总结

2014/1/29/   最近刚开始学hash,名字很陌生,但是hash的思想却很熟悉,以前早就做过此类的题,但是不知道这就是hash思想而已,说白了hash就是一个映射,往往灵活利用数组的下标来实现算法,hash的作用:1、判重;2、统计次数;

Open3D 基于法线的双边滤波

目录 一、概述 1.1原理 1.2实现步骤 1.3应用场景 二、代码实现 2.1关键函数 输入参数: 输出参数: 参数影响: 2.2完整代码 三、实现效果 3.1原始点云 3.2滤波后点云 Open3D点云算法汇总及实战案例汇总的目录地址: Open3D点云算法与点云深度学习案例汇总(长期更新)-CSDN博客 一、概述         基于法线的双边

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程(Gaussian Process,简称GP)是一种概率模型,用于描述一组随机变量的联合概率分布,其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数(或核函数) 1.3 核函数1.4 高斯过程回归(Gauss

git使用的说明总结

Git使用说明 下载安装(下载地址) macOS: Git - Downloading macOS Windows: Git - Downloading Windows Linux/Unix: Git (git-scm.com) 创建新仓库 本地创建新仓库:创建新文件夹,进入文件夹目录,执行指令 git init ,用以创建新的git 克隆仓库 执行指令用以创建一个本地仓库的

二分最大匹配总结

HDU 2444  黑白染色 ,二分图判定 const int maxn = 208 ;vector<int> g[maxn] ;int n ;bool vis[maxn] ;int match[maxn] ;;int color[maxn] ;int setcolor(int u , int c){color[u] = c ;for(vector<int>::iter

整数Hash散列总结

方法:    step1  :线性探测  step2 散列   当 h(k)位置已经存储有元素的时候,依次探查(h(k)+i) mod S, i=1,2,3…,直到找到空的存储单元为止。其中,S为 数组长度。 HDU 1496   a*x1^2+b*x2^2+c*x3^2+d*x4^2=0 。 x在 [-100,100] 解的个数  const int MaxN = 3000

状态dp总结

zoj 3631  N 个数中选若干数和(只能选一次)<=M 的最大值 const int Max_N = 38 ;int a[1<<16] , b[1<<16] , x[Max_N] , e[Max_N] ;void GetNum(int g[] , int n , int s[] , int &m){ int i , j , t ;m = 0 ;for(i = 0 ;

6.4双边滤波

目录 实验原理 示例代码1 运行结果1 实验代码2 运行结果2 实验原理 双边滤波(Bilateral Filtering)是一种非线性滤波技术,用于图像处理中去除噪声,同时保留边缘和细节。这种滤波器结合了空间邻近性和像素值相似性的双重加权,从而能够在去噪(平滑图像)的同时保留图像的边缘细节。双边滤波器能够在的同时,保持边缘清晰,因此非常适合用于去除噪声和保持图像特征。在Op

go基础知识归纳总结

无缓冲的 channel 和有缓冲的 channel 的区别? 在 Go 语言中,channel 是用来在 goroutines 之间传递数据的主要机制。它们有两种类型:无缓冲的 channel 和有缓冲的 channel。 无缓冲的 channel 行为:无缓冲的 channel 是一种同步的通信方式,发送和接收必须同时发生。如果一个 goroutine 试图通过无缓冲 channel