x01.BitmapHelper：图像处理

“所有致我于死地的，也激发我胆魄”，姚贝娜的《心火》，是我近年来听过最好的歌，特此推荐一下。

图像处理，大概分三步：1.LockBits()；2.进行处理；3.UnlockBits()；这比起 C++ 来，不知清爽几许？

编程，是为了满足人的需求，所以进行灰度处理时，不是简单的 (r + g + b) / 3，而是分别乘以合适的比例值，r * 0.30 + g * 0.59 + b * 0.11。这是因为人眼对 green 最敏感，red 次之，blue 最低。

只实现了灰度处理，边缘提取，二值化，缩小，Rotate 等有限功能，代码不言自明，无需多说。

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace x01.Utilities
{
    public static class BitmapHelper
    {
        /// <summary>
        /// 对 bitmap 进行灰度处理。r,g,b 权重相加为 1。
        /// </summary>
        /// <param name="bmp">所要处理的 bitmap 对象。</param>
        /// <param name="rWeight">red 权重。</param>
        /// <param name="gWeight">green 权重。</param>
        /// <param name="bWeight">blue 权重。</param>
        public static void Gray(Bitmap bmp, float rWeight = 0.30f, float gWeight = 0.59f, float bWeight = 0.11f)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);
            for (int y = ; y < bmp.Height * data.Stride; y += data.Stride)
            {
                for (int x = ; x < bmp.Width * ; x += )
                {
                    int i = y + x;
                    byte b = buf[i];
                    byte g = buf[i + ];
                    byte r = buf[i + ];
                    buf[i] = buf[i + ] = buf[i + ] = (byte)(b * bWeight + g * gWeight + r * rWeight);
                }
            }
            Marshal.Copy(buf, , data.Scan0, buf.Length);
            bmp.UnlockBits(data);
        }

        /// <summary>
        /// 对 bitmap 进行中值滤波处理。
        /// </summary>
        /// <param name="bmp">所要处理的 bitmap 对象。</param>
        public static void MedianFilter(Bitmap bmp)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe
            {
                byte* pBuf = (byte*)data.Scan0.ToPointer();
                for (int i = ; i < bmp.Height - ; i++)
                {
                    for (int j = ; j < bmp.Width - ; j++)
                    {
                        List<byte>[] list = new List<byte>[];
                        for (int k = ; k < ; k++)
                        {
                            list[k] = new List<byte>();
                        }

                        for (int y = -; y < ; y++)
                        {
                            for (int x = -; x < ; x++)
                            {
                                int index = (i + y) * data.Stride + (j + x) * ;
                                for (int k = ; k < ; k++)
                                {
                                    list[k].Add(pBuf[index + k]);
                                }
                            }
                        }

                        for (int k = ; k < ; k++)
                        {
                            list[k].Sort();
                        }

                        int indexMedian = i * data.Stride + j * ;

                        for (int k = ; k < ; k++)
                        {
                            pBuf[indexMedian + k] = list[k][]; // 4: median value after sort.
                            list[k].Clear();
                        }

                        list = null;
                    }
                }
            }

            bmp.UnlockBits(data);
        }

        /// <summary>
        /// 获取 bitmap 所选的颜色分量直方图。
        /// </summary>
        /// <param name="bmp">所要处理的 bitmap 对象</param>
        /// <param name="bgrOffset">所选的颜色： blue=0, green=1, red=2</param>
        /// <returns>返回 256 * 256 大小的 Bitmap 直方图。</returns>
        public static Bitmap Histogram(Bitmap bmp, int bgrOffset = )
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            int[] countColors = new int[];
            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;
                    countColors[buf[index + bgrOffset]]++;
                }
            }

            bmp.UnlockBits(data);

            int maxIndex = ;
            for (int i = ; i < ; i++)
            {
                if (countColors[maxIndex] < countColors[i])
                {
                    maxIndex = i;
                }
            }

            Bitmap hist = new Bitmap(, );
            Graphics g = Graphics.FromImage(hist);
            g.Clear(Color.Wheat);
            for (int i = ; i < ; i++)
            {
                int h =  * countColors[i] / countColors[maxIndex];
                g.DrawLine(new Pen(Color.FromArgb(i, i, i), 1f), i, , i,  - h); // top bottom inverse
            }

            return hist;
        }

        public static void ExtractEdge(Bitmap bmp)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            byte[] edge = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            for (int y = ; y < bmp.Height - ; y++)
            {
                for (int x = ; x < bmp.Width - ; x++)
                {
                    int index = y * data.Stride + x * ;
                    byte gray = (byte)((buf[index] + buf[index + ] + buf[index + ]) / );

                    int value = ;
                    for (int i = -; i < ; i++) // neareat eight point
                    {
                        for (int j = -; j < ; j++)
                        {
                            if (i ==  && j == )
                            {
                                continue;
                            }

                            int index2 = (y + i) * data.Stride + (x + i) * ;
                            byte gray2 = (byte)((buf[index2] + buf[index2 + ] + buf[index2 + ]) / );
                            value += Math.Abs(gray - gray2);
                        }
                    }

                    edge[index] = edge[index + ] = edge[index + ] = (byte)(value >> );
                }
            }

            Marshal.Copy(edge, , data.Scan0, edge.Length);
            bmp.UnlockBits(data);
        }

        /// <summary>
        /// 对图像进行二值化处理。
        /// </summary>
        /// <param name="bmp">处理的图像。</param>
        /// <param name="minValue">最小阀值。</param>
        /// <param name="maxValue">最大阀值。</param>
        public static void Binary(Bitmap bmp, int minValue, int maxValue)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;
                    int gray = (buf[index] + buf[index+] +buf[index+])/;
                    if (gray >= minValue && gray <= maxValue)
                    {
                        buf[index] = buf[index + ] = buf[index + ] = ;
                    }
                    else
                    {
                        buf[index] = buf[index + ] = buf[index + ] = ;
                    }
                }
            }

            Marshal.Copy(buf, , data.Scan0, buf.Length);
            bmp.UnlockBits(data);
        }

        /// <summary>
        /// 对灰度图像进行对比度增强。
        /// </summary>
        /// <param name="bmp">灰度图像</param>
        /// <param name="srcMin">原灰度下界</param>
        /// <param name="srcMax">原灰度上界</param>
        /// <param name="destMin">目标灰度下界</param>
        /// <param name="destMax">目标灰度上界</param>
        public static void Enhance(Bitmap bmp, int srcMin, int srcMax, int destMin, int destMax)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;
                    int gray = (buf[index] + buf[index + ] + buf[index + ]) / ;
                    float value = (float)(destMax - destMin) / (srcMax - srcMin) * (gray - srcMin) + destMin;
                    buf[index] = buf[index + ] = buf[index + ] =
                        value < byte.MinValue ? byte.MinValue : (value > byte.MaxValue ? byte.MaxValue : (byte)value);
                }
            }

            Marshal.Copy(buf, , data.Scan0, buf.Length);

            bmp.UnlockBits(data);
        }

        public static void Enhance(Bitmap bmp, float n)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;
                    int gray = (buf[index] + buf[index + ] + buf[index + ]) / ;
                    float value = gray * n;
                    buf[index] = buf[index + ] = buf[index + ] =
                        value < byte.MinValue ? byte.MinValue : (value > byte.MaxValue ? byte.MaxValue : (byte)value);
                }
            }

            Marshal.Copy(buf, , data.Scan0, buf.Length);
            bmp.UnlockBits(data);
        }

        public static void ConnectRegion(Bitmap bmp)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            int sign = ;
            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;
                    if (buf[index] == )
                    {
                        SignRegion(buf, x * , y * data.Stride, sign, data.Stride, bmp.Width, bmp.Height);
                        sign += ;
                    }
                }
            }

            Marshal.Copy(buf, , data.Scan0, buf.Length);
            bmp.UnlockBits(data);
        }

        public static void SignRegion(byte[] buf, int x, int y, int sign, int stride, int width, int height)
        {
            int index = x + y;
            buf[index] = buf[index + ] = buf[index + ] = (byte)sign;

            if (x >  && buf[index -] == )    // left
            {
                SignRegion(buf, x - , y, sign, stride, width, height);
            }

            if (x < width *  -  && buf[index + ] == ) // right
            {
                SignRegion(buf, x + , y, sign, stride, width, height);
            }

            if (y >  && buf[index - stride] == )  // top
            {
                SignRegion(buf, x, y - stride, sign, stride, width, height);
            }

            if (y < height * stride && buf[index + stride] == ) // bottom
            {
                SignRegion(buf, x, y + stride, sign, stride, width, height);
            }

        }

        /// <summary>
        /// 缩小图像。
        /// </summary>
        /// <param name="bmp">图像</param>
        /// <param name="widthFactor">宽度缩小倍数</param>
        /// <param name="heightFactor">高度缩小倍数</param>
        public static void Dilation(Bitmap bmp, float widthFactor, float heightFactor)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            byte[] result = new byte[data.Stride * bmp.Height];
            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;

                    int rx = (int)(x * widthFactor);
                    int ry = (int)(y * heightFactor);
                    if (rx <  || rx >= bmp.Width || ry <  || ry >= bmp.Height)
                    {
                        continue;
                    }
                    int rindex = ry * data.Stride + rx * ;

                    result[index] = buf[rindex];
                    result[index + ] = buf[rindex + ];
                    result[index + ] = buf[rindex + ];
                }
            }

            Marshal.Copy(result, , data.Scan0, result.Length);
            bmp.UnlockBits(data);
        }

        public static void Translate(Bitmap bmp, int xOffset, int yOffset)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            byte[] result = new byte[data.Stride * bmp.Height];
            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;

                    int rx = x - xOffset;
                    int ry = y - yOffset;
                    if (rx <  || rx >= bmp.Width || ry <  || ry >= bmp.Height)
                    {
                        continue;
                    }
                    int rindex = ry * data.Stride + rx * ;

                    result[index] = buf[rindex];
                    result[index + ] = buf[rindex + ];
                    result[index + ] = buf[rindex + ];
                }
            }

            Marshal.Copy(result, , data.Scan0, result.Length);
            bmp.UnlockBits(data);
        }

        public static void Rotate(Bitmap bmp, float angle, Point center)
        {
            BitmapData data = bmp.LockBits(new Rectangle(new Point(), bmp.Size), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            byte[] buf = new byte[data.Stride * bmp.Height];
            Marshal.Copy(data.Scan0, buf, , buf.Length);

            byte[] result = new byte[data.Stride * bmp.Height];
            for (int y = ; y < bmp.Height; y++)
            {
                for (int x = ; x < bmp.Width; x++)
                {
                    int index = y * data.Stride + x * ;

                    int rx = (int)( (x - center.X) * Math.Cos(angle * Math.PI / )
                        - (y - center.Y) * Math.Sin(angle * Math.PI / )  +  center.X );
                    int ry = (int)( (x - center.X) * Math.Sin(angle * Math.PI / )
                        + (y - center.Y) * Math.Cos(angle * Math.PI / ) + center.Y );

                    if (rx <  || rx >= bmp.Width || ry <  || ry >= bmp.Height)
                    {
                        continue;
                    }
                    int rindex = ry * data.Stride + rx * ;

                    result[index] = buf[rindex];
                    result[index + ] = buf[rindex + ];
                    result[index + ] = buf[rindex + ];
                }
            }

            Marshal.Copy(result, , data.Scan0, result.Length);
            bmp.UnlockBits(data);
        }
    }
}

BitmapHelper

如果要处理图像，Paint.Net 是款不错的软件。