编写高效的C#图像处理程序——我的实验（续）

本文是《编写高效的C#图像处理程序——我的实验》的后续实验。

昨天，在wuya的提醒下，仔细检查了下测试代码。发现存在2个问题：

（1）实验对EmguCV和OpenCV不公平，因为，其它测试都是进行处理图像这一个过程，而EmguCV和OpenCV在处理图像之间，需要将Bitmap转换为其内部图像格式IplImage这一过程。因此，今天的测试将这个转换过程提前，不计入执行时间。

（2）翻看OpenCV的实现代码，发现，它执行的是以下算法:

 1 static CvStatus CV_STDCALL
 2 icvBGRx2Gray_8u_CnC1R( const uchar* src, int srcstep,
 3                        uchar* dst, int dststep, CvSize size,
 4                        int src_cn, int blue_idx )
 5 {
 6     int i;
 7     srcstep -= size.width*src_cn; 
 8 
 9     if( size.width*size.height >= 1024 )
10     {
11         int* tab = (int*)cvStackAlloc( 256*3*sizeof(tab[0]) );
12         int r = 0, g = 0, b = (1 << (csc_shift-1));
13         for( i = 0; i < 256; i++ )
14         {
15             tab[i] = b;
16             tab[i+256] = g;
17             tab[i+512] = r;
18             g += cscGg;
19             if( !blue_idx )
20                 b += cscGb, r += cscGr;
21             else
22                 b += cscGr, r += cscGb;
23         } 
24 
25         for( ; size.height--; src += srcstep, dst += dststep )
26         {
27             for( i = 0; i < size.width; i++, src += src_cn )
28             {
29                 int t0 = tab[src[0]] + tab[src[1] + 256] + tab[src[2] + 512];
30                 dst[i] = (uchar)(t0 >> csc_shift);
31             }
32         }
33     }
34     else
35     {
36         for( ; size.height--; src += srcstep, dst += dststep )
37         {
38             for( i = 0; i < size.width; i++, src += src_cn )
39             {
40                 int t0 = src[blue_idx]*cscGb + src[1]*cscGg + src[blue_idx^2]*cscGr;
41                 dst[i] = (uchar)CV_DESCALE(t0, csc_shift);
42             }
43         }
44     }
45     return CV_OK;
46 }

这一算法有什么特点呢？

第一，它不进行浮点计算。它首先将浮点数乘于一个Scale（2的N次幂），转换为整数，计算后再经过 >> 计算，消去这个Scale

第二，对于大图像，它使用的是查表方式而不是乘法方式来计算灰度的。

鉴于此，我改进了C#的实现代码，对小图像，依然采用浮点计算：

*to = (Byte)(p->Red * rCoeff + p->Green * gCoeff + p->Blue * bCoeff);

对大图像，则使用查表计算：

                int* rCache = stackalloc int[256];
                int* gCache = stackalloc int[256];
                int* bCache = stackalloc int[256];

                const int shift = 1<<10;
                int rShift = (int)(rCoeff * shift);
                int gShift = (int)(gCoeff * shift);
                int bShift = shift - rShift - gShift;

                int r = 0, g = 0, b = 0;
                for (int i = 0; i < 256; i++)
                {
                    rCache[i] = r;
                    gCache[i] = g;
                    bCache[i] = b;
                    r += rShift;
                    g += gShift;
                    b += bShift;
                }

                while (p != end)
                {
                    *to = (Byte)((rCache[p->Red] + gCache[p->Green] + bCache[p->Red]) >> 10);
                    p++;
                    to++;
                }

这样，保证对比的是同一算法。今天的实验，主要比较下面五种图像灰度化方法：

（1）EmguCV实现：

         /// <summary>
2         /// 使用EmguCv处理图像
3         /// </summary>
4         private static void ProcessImageWithEmgucv(Image<Bgr, Byte> imageSource)
5         {
6             //灰度
7             Image<Gray, Byte> imageGrayscale = imageSource.Convert<Gray, Byte>();
8         }

（2）OpenCV/PInvoke实现：

         /// <summary>
2         /// 使用Open Cv P/Invoke处理图像
3         /// </summary>
4         unsafe private static void ProcessImageWithOpencv(IntPtr ptrSource, Size size)
5         {
6             IntPtr ptrGrayscale = CvInvoke.cvCreateImage(size, IPL_DEPTH.IPL_DEPTH_8U, 1);
7             CvInvoke.cvCvtColor(ptrSource, ptrGrayscale, COLOR_CONVERSION.CV_BGR2GRAY);
8         }
9 

（3）BitmapData实现：

 1         /// <summary>
 2         /// 将指定图像转换成灰度图
 3         /// </summary>
 4         /// <param name="bitmapSource">源图像支持3通道或者4通道图像，支持Format24bppRgb、Format32bppRgb和Format32bppArgb这3种像素格式</param>
 5         /// <returns>返回灰度图，如果转化失败，返回null。</returns>
 6         private static Bitmap Grayscale(Bitmap bitmapSource)
 7         {
 8             Bitmap bitmapGrayscale = null;
 9             if (bitmapSource != null && (bitmapSource.PixelFormat == PixelFormat.Format24bppRgb || bitmapSource.PixelFormat == PixelFormat.Format32bppArgb || bitmapSource.PixelFormat == PixelFormat.Format32bppRgb))
10             {
11                 int width = bitmapSource.Width;
12                 int height = bitmapSource.Height;
13                 Rectangle rect = new Rectangle(0, 0, width, height);
14                 bitmapGrayscale = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
15                 //设置调色板
16                 ColorPalette palette = bitmapGrayscale.Palette;
17                 for (int i = 0; i < palette.Entries.Length; i++)
18                     palette.Entries[i] = Color.FromArgb(255, i, i, i);
19                 bitmapGrayscale.Palette = palette;
20                 BitmapData dataSource = bitmapSource.LockBits(rect, ImageLockMode.ReadOnly, bitmapSource.PixelFormat);
21                 BitmapData dataGrayscale = bitmapGrayscale.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
22                 byte b, g, r;
23                 int strideSource = dataSource.Stride;
24                 int strideGrayscale = dataGrayscale.Stride;
25                 unsafe
26                 {
27                     byte* ptrSource = (byte*)dataSource.Scan0.ToPointer();
28                     byte* ptr1;
29                     byte* ptrGrayscale = (byte*)dataGrayscale.Scan0.ToPointer();
30                     byte* ptr2;
31                     if (bitmapSource.PixelFormat == PixelFormat.Format24bppRgb)
32                     {
33                         for (int row = 0; row < height; row++)
34                         {
35                             ptr1 = ptrSource + strideSource * row;
36                             ptr2 = ptrGrayscale + strideGrayscale * row;
37                             for (int col = 0; col < width; col++)
38                             {
39                                 b = *ptr1;
40                                 ptr1++;
41                                 g = *ptr1;
42                                 ptr1++;
43                                 r = *ptr1;
44                                 ptr1++;
45                                 *ptr2 = (byte)(0.114 * b + 0.587 * g + 0.299 * r);
46                                 ptr2++;
47                             }
48                         }
49                     }
50                     else    //bitmapSource.PixelFormat == PixelFormat.Format32bppArgb || bitmapSource.PixelFormat == PixelFormat.Format32bppRgb
51                     {
52                         for (int row = 0; row < height; row++)
53                         {
54                             ptr1 = ptrSource + strideGrayscale * row;
55                             ptr2 = ptrGrayscale + strideGrayscale * row;
56                             for (int col = 0; col < width; col++)
57                             {
58                                 b = *ptr1;
59                                 ptr1++;
60                                 g = *ptr1;
61                                 ptr1++;
62                                 r = *ptr1;
63                                 ptr1 += 2;
64                                 *ptr2 = (byte)(0.114 * b + 0.587 * g + 0.299 * r);
65                                 ptr2++;
66                             }
67                         }
68                     }
69                 }
70                 bitmapGrayscale.UnlockBits(dataGrayscale);
71                 bitmapSource.UnlockBits(dataSource);
72             }
73             return bitmapGrayscale;
74         }

（4）我自己的实现，Argb32Image，采用浮点计算：

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

（5）我自己的实现，Rgb24Image，对小图像采用浮点计算，对大图像采用查表计算：

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Drawing;
  4 using System.Text;
  5 
  6 namespace Orc.SmartImage.UnmanagedObjects
  7 {
  8     public struct Rgb24
  9     {
 10         public Byte Red;
 11         public Byte Green;
 12         public Byte Blue;
 13     }
 14 
 15     public class Rgb24Image : UnmanagedMemory<Rgb24>
 16     {
 17         private unsafe Rgb24* m_pointer;
 18 
 19         public unsafe Rgb24* Pointer { get { return m_pointer; } }
 20 
 21         public unsafe Rgb24Image(int length)
 22             : base(length)
 23         {
 24             m_pointer = (Rgb24*)this.Start;
 25         }
 26 
 27         public unsafe Rgb24 this[int index]
 28         {
 29             get { return *(m_pointer + index); }
 30             set { *(m_pointer + index) = value; }
 31         }
 32 
 33         public Grayscale8Image ToGrayscaleImage()
 34         {
 35             return ToGrayscaleImage(0.299, 0.587, 0.114);
 36         }
 37 
 38         public unsafe Grayscale8Image ToGrayscaleImage(double rCoeff, double gCoeff, double bCoeff)
 39         {
 40             Grayscale8Image img = new Grayscale8Image(this.Length);
 41             Rgb24* p = Pointer;
 42             Byte* to = img.Pointer;
 43             Rgb24* end = p + Length;
 44 
 45             if (Length < 1024)
 46             {
 47                 while (p != end)
 48                 {
 49                     *to = (Byte)(p->Red * rCoeff + p->Green * gCoeff + p->Blue * bCoeff);
 50                     p++;
 51                     to++;
 52                 }
 53             }
 54             else
 55             {
 56                 int* rCache = stackalloc int[256];
 57                 int* gCache = stackalloc int[256];
 58                 int* bCache = stackalloc int[256];
 59 
 60                 const int shift = 1<<10;
 61                 int rShift = (int)(rCoeff * shift);
 62                 int gShift = (int)(gCoeff * shift);
 63                 int bShift = shift - rShift - gShift;
 64 
 65                 int r = 0, g = 0, b = 0;
 66                 for (int i = 0; i < 256; i++)
 67                 {
 68                     rCache[i] = r;
 69                     gCache[i] = g;
 70                     bCache[i] = b;
 71                     r += rShift;
 72                     g += gShift;
 73                     b += bShift;
 74                 }
 75 
 76                 while (p != end)
 77                 {
 78                     *to = (Byte)((rCache[p->Red] + gCache[p->Green] + bCache[p->Red]) >> 10);
 79                     p++;
 80                     to++;
 81                 }
 82             }
 83             return img;
 84         }
 85 
 86         public unsafe static Rgb24Image CreateFromBitmap(Bitmap map)
 87         {
 88             if (map == null) throw new ArgumentNullException("map");
 89 
 90             Rgb24Image img = new Rgb24Image(map.Width * map.Height);
 91 
 92             Rgb24* p = img.Pointer;
 93 
 94             for (int row = 0; row < map.Height; row++)
 95             {
 96                 for (int col = 0; col < map.Width; col++)
 97                 {
 98                     Color c = map.GetPixel(col, row);
 99                     p->Red = c.R;
100                     p->Green = c.G;
101                     p->Blue = c.B;
102                     p++;
103                 }
104             }
105 
106             return img;
107         }
108     }
109 }
110 

测试代码如下：

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Runtime.InteropServices;
  4 using System.Diagnostics;
  5 using System.Linq;
  6 using System.Text;
  7 using System.Drawing;
  8 using System.Drawing.Imaging;
  9 using Orc.SmartImage;
 10 using Emgu.CV;
 11 using Emgu.CV.Structure;
 12 using Emgu.CV.CvEnum;
 13 using Orc.SmartImage.Gpu;
 14 using Orc.SmartImage.UnmanagedObjects;
 15 
 16 namespace Orc.SmartImage.PerformanceTest
 17 {
 18     public class PerformanceTestCase0
 19     {
 20         public static String Test(Bitmap src, int count)
 21         {
 22             Argb32Image img32 = Argb32Image.CreateFromBitmap(src);
 23             Rgb24Image img24 = Rgb24Image.CreateFromBitmap(src);
 24             Image<Bgr, Byte> imageSource = new Image<Bgr, byte>(src);
 25             IntPtr ptrSource = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MIplImage)));
 26             Marshal.StructureToPtr(imageSource.MIplImage, ptrSource, true);
 27             Size size = imageSource.Size;
 28             StringBuilder sb = new StringBuilder();
 29             Stopwatch sw = new Stopwatch();
 30 
 31             DoSomething();
 32 
 33             sw.Reset();
 34             sw.Start();
 35             for (int i = 0; i < count; i++)
 36                 ProcessImageWithEmgucv(imageSource);
 37             sw.Stop();
 38             sb.AppendLine("EmguCV:" + sw.ElapsedMilliseconds.ToString());
 39 
 40             DoSomething();
 41             sw.Reset();
 42             sw.Start();
 43             for (int i = 0; i < count; i++)
 44                 ProcessImageWithOpencv(ptrSource, imageSource.Size);
 45             sw.Stop();
 46             sb.AppendLine("OpenCV P/Invoke:" + sw.ElapsedMilliseconds.ToString());
 47 
 48             DoSomething();
 49             sw.Reset();
 50             sw.Start();
 51             for (int i = 0; i < count; i++)
 52                 Grayscale(src);
 53             sw.Stop();
 54             sb.AppendLine("BitmapData:" + sw.ElapsedMilliseconds.ToString());
 55 
 56             DoSomething();
 57             sw.Reset();
 58             sw.Start();
 59             for (int i = 0; i < count; i++)
 60                 img24.ToGrayscaleImage();
 61             sw.Stop();
 62             sb.AppendLine("RgbImage24[use table]:" + sw.ElapsedMilliseconds.ToString());
 63 
 64             DoSomething();
 65             sw.Reset();
 66             sw.Start();
 67             for (int i = 0; i < count; i++)
 68                 img32.ToGrayscaleImage();
 69             sw.Stop();
 70             sb.AppendLine("ArgbImage32:" + sw.ElapsedMilliseconds.ToString());
 71 
 72             return sb.ToString();
 73         }
 74 
 75         private static int[] DoSomething()
 76         {
 77             int[] data = new Int32[20000000];
 78             for (int i = 0; i < data.Length; i++)
 79             {
 80                 data[i] = i;
 81             }
 82             return data;
 83         }
 84 
 85         /// <summary>
 86         /// 使用EmguCv处理图像
 87         /// </summary>
 88         private static void ProcessImageWithEmgucv(Image<Bgr, Byte> imageSource)
 89         {
 90             //灰度
 91             Image<Gray, Byte> imageGrayscale = imageSource.Convert<Gray, Byte>();
 92         }
 93 
 94         /// <summary>
 95         /// 使用Open Cv P/Invoke处理图像
 96         /// </summary>
 97         unsafe private static void ProcessImageWithOpencv(IntPtr ptrSource, Size size)
 98         {
 99             IntPtr ptrGrayscale = CvInvoke.cvCreateImage(size, IPL_DEPTH.IPL_DEPTH_8U, 1);
100             CvInvoke.cvCvtColor(ptrSource, ptrGrayscale, COLOR_CONVERSION.CV_BGR2GRAY);
101         }
102 
103 
104 
105         /// <summary>
106         /// 将指定图像转换成灰度图
107         /// </summary>
108         /// <param name="bitmapSource">源图像支持3通道或者4通道图像，支持Format24bppRgb、Format32bppRgb和Format32bppArgb这3种像素格式</param>
109         /// <returns>返回灰度图，如果转化失败，返回null。</returns>
110         private static Bitmap Grayscale(Bitmap bitmapSource)
111         {
112             Bitmap bitmapGrayscale = null;
113             if (bitmapSource != null && (bitmapSource.PixelFormat == PixelFormat.Format24bppRgb || bitmapSource.PixelFormat == PixelFormat.Format32bppArgb || bitmapSource.PixelFormat == PixelFormat.Format32bppRgb))
114             {
115                 int width = bitmapSource.Width;
116                 int height = bitmapSource.Height;
117                 Rectangle rect = new Rectangle(0, 0, width, height);
118                 bitmapGrayscale = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
119                 //设置调色板
120                 ColorPalette palette = bitmapGrayscale.Palette;
121                 for (int i = 0; i < palette.Entries.Length; i++)
122                     palette.Entries[i] = Color.FromArgb(255, i, i, i);
123                 bitmapGrayscale.Palette = palette;
124                 BitmapData dataSource = bitmapSource.LockBits(rect, ImageLockMode.ReadOnly, bitmapSource.PixelFormat);
125                 BitmapData dataGrayscale = bitmapGrayscale.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
126                 byte b, g, r;
127                 int strideSource = dataSource.Stride;
128                 int strideGrayscale = dataGrayscale.Stride;
129                 unsafe
130                 {
131                     byte* ptrSource = (byte*)dataSource.Scan0.ToPointer();
132                     byte* ptr1;
133                     byte* ptrGrayscale = (byte*)dataGrayscale.Scan0.ToPointer();
134                     byte* ptr2;
135                     if (bitmapSource.PixelFormat == PixelFormat.Format24bppRgb)
136                     {
137                         for (int row = 0; row < height; row++)
138                         {
139                             ptr1 = ptrSource + strideSource * row;
140                             ptr2 = ptrGrayscale + strideGrayscale * row;
141                             for (int col = 0; col < width; col++)
142                             {
143                                 b = *ptr1;
144                                 ptr1++;
145                                 g = *ptr1;
146                                 ptr1++;
147                                 r = *ptr1;
148                                 ptr1++;
149                                 *ptr2 = (byte)(0.114 * b + 0.587 * g + 0.299 * r);
150                                 ptr2++;
151                             }
152                         }
153                     }
154                     else    //bitmapSource.PixelFormat == PixelFormat.Format32bppArgb || bitmapSource.PixelFormat == PixelFormat.Format32bppRgb
155                     {
156                         for (int row = 0; row < height; row++)
157                         {
158                             ptr1 = ptrSource + strideGrayscale * row;
159                             ptr2 = ptrGrayscale + strideGrayscale * row;
160                             for (int col = 0; col < width; col++)
161                             {
162                                 b = *ptr1;
163                                 ptr1++;
164                                 g = *ptr1;
165                                 ptr1++;
166                                 r = *ptr1;
167                                 ptr1 += 2;
168                                 *ptr2 = (byte)(0.114 * b + 0.587 * g + 0.299 * r);
169                                 ptr2++;
170                             }
171                         }
172                     }
173                 }
174                 bitmapGrayscale.UnlockBits(dataGrayscale);
175                 bitmapSource.UnlockBits(dataSource);
176             }
177             return bitmapGrayscale;
178         }
179 
180     }
181 }
182 

在每种测试方法运行之前，执行DoSomething()，清空CPU的高速缓存。

测试程序采用WinForm编写，界面如下：

可输入执行次数。目前，我机器有800M空闲物理内存。下面进行测试：

图片1，分辨率205×581，32位图像，执行50次，结果——

EmguCV:48
OpenCV P/Invoke:30
BitmapData:103
RgbImage24[use table]:38
ArgbImage32:147

再按一下运行，结果——

EmguCV:49
OpenCV P/Invoke:31
BitmapData:107
RgbImage24[use table]:37
ArgbImage32:74

图片2，分辨率864×486，24位图像，执行50次，结果——

EmguCV:131
OpenCV P/Invoke:108
BitmapData:376
RgbImage24[use table]:132
ArgbImage32:258

第二次，

EmguCV:131
OpenCV P/Invoke:107
BitmapData:382
RgbImage24[use table]:130
ArgbImage32:257

图片3，1280×720，24位图像，执行50次，结果——

EmguCV:262
OpenCV P/Invoke:239
BitmapData:822
RgbImage24[use table]:288
ArgbImage32:570

第二次，

EmguCV:280
OpenCV P/Invoke:244
BitmapData:819
RgbImage24[use table]:289
ArgbImage32:568

下面是那张最大的图片 5000×6000的24位图像，执行5次，结果——

内存耗完了（上面的测试都未释放内存），没得到结果。关闭程序，再重新打开，将次数减少为1次，结果——

EmguCV:226
OpenCV P/Invoke:153
BitmapData:553
RgbImage24[use table]:189
ArgbImage32:609

第二次，

EmguCV:155
OpenCV P/Invoke:152
BitmapData:565
RgbImage24[use table]:184
ArgbImage32:745

==================================

下面进行总结（对昨天的结论进行修正）：

（1）算法相同、数据结构相同的情况下，C#（采用指针和未托管内存）程序的性能大概是使用P/Invoke调用C程序的1/1.2～1/1.25倍。这个性能降低是可接受的（至少对我而言），并不是很大的性能降低。考虑到GC，性能会再打点折扣，就算是1/1.3吧。

（2）影响C#程序性能的主要因素是所使用的数据结构和算法。上面的测试，同样的功能，采用不同的数据结构和算法，性能差别是2～3倍。有时候可以产生1000倍以上的差异。

==================================

推论：

如果能够认同25%的性能损失，使用C#/非托管内存的优势主要是：快速开发，快速编译，快速测试，维护性好，同时，在非性能关键部分可以使用庞大的library。

==================================

为什么做这一系列实验？

我是想测试一下C#到底适合不适合做图像处理。目前我有几个选择：

（1）matlab。可以快速开发，然很难部署。

（2）OpenCV。速度很快，开发很慢。并且，OpenCV所提供的算法还是很有限。有时需要设计自己的算法，在OpenCV基础上扩展很慢。

（3）EmguCV。它封装了OpenCV。如果只使用既有功能，可以快速开发。一旦扩展，同样问题很大。

（4）AForge.Net。它提供了大量的适用的方法，但是我总感觉还是不好用，并且性能有问题。这个性能问题应该是所使用的算法问题。

所以，还不如写自己的纯C#图像库。因为一般来说一个应用，就只涉及那几个算法，把那几个算法实现就可以了。在C#下实现几个算法再进行研究和扩展，我感觉比在OpenCV下去研究现有算法，再进行扩展还要省事些。只要肯损失25%的性能。而我目前规划了一系列C#图像处理的文章，正好通过这个实验去寻找C#图像处理的最底层的数据结构。而未来多核机器+GPU的广泛应用，这个25%的性能损失问题不大。