.net版高斯模糊算法

最近挺多人找高斯算法，本人贴上一个高斯模糊算法类，希望可以帮助到大家。算法的效率还是可以接受的。

 #region 高斯模糊算法
 /// <summary>
 /// 高斯模糊算法
 /// </summary>
 using System ;
 using System .Drawing ;
 public class Gaussian
 {
     public static double[,] Calculate1DSampleKernel(double deviation, int size)
     {
         double[,] ret = new double[size, ];
         double sum = ;
         int half = size / ;
         for (int i = ; i < size; i++)
         {
             ret[i, ] =  / (Math.Sqrt( * Math.PI) * deviation) * Math.Exp(-(i - half) * (i - half) / ( * deviation * deviation));
             sum += ret[i, ];
         }
         return ret;
     }
     public static double[,] Calculate1DSampleKernel(double deviation)
     {
         int size = (int)Math.Ceiling(deviation * ) *  + ;
         return Calculate1DSampleKernel(deviation, size);
     }
     public static double[,] CalculateNormalized1DSampleKernel(double deviation)
     {
         return NormalizeMatrix(Calculate1DSampleKernel(deviation));
     }
     public static double[,] NormalizeMatrix(double[,] matrix)
     {
         double[,] ret = new double[matrix.GetLength(), matrix.GetLength()];
         double sum = ;
         for (int i = ; i < ret.GetLength(); i++)
         {
             for (int j = ; j < ret.GetLength(); j++)
                 sum += matrix[i, j];
         }
         if (sum != )
         {
             for (int i = ; i < ret.GetLength(); i++)
             {
                 for (int j = ; j < ret.GetLength(); j++)
                     ret[i, j] = matrix[i, j] / sum;
             }
         }
         return ret;
     }
     public static double[,] GaussianConvolution(double[,] matrix, double deviation)
     {
         double[,] kernel = CalculateNormalized1DSampleKernel(deviation);
         double[,] res1 = new double[matrix.GetLength(), matrix.GetLength()];
         double[,] res2 = new double[matrix.GetLength(), matrix.GetLength()];
         //x-direction
         for (int i = ; i < matrix.GetLength(); i++)
         {
             for (int j = ; j < matrix.GetLength(); j++)
                 res1[i, j] = processPoint(matrix, i, j, kernel, );
         }
         //y-direction
         for (int i = ; i < matrix.GetLength(); i++)
         {
             for (int j = ; j < matrix.GetLength(); j++)
                 res2[i, j] = processPoint(res1, i, j, kernel, );
         }
         return res2;
     }
     private static double processPoint(double[,] matrix, int x, int y, double[,] kernel, int direction)
     {
         double res = ;
         int half = kernel.GetLength() / ;
         for (int i = ; i < kernel.GetLength(); i++)
         {
             int cox = direction ==  ? x + i - half : x;
             int coy = direction ==  ? y + i - half : y;
             if (cox >=  && cox < matrix.GetLength() && coy >=  && coy < matrix.GetLength())
             {
                 res += matrix[cox, coy] * kernel[i, ];
             }
         }
         return res;
     }
     /// <summary>
     /// 对颜色值进行灰色处理
     /// </summary>
     /// <param name="cr"></param>
     /// <returns></returns>
     private Color grayscale(Color cr)
     {
         return Color.FromArgb(cr.A, (int)(cr.R * . + cr.G * . + cr.B * 0.11),
                               (int)(cr.R * . + cr.G * . + cr.B * 0.11),
                               (int)(cr.R * . + cr.G * . + cr.B * 0.11));
     }
     /// <summary>
     /// 对图片进行高斯模糊
     /// </summary>
     /// <param name="d">模糊数值，数值越大模糊越很</param>
     /// <param name="image">一个需要处理的图片</param>
     /// <returns></returns>
     public Bitmap FilterProcessImage(double d, Bitmap image)
     {
         Bitmap ret = new Bitmap(image.Width, image.Height);
         Double[,] matrixR = new Double[image.Width, image.Height];
         Double[,] matrixG = new Double[image.Width, image.Height];
         Double[,] matrixB = new Double[image.Width, image.Height];
         for (int i = ; i < image.Width; i++)
         {
             for (int j = ; j < image.Height; j++)
             {
                 //matrix[i, j] = grayscale(image.GetPixel(i, j)).R;
                 matrixR[i, j] = image.GetPixel(i, j).R;
                 matrixG[i, j] = image.GetPixel(i, j).G;
                 matrixB[i, j] = image.GetPixel(i, j).B;
             }
         }
         matrixR = Gaussian.GaussianConvolution(matrixR, d);
         matrixG = Gaussian.GaussianConvolution(matrixG, d);
         matrixB = Gaussian.GaussianConvolution(matrixB, d);
         for (int i = ; i < image.Width; i++)
         {
             for (int j = ; j < image.Height; j++)
             {
                 Int32 R = (int)Math.Min(, matrixR[i, j]);
                 Int32 G = (int)Math.Min(, matrixG[i, j]);
                 Int32 B = (int)Math.Min(, matrixB[i, j]);
                 ret.SetPixel(i, j, Color.FromArgb(R, G, B));
             }
         }
         return ret;
     }
 }
 #endregion