Bitmap的优化

摘自：http://www.codeproject.com/Tips/240428/Work-with-bitmap-faster-with-Csharp#_rating

作者：Vano Maisuradze

　　当你在C#中操作bitmaps时，你可以使用 GetPixel(x ,y) 和 SetPixel(x, y, color) 去获取/设置特定像素的值。但是它们十分的慢。

　　这里有另一种更快的方法去操作bitmaps。

LockBitmap

　　使用LockBitmap类，我们可以锁定/解锁bitmaps的数据

　　（PS：这里定义一个类LockBitmap，锁定时把bitmap所有像素的数据拷贝在一个数组上，操作时就是在数组上直接操作，避免了对bitmap的直接操作，解锁后就拷贝回到bitmap中。）

public class LockBitmap
{
    Bitmap source = null;
    IntPtr Iptr = IntPtr.Zero;
    BitmapData bitmapData = null;
 
    public byte[] Pixels { get; set; }
    public int Depth { get; private set; }
    public int Width { get; private set; }
    public int Height { get; private set; }
 
    public LockBitmap(Bitmap source)
    {
        this.source = source;
    }
 
    /// <summary>
    /// Lock bitmap data
    /// </summary>
    public void LockBits()
    {
        try
        {
            // Get width and height of bitmap
            Width = source.Width;
            Height = source.Height;
 
            // get total locked pixels count
            int PixelCount = Width * Height;
 
            // Create rectangle to lock
            Rectangle rect = new Rectangle(0, 0, Width, Height);
 
            // get source bitmap pixel format size
            Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);
 
            // Check if bpp (Bits Per Pixel) is 8, 24, or 32
            if (Depth != 8 && Depth != 24 && Depth != 32)
            {
                throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
            }
 
            // Lock bitmap and return bitmap data
            bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite, 
                                         source.PixelFormat);
 
            // create byte array to copy pixel values
            int step = Depth / 8;
            Pixels = new byte[PixelCount * step];
            Iptr = bitmapData.Scan0;
 
            // Copy data from pointer to array
            Marshal.Copy(Iptr, Pixels, 0, Pixels.Length);
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
 
    /// <summary>
    /// Unlock bitmap data
    /// </summary>
    public void UnlockBits()
    {
        try
        {
            // Copy data from byte array to pointer
            Marshal.Copy(Pixels, 0, Iptr, Pixels.Length);
 
            // Unlock bitmap data
            source.UnlockBits(bitmapData);
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
 
    /// <summary>
    /// Get the color of the specified pixel
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    public Color GetPixel(int x, int y)
    {
        Color clr = Color.Empty;
 
        // Get color components count
        int cCount = Depth / 8;
 
        // Get start index of the specified pixel
        int i = ((y * Width) + x) * cCount;
 
        if (i > Pixels.Length - cCount)
            throw new IndexOutOfRangeException();
 
        if (Depth == 32) // For 32 bpp get Red, Green, Blue and Alpha
        {
            byte b = Pixels[i];
            byte g = Pixels[i + 1];
            byte r = Pixels[i + 2];
            byte a = Pixels[i + 3]; // a
            clr = Color.FromArgb(a, r, g, b);
        }
        if (Depth == 24) // For 24 bpp get Red, Green and Blue
        {
            byte b = Pixels[i];
            byte g = Pixels[i + 1];
            byte r = Pixels[i + 2];
            clr = Color.FromArgb(r, g, b);
        }
        if (Depth == 8)
        // For 8 bpp get color value (Red, Green and Blue values are the same)
        {
            byte c = Pixels[i];
            clr = Color.FromArgb(c, c, c);
        }
        return clr;
    }
 
    /// <summary>
    /// Set the color of the specified pixel
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <param name="color"></param>
    public void SetPixel(int x, int y, Color color)
    {
        // Get color components count
        int cCount = Depth / 8;
 
        // Get start index of the specified pixel
        int i = ((y * Width) + x) * cCount;
 
        if (Depth == 32) // For 32 bpp set Red, Green, Blue and Alpha
        {
            Pixels[i] = color.B;
            Pixels[i + 1] = color.G;
            Pixels[i + 2] = color.R;
            Pixels[i + 3] = color.A;
        }
        if (Depth == 24) // For 24 bpp set Red, Green and Blue
        {
            Pixels[i] = color.B;
            Pixels[i + 1] = color.G;
            Pixels[i + 2] = color.R;
        }
        if (Depth == 8)
        // For 8 bpp set color value (Red, Green and Blue values are the same)
        {
            Pixels[i] = color.B;
        }
    }
}

测试方法

　　我们可以使用Benchmark类去测试LockBitmap的性能。

public class Benchmark
{
    private static DateTime startDate = DateTime.MinValue;
    private static DateTime endDate = DateTime.MinValue;
 
    public static TimeSpan Span { get { return endDate.Subtract(startDate); } }
 
    public static void Start() { startDate = DateTime.Now; }
 
    public static void End() { endDate = DateTime.Now; }
 
    public static double GetSeconds()
    {
        if (endDate == DateTime.MinValue) return 0.0;
        else return Span.TotalSeconds;
    }
}

使用方法

　　现在，我们可以使用LockBitmap类非常快地去操作bitmap。

public void ChangeColor()
{
    Bitmap bmp = (Bitmap)Image.FromFile(d:\source.png);
    Benchmark.Start();
    LockBitmap lockBitmap = new LockBitmap(bmp);
    lockBitmap.LockBits();
 
    Color compareClr = Color.FromArgb(255, 255, 255, 255);
    for (int y = 0; y < lockBitmap.Height; y++)
    {
        for (int x = 0; x < lockBitmap.Width; x++)
        {
            if (lockBitmap.GetPixel(x, y) == compareClr)
            {
                lockBitmap.SetPixel(x, y, Color.Red);
            }
        }
    }
    lockBitmap.UnlockBits();
    Benchmark.End();
    double seconds = Benchmark.GetSeconds();
    bmp.Save(d:\result.png);
}

 　　(PS：原作者的使用样例包含了测试样例，笔者在这里给大家一个只有LockBitmap类的使用样例。） 

string file = @"C:	est.jpg";
Bitmap bmp = new Bitmap(file);
LockBitmap lockbmp = new LockBitmap(bmp);

//锁定bitmap
lockbmp.lockBits();

//通过GetPixel获取像素信息
Color color = lockbmp.GetPixel(0, 0);

//通过SetPixel设置像素信息
lockbmp.SetPixel(0, 0, Color.Black);

//解锁bitmap
lockbmp.UnlockBits();

---

摘自：https://www.codeproject.com/tips/285577/workwithbitmapsfasterincsharp#alternative3

作者：danlobo

　　（PS：这个帖子只是在LockBitmap的基础上继承了IDisposable接口）

　　总的来说，它涉及改变：

public class LockBitmap

　　变为：

public class LockBitmap : IDisposable

　　构造函数：

public LockBitmap(Bitmap source)
{
    this.source = source;
}

 　　变为：

public LockBitmap(Bitmap source)
{
    this.source = source;
    LockBits();
}

　　并且新增一个函数：

public void Dispose()
{
   UnlockBits();
}

　　因此，这个类的使用方法，从这样：

LockBitmap lockBitmap = new LockBitmap(bmp);
lockBitmap.LockBits();
(...)
lockBitmap.UnlockBits();

　　变为这样：

using(LockBitmap lockBitmap = new LockBitmap(bmp))
{
    (...)
}

　　我认为这样更加优雅。（PS：more elegant, IMO.)

---

摘自：http://www.cnblogs.com/bomo/archive/2013/02/26/2934055.html

作者：bomo

（PS：这是网上的另一种方法，但笔者更推荐第一种，也就是LockBitmap）

指针法

　　这种方法访问速度比内存法更快，直接通过指针对内存进行操作，不需要进行拷贝，但是在C#中直接通过指针操作内存是不安全的，所以需要在代码中加入unsafe关键字，在生成选项中把允许不安全代码勾上，才能编译通过。

　　这里定义成PointerBitmap类。 

public class PointBitmap
{
    Bitmap source = null;
    IntPtr Iptr = IntPtr.Zero;
    BitmapData bitmapData = null;

    public int Depth { get; private set; }
    public int Width { get; private set; }
    public int Height { get; private set; }

    public PointBitmap(Bitmap source)
    {
        this.source = source;
    }

    public void LockBits()
    {
        try
        {
            // Get width and height of bitmap
            Width = source.Width;
            Height = source.Height;

            // get total locked pixels count
            int PixelCount = Width * Height;

            // Create rectangle to lock
            Rectangle rect = new Rectangle(0, 0, Width, Height);

            // get source bitmap pixel format size
            Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);

            // Check if bpp (Bits Per Pixel) is 8, 24, or 32
            if (Depth != 8 && Depth != 24 && Depth != 32)
            {
                throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
            }

            // Lock bitmap and return bitmap data
            bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite,
                                         source.PixelFormat);

            //得到首地址
            unsafe
            {
                Iptr = bitmapData.Scan0;
                //二维图像循环

            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

    public void UnlockBits()
    {
        try
        {
            source.UnlockBits(bitmapData);
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

    public Color GetPixel(int x, int y)
    {
        unsafe
        {
            byte* ptr = (byte*)Iptr;
            ptr = ptr + bitmapData.Stride * y;
            ptr += Depth * x / 8;
            Color c = Color.Empty;
            if (Depth == 32)
            {
                int a = ptr[3];
                int r = ptr[2];
                int g = ptr[1];
                int b = ptr[0];
                c = Color.FromArgb(a, r, g, b);
            }
            else if (Depth == 24)
            {
                int r = ptr[2];
                int g = ptr[1];
                int b = ptr[0];
                c = Color.FromArgb(r, g, b);
            }
            else if (Depth == 8)
            {
                int r = ptr[0];
                c = Color.FromArgb(r, r, r);
            }
            return c;
        }
    }

    public void SetPixel(int x, int y, Color c)
    {
        unsafe
        {
            byte* ptr = (byte*)Iptr;
            ptr = ptr + bitmapData.Stride * y;
            ptr += Depth * x / 8;
            if (Depth == 32)
            {
                ptr[3] = c.A;
                ptr[2] = c.R;
                ptr[1] = c.G;
                ptr[0] = c.B;
            }
            else if (Depth == 24)
            {
                ptr[2] = c.R;
                ptr[1] = c.G;
                ptr[0] = c.B;
            }
            else if (Depth == 8)
            {
                ptr[2] = c.R;
                ptr[1] = c.G;
                ptr[0] = c.B;
            }
        }
    }
}

 　　（PS：使用方法这里就不列出来了，跟上面的LockBitmap类似。）