编写高效的C#图像处理程序

前些天阅读《各种图像处理类库的比较及选择(The Comparison of Image Processing Libraries)》，对后面的比较结果感觉怪异。对计算密集型运算，C#和C/C++的性能应该差别不大才是。为了探讨问题，做了以下实验。

本实验比较了五种方式进行图像灰度化计算：

（1）EmguCV实现，见 《各种图像处理类库的比较及选择(The Comparison of Image Processing Libraries)》 文中代码

（2）OpenCV/PInvoke实现，见 《各种图像处理类库的比较及选择(The Comparison of Image Processing Libraries)》 文中代码

（3）BitmapData实现，见 《各种图像处理类库的比较及选择(The Comparison of Image Processing Libraries)》 文中代码

（4）Array实现（ArgbImage8），核心代码如下:

（每一个）ImageChannel8 内含1个Byte数组Data。GrayscaleImage8  继承自 ImageChannel8 。

1.     public class ArgbImage8 : ImageChannelSet8
   
2.     {
   
3.         public ImageChannel8 A { get { return this.Channels[0]; } }
   
4.         public ImageChannel8 R { get { return this.Channels[0]; } }
   
5.         public ImageChannel8 G { get { return this.Channels[0]; } }
   
6.         public ImageChannel8 B { get { return this.Channels[0]; } }
   
7. 
   
8.         public ArgbImage8(int width, int height)
   
9.             : base(4, width, height)
   
10.         {
    
11.         }
    
12. 
    
13.         public GrayscaleImage8 ToGrayscaleImage()
    
14.         {
    
15.             return ToGrayscaleImage(0.299, 0.587, 0.114);
    
16.         }
    
17. 
    
18.         public GrayscaleImage8 ToGrayscaleImage(double rCoeff, double gCoeff, double bCoeff)
    
19.         {
    
20.             GrayscaleImage8 img = new GrayscaleImage8(this.Width, this.Height);
    
21.             Byte[] r = R.Data;
    
22.             Byte[] g = G.Data;
    
23.             Byte[] b = B.Data;
    
24.             Byte[] dst = img.Data;
    
25. 
    
26.             for (int i = 0; i < r.Length; i++)
    
27.             {
    
28.                 dst = (Byte)(r * rCoeff + g * gCoeff + b * bCoeff);
    
29.             }
    
30. 
    
31.             return img;
    
32.         }
    
33. 
    
34.         //性能低下，先这样写了
    
35.         public static ArgbImage8 CreateFromBitmap(Bitmap map)
    
36.         {
    
37.             if (map == null) throw new ArgumentNullException("map");
    
38. 
    
39.             ArgbImage8 img = new ArgbImage8(map.Width, map.Height);
    
40.             Byte[] a = img.A.Data;
    
41.             Byte[] r = img.R.Data;
    
42.             Byte[] g = img.G.Data;
    
43.             Byte[] b = img.B.Data;
    
44. 
    
45.             for (int row = 0; row < img.Height; row++)
    
46.             {
    
47.                 for (int col = 0; col < img.Width; col++)
    
48.                 {
    
49.                     int index = row * img.Width + col;
    
50.                     Color c = map.GetPixel(col, row);
    
51.                     a[index] = c.A;
    
52.                     r[index] = c.R;
    
53.                     r[index] = c.R;
    
54.                     r[index] = c.R;
    
55.                 }
    
56.             }
    
57. 
    
58.             return img;
    
59.         }
    
60.     }
    

复制代码

（5）C# 指针/unsafe 实现（ArgbImage32 ），核心代码如下：

1.     public class UnmanagedMemory<T> : IDisposable
   
2.         where T : struct
   
3.     {
   
4.         public Int32 ByteCount { get; private set; }
   
5.         public Int32 Length { get; private set; }
   
6.         public IntPtr Start { get; private set; }
   
7.         public Int32 SizeOfType { get; private set; }
   
8. 
   
9.         public UnmanagedMemory(Int32 length)
   
10.         {
    
11.             Length = length;
    
12.             SizeOfType = SizeOfT();
    
13.             ByteCount = SizeOfType * length;
    
14.             Start = Marshal.AllocHGlobal(ByteCount);
    
15.         }
    
16. 
    
17.         public void Dispose()
    
18.         {
    
19.             Dispose(true);
    
20.             GC.SuppressFinalize(this);
    
21.         }
    
22. 
    
23.         protected virtual void Dispose(bool disposing)
    
24.         {
    
25.             if (false == disposed)
    
26.             {
    
27.                 disposed = true;
    
28.                 Marshal.FreeHGlobal(Start);
    
29.             }
    
30.         }
    
31. 
    
32.         private bool disposed;
    
33. 
    
34.         ~UnmanagedMemory()
    
35.         {
    
36.             Dispose(false);
    
37.         }
    
38. 
    
39.         private Int32 SizeOfT()
    
40.         {
    
41.             return Marshal.SizeOf(typeof(T));
    
42.         }
    
43.     }
    
44. 
    
45. 
    
46.     public struct Argb32
    
47.     {
    
48.         public Byte Alpha;
    
49.         public Byte Red;
    
50.         public Byte Green;
    
51.         public Byte Blue;
    
52.     }
    
53. 
    
54.     public class Argb32Image : UnmanagedMemory<Argb32>
    
55.     {
    
56.         private unsafe Argb32* m_pointer;
    
57. 
    
58.         public unsafe Argb32* Pointer { get { return m_pointer; } }
    
59. 
    
60.         public unsafe Argb32Image(int length)
    
61.             : base(length)
    
62.         {
    
63.             m_pointer = (Argb32*)this.Start;
    
64.         }
    
65. 
    
66.         public unsafe Argb32 this[int index]
    
67.         {
    
68.             get { return *(m_pointer + index); }
    
69.             set { *(m_pointer + index) = value; }
    
70.         }
    
71. 
    
72.         public Grayscale8Image ToGrayscaleImage()
    
73.         {
    
74.             return ToGrayscaleImage(0.299, 0.587, 0.114);
    
75.         }
    
76. 
    
77.         public unsafe Grayscale8Image ToGrayscaleImage(double rCoeff, double gCoeff, double bCoeff)
    
78.         {
    
79.             Grayscale8Image img = new Grayscale8Image(this.Length);
    
80.             Argb32* p = Pointer;
    
81.             Byte* to = img.Pointer;
    
82.             Argb32* end = p + Length;
    
83. 
    
84.             while (p != end)
    
85.             {
    
86.                 *to = (Byte)(p->Red * rCoeff + p->Green * gCoeff + p->Blue * bCoeff);
    
87.                 p++;
    
88.                 to++;
    
89.             }
    
90.             return img;
    
91.         }
    
92. 
    
93.         public unsafe static Argb32Image CreateFromBitmap(Bitmap map)
    
94.         {
    
95.             if (map == null) throw new ArgumentNullException("map");
    
96. 
    
97.             Argb32Image img = new Argb32Image(map.Width*map.Height);
    
98. 
    
99.             Argb32* p = img.Pointer;
    
100. 
     
101.             for (int row = 0; row < map.Height; row++)
     
102.             {
     
103.                 for (int col = 0; col < map.Width; col++)
     
104.                 {
     
105.                     Color c = map.GetPixel(col, row);
     
106.                     p->Alpha = c.A;
     
107.                     p->Red = c.R;
     
108.                     p->Green = c.G;
     
109.                     p->Blue = c.B;
     
110.                     p++;
     
111.                 }
     
112.             }
     
113. 
     
114.             return img;
     
115.         }
     
116.     }
     

复制代码