[共享] 借助GDI+1.1中的函数实现高斯模糊、USM锐化等经典效果。

GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect *effect, RECT *roi, BOOL useAuxData, VOID **auxData, INT *auxDataSize)

  

[DllImport( "gdiplus.dll",SetLastError = true, ExactSpelling = true,CharSet = CharSet.Unicode)]

        private static extern int GdipBitmapApplyEffect(IntPtr bitmap, IntPtr effect, ref Rectangle rectOfInterest, bool useAuxData, IntPtr auxData, int auxDataSize);

 internal static TResult GetPrivateField<TResult>(this object obj, string fieldName)

        {

            if (obj == null) return default(TResult);

            Type ltType = obj.GetType();

            FieldInfo lfiFieldInfo = ltType.GetField( fieldName,System.Reflection.BindingFlags.GetField |System.Reflection.BindingFlags.Instance |System.Reflection.BindingFlags.NonPublic);

            if (lfiFieldInfo != null)

                return (TResult)lfiFieldInfo.GetValue(obj);

            else

                throw new InvalidOperationException(string.Format("Instance field '{0}' could not be located in object of type '{1}'.",fieldName, obj.GetType().FullName));

        }

        public static IntPtr NativeHandle(this Bitmap Bmp)

        {

            return Bmp.GetPrivateField<IntPtr>("nativeImage");

            /*  用Reflector反编译System.Drawing.Dll可以看到Image类有如下的私有字段

                internal IntPtr nativeImage;

                private byte[] rawData;

                private object userData;

                然后还有一个 SetNativeImage函数

                internal void SetNativeImage(IntPtr handle)

                {

                    if (handle == IntPtr.Zero)

                    {

                        throw new ArgumentException(SR.GetString("NativeHandle0"), "handle");

                    }

                    this.nativeImage = handle;

                }

                这里在看看FromFile等等函数，其实也就是调用一些例如GdipLoadImageFromFile之类的GDIP函数，并把返回的GDIP图像句柄

                通过调用SetNativeImage赋值给变量nativeImage，因此如果我们能获得该值，就可以调用VS2010暂时还没有封装的GDIP函数

                进行相关处理了，并且由于.NET肯定已经初始化过了GDI+，我们也就无需在调用GdipStartup初始化他了。

             */

        }

/// <summary>

        /// 对图像进行高斯模糊,参考：http://msdn.microsoft.com/en-us/library/ms534057(v=vs.85).aspx

        /// </summary>

        /// <param name="Rect">需要模糊的区域，会对该值进行边界的修正并返回.</param>

        /// <param name="Radius">指定高斯卷积核的半径，有效范围[0，255],半径越大，图像变得越模糊.</param>

        /// <param name="ExpandEdge">指定是否对边界进行扩展，设置为True，在边缘处可获得较为柔和的效果. </param>

            

        public static void GaussianBlur(this Bitmap Bmp, ref Rectangle Rect, float Radius = 10, bool ExpandEdge = false)

        {

            int Result;

            IntPtr BlurEffect;

            BlurParameters BlurPara;

            if ((Radius <0) || (Radius>255)) 

            {

                throw new ArgumentOutOfRangeException("半径必须在[0,255]范围内");

            }

            BlurPara.Radius = Radius ;

            BlurPara.ExpandEdges = ExpandEdge;

            Result = GdipCreateEffect(BlurEffectGuid, out BlurEffect);

            if (Result == 0)

            {

                IntPtr Handle = Marshal.AllocHGlobal(Marshal.SizeOf(BlurPara));

                Marshal.StructureToPtr(BlurPara, Handle, true);

                GdipSetEffectParameters(BlurEffect, Handle, (uint)Marshal.SizeOf(BlurPara));

                GdipBitmapApplyEffect(Bmp.NativeHandle(), BlurEffect, ref Rect, false, IntPtr.Zero, 0);

                // 使用GdipBitmapCreateApplyEffect函数可以不改变原始的图像，而把模糊的结果写入到一个新的图像中

                GdipDeleteEffect(BlurEffect);

                Marshal.FreeHGlobal(Handle);

            }

            else

            {

                throw new ExternalException("不支持的GDI+版本，必须为GDI+1.1及以上版本，且操作系统要求为Win Vista及之后版本.");

            }

        }

#region 高斯模糊算法

    /// <summary>

    /// 高斯模糊算法

    /// </summary>

    public class Gaussian

    {

        public static double[,] Calculate1DSampleKernel(double deviation, int size)

        {

            double[,] ret = new double[size, 1];

            double sum = 0;

            int half = size / 2;

            for (int i = 0; i < size; i++)

            {

                ret[i, 0] = 1 / (Math.Sqrt(2 * Math.PI) * deviation) * Math.Exp(-(i - half) * (i - half) / (2 * deviation * deviation));

                sum += ret[i, 0];

            }

            return ret;

        }

        public static double[,] Calculate1DSampleKernel(double deviation)

        {

            int size = (int)Math.Ceiling(deviation * 3) * 2 + 1;

            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(0), matrix.GetLength(1)];

            double sum = 0;

            for (int i = 0; i < ret.GetLength(0); i++)

            {

                for (int j = 0; j < ret.GetLength(1); j++)

                    sum += matrix[i, j];

            }

            if (sum != 0)

            {

                for (int i = 0; i < ret.GetLength(0); i++)

                {

                    for (int j = 0; j < ret.GetLength(1); 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(0), matrix.GetLength(1)];

            double[,] res2 = new double[matrix.GetLength(0), matrix.GetLength(1)];

            //x-direction

            for (int i = 0; i < matrix.GetLength(0); i++)

            {

                for (int j = 0; j < matrix.GetLength(1); j++)

                    res1[i, j] = processPoint(matrix, i, j, kernel, 0);

            }

            //y-direction

            for (int i = 0; i < matrix.GetLength(0); i++)

            {

                for (int j = 0; j < matrix.GetLength(1); j++)

                    res2[i, j] = processPoint(res1, i, j, kernel, 1);

            }

            return res2;

        }

        private static double processPoint(double[,] matrix, int x, int y, double[,] kernel, int direction)

        {

            double res = 0;

            int half = kernel.GetLength(0) / 2;

            for (int i = 0; i < kernel.GetLength(0); i++)

            {

                int cox = direction == 0 ? x + i - half : x;

                int coy = direction == 1 ? y + i - half : y;

                if (cox >= 0 && cox < matrix.GetLength(0) && coy >= 0 && coy < matrix.GetLength(1))

                {

                    res += matrix[cox, coy] * kernel[i, 0];

                }

            }

            return res;

        }

        /// <summary>

        /// 对颜色值进行灰色处理

        /// </summary>

        /// <param name="cr"></param>

        /// <returns></returns>

        private Color grayscale(Color cr)

        {

            return Color.FromArgb(cr.A, (int)(cr.R * .3 + cr.G * .59 + cr.B * 0.11),

               (int)(cr.R * .3 + cr.G * .59 + cr.B * 0.11),

              (int)(cr.R * .3 + cr.G * .59 + 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 = 0; i < image.Width; i++)

            {

                for (int j = 0; 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 = 0; i < image.Width; i++)

            {

                for (int j = 0; j < image.Height; j++)

                {

                    Int32 R = (int)Math.Min(255, matrixR[i, j]);

                    Int32 G = (int)Math.Min(255, matrixG[i, j]);

                    Int32 B = (int)Math.Min(255, matrixB[i, j]);

                    ret.SetPixel(i, j, Color.FromArgb(R, G, B));

                }

            }

            return ret;

        }



    }

    #endregion

补充：.NET技术 ,  C#

上一个：c# 如何立刻刷新桌面
下一个：ASP.NET sessionState配置为"StateServer"值ajax提交数据失败