原文编写高效的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 。
public class ArgbImage8 : ImageChannelSet8
{ public ImageChannel8 A { get { return this.Channels[0]; } } public ImageChannel8 R { get { return this.Channels[0]; } } public ImageChannel8 G { get { return this.Channels[0]; } } public ImageChannel8 B { get { return this.Channels[0]; } } public ArgbImage8(int width, int height)
: base(4, width, height)
{
} public GrayscaleImage8 ToGrayscaleImage()
{ return ToGrayscaleImage(0.299, 0.587, 0.114);
} public GrayscaleImage8 ToGrayscaleImage(double rCoeff, double gCoeff, double bCoeff)
{
GrayscaleImage8 img = new GrayscaleImage8(this.Width, this.Height);
Byte[] r = R.Data;
Byte[] g = G.Data;
Byte[] b = B.Data;
Byte[] dst = img.Data; for (int i = 0; i < r.Length; i++)
{
dst[i] = (Byte)(r[i] * rCoeff + g[i] * gCoeff + b[i] * bCoeff);
} return img;
} //性能低下，先这样写了
public static ArgbImage8 CreateFromBitmap(Bitmap map)
{ if (map == null) throw new ArgumentNullException("map");
ArgbImage8 img = new ArgbImage8(map.Width, map.Height);
Byte[] a = img.A.Data;
Byte[] r = img.R.Data;
Byte[] g = img.G.Data;
Byte[] b = img.B.Data; for (int row = 0; row < img.Height; row++)
{ for (int col = 0; col < img.Width; col++)
{ int index = row * img.Width + col;
Color c = map.GetPixel(col, row);
a[index] = c.A;
r[index] = c.R;
r[index] = c.R;
r[index] = c.R;
}
} return img;
}
}
（5）C# 指针/unsafe 实现（ArgbImage32 ），核心代码如下：
public class UnmanagedMemory<T> : IDisposable
where T : struct
{ public Int32 ByteCount { get; private set; } public Int32 Length { get; private set; } public IntPtr Start { get; private set; } public Int32 SizeOfType { get; private set; } public UnmanagedMemory(Int32 length)
{
Length = length;
SizeOfType = SizeOfT();
ByteCount = SizeOfType * length;
Start = Marshal.AllocHGlobal(ByteCount);
} public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
} protected virtual void Dispose(bool disposing)
{ if (false == disposed)
{
disposed = true;
Marshal.FreeHGlobal(Start);
}
} private bool disposed;
~UnmanagedMemory()
{
Dispose(false);
} private Int32 SizeOfT()
{ return Marshal.SizeOf(typeof(T));
}
}
public struct Argb32
{ public Byte Alpha; public Byte Red; public Byte Green; public Byte Blue;
} public class Argb32Image : UnmanagedMemory<Argb32>
{ private unsafe Argb32* m_pointer; public unsafe Argb32* Pointer { get { return m_pointer; } } public unsafe Argb32Image(int length)
: base(length)
{
m_pointer = (Argb32*)this.Start;
} public unsafe Argb32 this[int index]
{ get { return *(m_pointer + index); } set { *(m_pointer + index) = value; }
} public Grayscale8Image ToGrayscaleImage()
{ return ToGrayscaleImage(0.299, 0.587, 0.114);
} public unsafe Grayscale8Image ToGrayscaleImage(double rCoeff, double gCoeff, double bCoeff)
{
Grayscale8Image img = new Grayscale8Image(this.Length);
Argb32* p = Pointer;
Byte* to = img.Pointer;
Argb32* end = p + Length; while (p != end)
{
*to = (Byte)(p->Red * rCoeff + p->Green * gCoeff + p->Blue * bCoeff);
p++;
to++;
} return img;
} public unsafe static Argb32Image CreateFromBitmap(Bitmap map)
{ if (map == null) throw new ArgumentNullException("map");
Argb32Image img = new Argb32Image(map.Width*map.Height);
Argb32* p = img.Pointer; for (int row = 0; row < map.Height; row++)
{ for (int col = 0; col < map.Width; col++)
{
Color c = map.GetPixel(col, row);
p->Alpha = c.A;
p->Red = c.R;
p->Green = c.G;
p->Blue = c.B;
p++;
}
} return img;
}
}
机器配置：
在每个方法测试前，均运行一段DoSomething（）清空高速缓存：
private static int[] DoSomething()
{
int[] data = new Int32[20000000];
for (int i = 0; i < data.Length; i++)
{
data[i] = i;
}
return data;
}
测试结果（每个执行5次，计算耗时总和。单位ms）:
图像1——
BitmapData:53
ArgbImage8:80
ArgbImage32:38
EmguCV:68
OpenCV:69
图像2——
BitmapData:25
ArgbImage8:45
ArgbImage32:19
EmguCV:42
OpenCV:45
图像3——
BitmapData:8
ArgbImage8:25
ArgbImage32:6
EmguCV:23
OpenCV:24
图像4——
BitmapData:48
ArgbImage8:76
ArgbImage32:39
EmguCV:67
OpenCV:69
图像5（大图：5000×6000）——
BitmapData:1584
ArgbImage8:1991
ArgbImage32:1229
EmguCV:1545
OpenCV:2817
下面删去ArgbImage8，仅比较剩下的4种（每个执行5次，计算耗时总和。单位ms）：
图像6——
BitmapData:17
ArgbImage32:10
EmguCV:25
OpenCV:25
图像7——
BitmapData:88
ArgbImage32:56
EmguCV:69
OpenCV:70
图像8——
BitmapData:41
ArgbImage32:25
EmguCV:40
OpenCV:43
图像5（大图：5000×6000）——
BitmapData:2855
ArgbImage32:1849
EmguCV:1578
OpenCV:2522
下面，把执行顺序颠倒一下，让EmguCV和OpenCV在前面。剩下的2个在后面：
图像8——
EmguCV:41
OpenCV:42
BitmapData:38
ArgbImage32:26
图像9——
EmguCV:32
OpenCV:34
BitmapData:28
ArgbImage32:18
好了，不做试验了。根据上面结果，再考虑到纯C/C++程序比P/Invoke程序性能高一些，可得出这样的结论（在我的机器上）：
（1）C#不直接用指针比P/Invoke 的 C/C++程序低效一些。
（2）C#直接用指针，可以写出非常高效的程序，至少比P/Invoke高效。从上面的代码可看出，C#下指针用很舒服，并且编译快。猜想：C#下玩指针+Struct，和C没啥区别。图像处理这样的基本类型简单的程序，非常适合用C#编写。大量用指针，大量用非托管内存，可以最大化性能，最小化内存占用，最小化GC对程序的影响，达到和C/C++所差无几的性能。
下面尝试直接使用硬件。对图像处理加速最有效果的是GPU，好吧，下面就尝试调用GPU的功能。
如何在无界面的情况下调用GPU呢？
下面是我写的一个测试程序（需要引用XNA）：
using System;using System.Collections.Generic;using System.Linq;using Microsoft.Xna.Framework;using Microsoft.Xna.Framework.Audio;using Microsoft.Xna.Framework.Content;using Microsoft.Xna.Framework.GamerServices;using Microsoft.Xna.Framework.Graphics;using Microsoft.Xna.Framework.Input;using Microsoft.Xna.Framework.Media;using Microsoft.Xna.Framework.Net;using Microsoft.Xna.Framework.Storage;namespace Orc.SmartImage.Xna
{ public class Shader
{ private class GameHelper : Game
{ public void Init()
{ this.Initialize();
GraphicsDeviceManager m = new GraphicsDeviceManager(this);
m.ApplyChanges();
}
} private GameHelper m_helper; public GraphicsDevice GraphicsDevice { get; set; } public Shader(IntPtr hwnd)
{
m_helper = new GameHelper();
m_helper.Init(); this.GraphicsDevice = m_helper.GraphicsDevice;
} public void Test()
{
RenderTarget2D tar = new RenderTarget2D(this.GraphicsDevice, 100, 100, 1, SurfaceFormat.Color); this.GraphicsDevice.SetRenderTarget(0, tar); this.GraphicsDevice.Clear(Color.Yellow); this.GraphicsDevice.SetRenderTarget(0, null);
Texture2D txt = tar.GetTexture(); uint[] data = new uint[10000];
txt.GetData(data); return;
}
}
}
进一步就是写HLSL了。
============================
离C/C++又远了一步。
附：具体测试代码
（注：那个Shader是我测试GPU计算能否通过的部分。IntPtr hwnd是因为GraphicsDevice构造函数中有这样一个参数，不过后来，我绕了过去，但测试程序这里我没删掉，还留在这里。）
using System;using System.Collections.Generic;using System.Runtime.InteropServices;using System.Diagnostics;using System.Linq;using System.Text;using System.Drawing;using System.Drawing.Imaging;using Orc.SmartImage;using Emgu.CV;using Emgu.CV.Structure;using Emgu.CV.CvEnum;using Orc.SmartImage.Gpu;using Orc.SmartImage.UnmanagedObjects;namespace Orc.SmartImage.PerformanceTest
{ public class PerformanceTestCase0
{ public static String Test(IntPtr hwnd, Bitmap src, int count)
{
Shader sd = new Shader(hwnd);// ArgbImage8 img8 = ArgbImage8.CreateFromBitmap(src);
Argb32Image img32 = Argb32Image.CreateFromBitmap(src);
StringBuilder sb = new StringBuilder();
Stopwatch sw = new Stopwatch();
DoSomething();
sw.Reset();
sw.Start(); for (int i = 0; i < count; i++)
ProcessImageWithEmgucv(src);
sw.Stop();
sb.AppendLine("EmguCV:" + sw.ElapsedMilliseconds.ToString());
DoSomething();
sw.Reset();
sw.Start(); for (int i = 0; i < count; i++)
ProcessImageWithOpencv(src);
sw.Stop();
sb.AppendLine("OpenCV:" + sw.ElapsedMilliseconds.ToString());
DoSomething();
sw.Reset();
sw.Start(); for (int i = 0; i < count; i++)
Grayscale(src);
sw.Stop();
sb.AppendLine("BitmapData:" + sw.ElapsedMilliseconds.ToString()); //DoSomething();
//sw.Reset();
//sw.Start();
//for (int i = 0; i < count; i++)
// img8.ToGrayscaleImage();
//sw.Stop();
//sb.AppendLine("ArgbImage8:" + sw.ElapsedMilliseconds.ToString());
DoSomething();
sw.Reset();
sw.Start(); for (int i = 0; i < count; i++)
img32.ToGrayscaleImage();
sw.Stop();
sb.AppendLine("ArgbImage32:" + sw.ElapsedMilliseconds.ToString());
//sw.Reset();
//sw.Start();
//for (int i = 0; i < count; i++)
// img8.ToGrayscaleImage();
//sw.Stop();
//sb.AppendLine("ArgbImage8:" + sw.ElapsedMilliseconds.ToString());
return sb.ToString();
} private static int[] DoSomething()
{ int[] data = new Int32[20000000]; for (int i = 0; i < data.Length; i++)
{
data[i] = i;
} return data;
} private static GrayscaleImage TestMyConvert(ArgbImage img)
{ return img.ToGrayscaleImage();
} /// <summary>
/// 使用EmguCv处理图像
/// </summary>
private static void ProcessImageWithEmgucv(Bitmap bitmapSource)
{ //灰度
Image<Bgr, Byte> imageSource = new Image<Bgr, byte>(bitmapSource);
Image<Gray, Byte> imageGrayscale = imageSource.Convert<Gray, Byte>();
} /// <summary>
/// 使用Open Cv P/Invoke处理图像
/// </summary>
unsafe private static void ProcessImageWithOpencv(Bitmap bitmapSource)
{
Image<Bgr, Byte> imageSource = new Image<Bgr, byte>(bitmapSource);
IntPtr ptrSource = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MIplImage)));
Marshal.StructureToPtr(imageSource.MIplImage, ptrSource, true);
IntPtr ptrGrayscale = CvInvoke.cvCreateImage(imageSource.Size, IPL_DEPTH.IPL_DEPTH_8U, 1);
CvInvoke.cvCvtColor(ptrSource, ptrGrayscale, COLOR_CONVERSION.CV_BGR2GRAY);
} /// <summary>
/// 将指定图像转换成灰度图
/// </summary>
/// <param name="bitmapSource">源图像支持3通道或者4通道图像，支持Format24bppRgb、Format32bppRgb和Format32bppArgb这3种像素格式</param>
/// <returns>返回灰度图，如果转化失败，返回null。</returns>
private static Bitmap Grayscale(Bitmap bitmapSource)
{
Bitmap bitmapGrayscale = null; if (bitmapSource != null && (bitmapSource.PixelFormat == PixelFormat.Format24bppRgb || bitmapSource.PixelFormat == PixelFormat.Format32bppArgb || bitmapSource.PixelFormat == PixelFormat.Format32bppRgb))
{ int width = bitmapSource.Width; int height = bitmapSource.Height;
Rectangle rect = new Rectangle(0, 0, width, height);
bitmapGrayscale = new Bitmap(width, height, PixelFormat.Format8bppIndexed); //设置调色板
ColorPalette palette = bitmapGrayscale.Palette; for (int i = 0; i < palette.Entries.Length; i++)
palette.Entries[i] = Color.FromArgb(255, i, i, i);
bitmapGrayscale.Palette = palette;
BitmapData dataSource = bitmapSource.LockBits(rect, ImageLockMode.ReadOnly, bitmapSource.PixelFormat);
BitmapData dataGrayscale = bitmapGrayscale.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed); byte b, g, r; int strideSource = dataSource.Stride; int strideGrayscale = dataGrayscale.Stride; unsafe
{ byte* ptrSource = (byte*)dataSource.Scan0.ToPointer(); byte* ptr1; byte* ptrGrayscale = (byte*)dataGrayscale.Scan0.ToPointer(); byte* ptr2; if (bitmapSource.PixelFormat == PixelFormat.Format24bppRgb)
{ for (int row = 0; row < height; row++)
{
ptr1 = ptrSource + strideSource * row;
ptr2 = ptrGrayscale + strideGrayscale * row; for (int col = 0; col < width; col++)
{
b = *ptr1;
ptr1++;
g = *ptr1;
ptr1++;
r = *ptr1;
ptr1++;
*ptr2 = (byte)(0.114 * b + 0.587 * g + 0.299 * r);
ptr2++;
}
}
} else //bitmapSource.PixelFormat == PixelFormat.Format32bppArgb || bitmapSource.PixelFormat == PixelFormat.Format32bppRgb
{ for (int row = 0; row < height; row++)
{
ptr1 = ptrSource + strideGrayscale * row;
ptr2 = ptrGrayscale + strideGrayscale * row; for (int col = 0; col < width; col++)
{
b = *ptr1;
ptr1++;
g = *ptr1;
ptr1++;
r = *ptr1;
ptr1 += 2;
*ptr2 = (byte)(0.114 * b + 0.587 * g + 0.299 * r);
ptr2++;
}
}
}
}
bitmapGrayscale.UnlockBits(dataGrayscale);
bitmapSource.UnlockBits(dataSource);
} return bitmapGrayscale;
}
}
}
作者：xiaotie , 集异璧实验室(GEBLAB)
出处：http://www.cnblogs.com/xiaotie/
若标题中有“转载”字样，则本文版权归原作者所有。若无转载字样，本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.