图像基本变换---图像快速高斯模糊算法

本文将详细介绍经典高斯滤波的相关内容。

高斯滤波器实质上是一种信号的滤波器，其用途是信号的平滑处理。它是一类根据高斯函数的形状来选择权重的线性平滑滤波器，该滤波器对于抑制服从正态分布的噪声非常有效。高斯函数的公式如下所示：

一维高斯函数：

               

二维高斯函数：

                         

对于二维高斯函数，它的分布如下图所示：

Fig.1二维Gauss分布

对于二维高斯函数，我们设置两个参数：高斯半径r和方差sigma，由半径r我们可以得到一个(2r+1)*(2r+1)大小的高斯核模板，计算函数代码如下(其中k是高斯模板的权系数，即归一化系数)：

private static double[,] GaussFuc(int r, double sigma)

        {

            int size = 2 * r + 1;

            double[,] gaussResult = new double[size, size];

            double k = 0.0;

            for (int y = -r, h = 0; y <= r; y++, h++)

            {

                for (int x = -r, w = 0; x <= r; x++, w++)

                {

                    gaussResult[w, h] = (1.0 / (2.0 * Math.PI * sigma * sigma)) * (Math.Exp(-((double)x * (double)x + (double)y * (double)y) / (2.0 * sigma * sigma)));

k += gaussResult[w, h];

                }

            }

            return gaussResult;

        }

我们设置参数r=1,sigma=1.0，则得到一个3*3的高斯模板如下：

                      Fig.2 3*3高斯模板

通常，我们在图像处理中使用的高斯函数定义如下：

使用该公式得到3*3高斯模板如下：

Fig.3 3*3高斯模板

对模板修正，即可得到我们常用的3*3经典模板：

  Fig.4经典3*3高斯模板

   这就是经典高斯模板的计算过程，半径不同，我们可以得到不同的模板。通常使用了3*3和5*5的经典模板：

         

Fig.5 Gauss 模板

   得到高斯模板后，我们用它对图像进行卷积，就可以得到高斯滤波的结果图像了。

   由于直接使用公式2-(97)，计算量巨大，影响图像处理的，因此，我们采用快速算法，即将公式2-(97)分解为如下公式：

这个公式可以理解为先对图像按行进行一次一维高斯滤波，在对结果图像按列进行一次一维高斯滤波，这样速度将大大提高。

一维高斯滤波代码如下(包含归一化)：

1. private static double[] GaussKernel1D(int r, double sigma)  
2.         {  
3.             double[] filter = new double[2 * r + 1];  
4.             double sum = 0.0;  
5.             for (int i = 0; i < filter.Length; i++)  
6.             {  
7.                 filter[i] = Math.Exp((double)(-(i - r) * (i - r)) / (2.0 * sigma * sigma));  
8.                 sum += filter[i];  
9.             }  
10.             for (int i = 0; i < filter.Length; i++)  
11.             {  
12.                 filter[i] = filter[i] / sum;  
13.             }  
14.             return filter;  
15.         } 

1. private static double[] GaussKernel(int radius, double sigma)  
2. {  
3.     int length=2*radius+1;  
4.     double[] kernel = new double[length];  
5.     double sum = 0.0;  
6.     for (int i = 0; i < length; i++)  
7.     {  
8.         kernel[i] = Math.Exp((double)(-(i - radius) * (i - radius)) / (2.0 * sigma * sigma));  
9.         sum += kernel[i];  
10.     }  
11.     for (int i = 0; i < length; i++)  
12.     {  
13.         kernel[i] = kernel[i] / sum;  
14.     }  
15.     return kernel;  
16. }  
17. ///   
18. /// Gauss filter process  
19. ///   
20. /// The source image.  
21. /// The radius of gauss kernel,from 0 to 100.  
22. /// The convince of gauss kernel, from 0 to 30.  
23. ///   
24. public static WriteableBitmap GaussFilter(WriteableBitmap src,int radius,double sigma) ////高斯滤波  
25. {  
26.     if (src != null)  
27.     {  
28.         int w = src.PixelWidth;  
29.         int h = src.PixelHeight;  
30.         WriteableBitmap srcImage = new WriteableBitmap(w, h);  
31.         byte[] srcValue = src.PixelBuffer.ToArray();  
32.         byte[] tempValue=(byte[])srcValue.Clone();  
33.         double[] kernel = GaussKernel(radius, sigma);  
34.         double tempB = 0.0, tempG = 0.0, tempR = 0.0;  
35.         int rem = 0;  
36.         int t = 0;  
37.         int v = 0;  
38.         double K = 0.0;  
39.         for (int y = 0; y < h; y++)  
40.         {  
41.             for (int x = 0; x < w; x++)  
42.             {  
43.                 tempB = tempG = tempR = 0.0;  
44.                 for (int k = -radius; k <= radius; k++)  
45.                 {  
46.                     rem = (Math.Abs(x + k) % w);  
47.                     t = rem * 4 + y * w * 4;  
48.                     K=kernel[k+radius];  
49.                     tempB += srcValue[t] * K;  
50.                     tempG += srcValue[t + 1] * K;  
51.                     tempR += srcValue[t + 2] * K;  
52.                 }  
53.                 v = x * 4 + y * w * 4;  
54.                 tempValue[v] = (byte)tempB;  
55.                 tempValue[v + 1] = (byte)tempG;  
56.                 tempValue[v + 2] = (byte)tempR;  
57.             }  
58.         }  
59.         for (int x = 0; x < w; x++)  
60.         {  
61.             for (int y = 0; y < h; y++)  
62.             {  
63.                 tempB = tempG = tempR = 0.0;  
64.                 for (int k = -radius; k <= radius; k++)  
65.                 {  
66.                     rem = (Math.Abs(y + k) % h);  
67.                     t = rem * w * 4 + x * 4;  
68.                     K = kernel[k + radius];  
69.                     tempB += tempValue[t] * K;  
70.                     tempG += tempValue[t + 1] * K;  
71.                     tempR += tempValue[t + 2] * K;  
72.                 }  
73.                 v = x * 4 + y * w * 4;  
74.                 srcValue[v] = (byte)tempB;  
75.                 srcValue[v + 1] = (byte)tempG;  
76.                 srcValue[v + 2] = (byte)tempR;  
77.             }  
78.         }  
79.         Stream sTemp = srcImage.PixelBuffer.AsStream();  
80.         sTemp.Seek(0, SeekOrigin.Begin);  
81.         sTemp.Write(srcValue, 0, w * 4 * h);  
82.         return srcImage;  
83.     }  
84.     else  
85.     {  
86.         return null;  
87.     }  
88. }  

    

demo: http://www.zealfilter.com/forum.php?mod=viewthread&tid=26&extra=page%3D2