发布我的高性能纯C#图像处理基本类，顺便也挑战一下极限。:)
前些天写了《编写高效的C#图像处理程序——我的实验》《编写高效的C#图像处理程序——我的实验（续）》，后来，在这两篇文章的基础上，整理了代码，发布在 http://code.google.com/p/smartimage/ ；可以使用SVN通过下面地址：http://smartimage.googlecode.com/svn/trunk/ smartimage-read-only 下载源代码。
其中：Orc.SmartImage.Common 项目是C#图像处理的基础类。Orc.SmartImage.CommonTest 是单元测试（需nunit），Orc.SmartImageLab.PerformanceTest是性能测试。关于这些基础类和EmguCV和OpenCV(P/Invoke）的性能比较见我的博客：《编写高效的C#图像处理程序——我的实验（续）》，项目核心是泛型类 UnmanagedImage.cs
代码
using
System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
namespace Orc.SmartImage
{
public abstract class UnmanagedImage < T > : IDisposable, IEnumerable < T >
where T : struct
{
public Int32 ByteCount { get ; private set ; }
public Int32 Length { get ; private set ; }
public Int32 SizeOfType { get ; private set ; }
public Int32 Width { get ; private set ; }
public Int32 Height { get ; private set ; }
public IntPtr StartIntPtr { get ; private set ; }
private IByteConverter < T > m_converter;
private unsafe Byte * m_start;
public unsafe UnmanagedImage(Int32 width, Int32 height)
{
Width = width;
Height = height;
Length = Width * Height;
SizeOfType = SizeOfT();
ByteCount = SizeOfType * Length;
m_converter = this .CreateByteConverter();
StartIntPtr = Marshal.AllocHGlobal(ByteCount);
m_start = (Byte * )StartIntPtr;
}
public UnmanagedImage(Bitmap map): this (map.Width, map.Height)
{
if (map == null ) throw new ArgumentNullException( " map " );
this .CreateFromBitmap(map);
}
/// <summary>
/// 性能约是指针操作的1/4。不适用于性能要求高的地方。
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public unsafe T this [ int index]
{
get
{
T t = new T();
m_converter.Copy(m_start + index * SizeOfType, ref t);
return t;
}
set
{
Byte * to = m_start + index * SizeOfType;
m_converter.Copy( ref value, to);
}
}
/// <summary>
/// 性能约是指针操作的1/4。不适用于性能要求高的地方。
/// </summary>
/// <param name="row"></param>
/// <param name="col"></param>
/// <returns></returns>
public unsafe T this [ int row, int col]
{
get
{
T t = new T();
m_converter.Copy(m_start + (row * Width + col) * SizeOfType, ref t);
return t;
}
set
{
Byte * to = m_start + (row * Width + col) * SizeOfType;
m_converter.Copy( ref value, to);
}
}
public void Dispose()
{
Dispose( true );
GC.SuppressFinalize( this );
}
protected virtual void Dispose( bool disposing)
{
if ( false == disposed)
{
disposed = true ;
Marshal.FreeHGlobal(StartIntPtr);
}
}
private bool disposed;
~ UnmanagedImage()
{
Dispose( false );
}
private static Int32 SizeOfT()
{
return Marshal.SizeOf( typeof (T));
}
private unsafe void CreateFromBitmap(Bitmap map)
{
int height = map.Height;
int width = map.Width;
PixelFormat format = map.PixelFormat;
if ( this .Width != width || this .Height != height)
{
return ;
}
Bitmap newMap = map;
Int32 step = SizeOfT();
switch (format)
{
case PixelFormat.Format24bppRgb:
break ;
case PixelFormat.Format32bppArgb:
break ;
default :
format = PixelFormat.Format32bppArgb;
newMap = map.Clone( new Rectangle( 0 , 0 , width, height), PixelFormat.Format32bppArgb);
break ;
}
Byte * t = (Byte * )StartIntPtr;
BitmapData data = newMap.LockBits( new Rectangle( 0 , 0 , width, height), ImageLockMode.ReadOnly, format);
try
{
if (format == PixelFormat.Format24bppRgb)
{
Byte * line = (Byte * )data.Scan0;
for ( int h = 0 ; h < height; h ++ )
{
Rgb24 * c = (Rgb24 * )line;
for ( int w = 0 ; w < width; w ++ )
{
m_converter.Copy(c, t);
t += step;
c ++ ;
}
line += data.Stride;
}
}
else
{
Byte * line = (Byte * )data.Scan0;
for ( int h = 0 ; h < height; h ++ )
{
Argb32 * c = (Argb32 * )line;
for ( int w = 0 ; w < width; w ++ )
{
m_converter.Copy(c, t);
t += step;
c ++ ;
}
line += data.Stride;
}
}
}
catch (Exception)
{
throw ;
}
finally
{
newMap.UnlockBits(data);
}
}
public unsafe Bitmap ToBitmap()
{
Bitmap map = new Bitmap( this .Width, this .Height, PixelFormat.Format32bppArgb);
ToBitmap(map);
return map;
}
public unsafe void ToBitmap(Bitmap map)
{
if (map == null ) throw new ArgumentNullException( " map " );
if (map.Width != this .Width || map.Height != this .Height)
{
throw new ArgumentException( " 尺寸不匹配. " );
}
if (map.PixelFormat != PixelFormat.Format32bppArgb)
{
throw new ArgumentException( " 只支持 Format32bppArgb 格式。 " );
}
Int32 step = SizeOfT();
Byte * t = (Byte * )StartIntPtr;
BitmapData data = map.LockBits( new Rectangle( 0 , 0 , map.Width, map.Height), ImageLockMode.ReadWrite, map.PixelFormat);
try
{
int width = map.Width;
int height = map.Height;
Byte * line = (Byte * )data.Scan0;
for ( int h = 0 ; h < height; h ++ )
{
Argb32 * c = (Argb32 * )line;
for ( int w = 0 ; w < width; w ++ )
{
m_converter.Copy(t, c);
t += step;
c ++ ;
}
line += data.Stride;
}
}
finally
{
map.UnlockBits(data);
}
}
protected abstract IByteConverter < T > CreateByteConverter();
#region IEnumerable<T> Members
public IEnumerator < T > GetEnumerator()
{
return new ImageEnum < T > ( this , this .m_converter);
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
}
internal class ImageEnum < T > : IEnumerator < T >
where T : struct
{
private UnmanagedImage < T > m_img;
private unsafe Byte * m_start;
private Int32 m_step;
private unsafe Byte * m_end;
private unsafe Byte * m_current;
private IByteConverter < T > m_converter;
public unsafe ImageEnum(UnmanagedImage < T > img, IByteConverter < T > converter)
{
m_img = img;
m_start = (Byte * )m_img.StartIntPtr;
m_step = m_img.SizeOfType;
m_end = m_start + m_step * m_img.Length;
m_current = m_start;
m_converter = converter;
}
#region IEnumerator<T> Members
public unsafe T Current
{
get
{
T t = new T();
m_converter.Copy(m_current, ref t);
return t;
}
}
#endregion
#region IDisposable Members
public void Dispose()
{
}
#endregion
#region IEnumerator Members
object System.Collections.IEnumerator.Current
{
get { return Current; }
}
public unsafe bool MoveNext()
{
m_current += this .m_step;
return m_current < m_end;
}
public unsafe void Reset()
{
m_current = m_start;
}
#endregion
}
}
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
namespace Orc.SmartImage
{
public abstract class UnmanagedImage < T > : IDisposable, IEnumerable < T >
where T : struct
{
public Int32 ByteCount { get ; private set ; }
public Int32 Length { get ; private set ; }
public Int32 SizeOfType { get ; private set ; }
public Int32 Width { get ; private set ; }
public Int32 Height { get ; private set ; }
public IntPtr StartIntPtr { get ; private set ; }
private IByteConverter < T > m_converter;
private unsafe Byte * m_start;
public unsafe UnmanagedImage(Int32 width, Int32 height)
{
Width = width;
Height = height;
Length = Width * Height;
SizeOfType = SizeOfT();
ByteCount = SizeOfType * Length;
m_converter = this .CreateByteConverter();
StartIntPtr = Marshal.AllocHGlobal(ByteCount);
m_start = (Byte * )StartIntPtr;
}
public UnmanagedImage(Bitmap map): this (map.Width, map.Height)
{
if (map == null ) throw new ArgumentNullException( " map " );
this .CreateFromBitmap(map);
}
/// <summary>
/// 性能约是指针操作的1/4。不适用于性能要求高的地方。
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public unsafe T this [ int index]
{
get
{
T t = new T();
m_converter.Copy(m_start + index * SizeOfType, ref t);
return t;
}
set
{
Byte * to = m_start + index * SizeOfType;
m_converter.Copy( ref value, to);
}
}
/// <summary>
/// 性能约是指针操作的1/4。不适用于性能要求高的地方。
/// </summary>
/// <param name="row"></param>
/// <param name="col"></param>
/// <returns></returns>
public unsafe T this [ int row, int col]
{
get
{
T t = new T();
m_converter.Copy(m_start + (row * Width + col) * SizeOfType, ref t);
return t;
}
set
{
Byte * to = m_start + (row * Width + col) * SizeOfType;
m_converter.Copy( ref value, to);
}
}
public void Dispose()
{
Dispose( true );
GC.SuppressFinalize( this );
}
protected virtual void Dispose( bool disposing)
{
if ( false == disposed)
{
disposed = true ;
Marshal.FreeHGlobal(StartIntPtr);
}
}
private bool disposed;
~ UnmanagedImage()
{
Dispose( false );
}
private static Int32 SizeOfT()
{
return Marshal.SizeOf( typeof (T));
}
private unsafe void CreateFromBitmap(Bitmap map)
{
int height = map.Height;
int width = map.Width;
PixelFormat format = map.PixelFormat;
if ( this .Width != width || this .Height != height)
{
return ;
}
Bitmap newMap = map;
Int32 step = SizeOfT();
switch (format)
{
case PixelFormat.Format24bppRgb:
break ;
case PixelFormat.Format32bppArgb:
break ;
default :
format = PixelFormat.Format32bppArgb;
newMap = map.Clone( new Rectangle( 0 , 0 , width, height), PixelFormat.Format32bppArgb);
break ;
}
Byte * t = (Byte * )StartIntPtr;
BitmapData data = newMap.LockBits( new Rectangle( 0 , 0 , width, height), ImageLockMode.ReadOnly, format);
try
{
if (format == PixelFormat.Format24bppRgb)
{
Byte * line = (Byte * )data.Scan0;
for ( int h = 0 ; h < height; h ++ )
{
Rgb24 * c = (Rgb24 * )line;
for ( int w = 0 ; w < width; w ++ )
{
m_converter.Copy(c, t);
t += step;
c ++ ;
}
line += data.Stride;
}
}
else
{
Byte * line = (Byte * )data.Scan0;
for ( int h = 0 ; h < height; h ++ )
{
Argb32 * c = (Argb32 * )line;
for ( int w = 0 ; w < width; w ++ )
{
m_converter.Copy(c, t);
t += step;
c ++ ;
}
line += data.Stride;
}
}
}
catch (Exception)
{
throw ;
}
finally
{
newMap.UnlockBits(data);
}
}
public unsafe Bitmap ToBitmap()
{
Bitmap map = new Bitmap( this .Width, this .Height, PixelFormat.Format32bppArgb);
ToBitmap(map);
return map;
}
public unsafe void ToBitmap(Bitmap map)
{
if (map == null ) throw new ArgumentNullException( " map " );
if (map.Width != this .Width || map.Height != this .Height)
{
throw new ArgumentException( " 尺寸不匹配. " );
}
if (map.PixelFormat != PixelFormat.Format32bppArgb)
{
throw new ArgumentException( " 只支持 Format32bppArgb 格式。 " );
}
Int32 step = SizeOfT();
Byte * t = (Byte * )StartIntPtr;
BitmapData data = map.LockBits( new Rectangle( 0 , 0 , map.Width, map.Height), ImageLockMode.ReadWrite, map.PixelFormat);
try
{
int width = map.Width;
int height = map.Height;
Byte * line = (Byte * )data.Scan0;
for ( int h = 0 ; h < height; h ++ )
{
Argb32 * c = (Argb32 * )line;
for ( int w = 0 ; w < width; w ++ )
{
m_converter.Copy(t, c);
t += step;
c ++ ;
}
line += data.Stride;
}
}
finally
{
map.UnlockBits(data);
}
}
protected abstract IByteConverter < T > CreateByteConverter();
#region IEnumerable<T> Members
public IEnumerator < T > GetEnumerator()
{
return new ImageEnum < T > ( this , this .m_converter);
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
}
internal class ImageEnum < T > : IEnumerator < T >
where T : struct
{
private UnmanagedImage < T > m_img;
private unsafe Byte * m_start;
private Int32 m_step;
private unsafe Byte * m_end;
private unsafe Byte * m_current;
private IByteConverter < T > m_converter;
public unsafe ImageEnum(UnmanagedImage < T > img, IByteConverter < T > converter)
{
m_img = img;
m_start = (Byte * )m_img.StartIntPtr;
m_step = m_img.SizeOfType;
m_end = m_start + m_step * m_img.Length;
m_current = m_start;
m_converter = converter;
}
#region IEnumerator<T> Members
public unsafe T Current
{
get
{
T t = new T();
m_converter.Copy(m_current, ref t);
return t;
}
}
#endregion
#region IDisposable Members
public void Dispose()
{
}
#endregion
#region IEnumerator Members
object System.Collections.IEnumerator.Current
{
get { return Current; }
}
public unsafe bool MoveNext()
{
m_current += this .m_step;
return m_current < m_end;
}
public unsafe void Reset()
{
m_current = m_start;
}
#endregion
}
}
Argb32Image，GrayscaleImage, ImageU8, Rgb24Image是UnmanagedImage<T>的四个实现。对于具体的图像类，可以直接使用指针进行操作，也可以通过索引器和迭代器进行操作。直接通过指针操作的性能大概是后者的4倍。通过迭代器进行操作不用考虑指针越界问题。通过指针和索引器进行操作需自行判断指针越界的问题。
这几个基本类和Bitmap之间的转换很简单高效，如：
Rgb24Image rgb24 = new Rgb24Image(map);
Bitmap to = rgb24.ToBitmap();
使用这几个类进行图像处理，性能逼近C/C++代码。且使用的是非托管内存，又实现了Dispose模式，不会发生内存泄漏。想要及时释放内存，Dispose一下即可。
==================================
在此挑战一下，哪位兄弟能用C#写出性能更高的代码？小弟奉上银鳞胸甲一件！