各种图像处理类库的比较及选择(The Comparison of Image Processing Libraries)
作者：王先荣
前言
近期需要做一些图像处理方面的学习和研究，首要任务就是选择一套合适的图像处理类库。目前较知名且功能完善的图像处理类库有OpenCv、EmguCv、AForge.net等等。本文将从许可协议、下载、安装、文档资料、易用性、性能等方面对这些类库进行比较，然后给出选择建议，当然也包括我自己的选择。
许可协议
| 类库 | 许可协议 | 许可协议网址 | 大致介绍 |
| OpenCv | BSD | www.opensource.org/licenses/bsd-license.html | 在保留原来BSD协议声明的前提下，随便怎么用都行 |
| EmguCv | GPL v3 | http://www.gnu.org/licenses/gpl-3.0.txt | 你的产品必须也使用GPL协议，开源且免费 |
| 商业授权 | http://www.emgu.com/wiki/files/CommercialLicense.txt | 给钱之后可以用于闭源的商业产品 | |
| AForge.net | LGPL v3 | http://www.gnu.org/licenses/lgpl.html | 如果不修改类库源代码，引用该类库的产品可以闭源和（或）收费 |
以上三种类库都可以用于开发商业产品，但是EmguCv需要付费；因为我只是用来学习和研究，所以这些许可协议对我无所谓。不过鉴于我们身在中国，如果脸皮厚点，去他丫的许可协议。
下载
可以很方便的下载到这些类库，下载地址分别为：
类库 | 下载地址 |
OpenCv | http://sourceforge.net/projects/opencvlibrary/files/ |
EmguCv | http://www.emgu.com/wiki/index.php/Download_And_Installation |
AForge.net | http://www.aforgenet.com/framework/downloads.html |
安装
这些类库的安装都比较简单，直接运行安装程序，并点“下一步”即可完成。但是OpenCv在安装完之后还需要一些额外的处理才能在VS2008里面使用，在http://www.opencv.org.cn有一篇名为《VC2008 Express下安装OpenCv 2.0》的文章专门介绍了如何安装OpenCv。
类库 | 安装难易度 | 备注 |
OpenCv | 比较容易 | VC下使用需要重新编译 |
EmguCv | 容易 |
|
AForge.net | 容易 |
|
相信看这篇文章的人都不会被安装困扰。
文档资料
类库 | 总体评价 | 书籍 | 网站 | 文档 | 示例 | 社区 | 备注 |
OpenCv | 中等 | 中英文 | 中英文 | 中英文 | 较多 | 中文论坛 | 有中文资料但不完整 |
EmguCv | 少 | 无 | 英文 | 英文 | 少 | 英文论坛 | 论坛人气很差 |
AForge.net | 少 | 无 | 英文 | 英文 | 少 | 英文论坛 | 论坛人气很差 |
OpenCv有一些中文资料，另外两种的资料全是英文的；不过EmguCv建立在OpenCv的基础上，大部分OpenCv的资料可以用于EmguCv；而AForge.net是原生的.net类库，对GDI+有很多扩展，一些MSDN的资料可以借鉴。如果在查词典的基础上还看不懂英文文档，基本上可以放弃使用这些类库了。
易用性
易用性这玩意，主观意志和个人能力对它影响很大，下面是我的看法：
类库 | 易用性 | 备注 |
OpenCv | 比较差 | OpenCv大多数功能都以C风格函数形式提供，少部分功能以C++类提供。注意：2.0版将更多的功能封装成类了。 |
EmguCv | 比较好 | 将OpenCv的绝大部分功能都包装成了.net类、结构或者枚举。不过文档不全，还是得对照OpenCv的文档去看才行。 |
AForge.net | 好 | 纯.net类库，用起来很方便。 |
最近几年一直用的是C# ，把C和C++忘记得差不多了，况且本来C/C++我就不太熟，所以对OpenCv的看法恐怕有偏见。
性能
这些类库能做的事情很多，我选了最基础的部分来进行性能测试，那就是将一幅彩色图像转换成灰度图，然后再将灰度图转换成二值图像。因为图像处理大部分时间都用于内存读写及运算（特别是矩阵运算），所以这两种操作有一定的代表性。
我分别用以下方式实现了图像的灰度化及二值化：（1）C语言调用OpenCv库；（2）C#调用AForge.net库；（3）C#调用EmguCv库；（4）C#中用P/INVOKE的形式调用OpenCv函数；（5）C#调用自己写的灰度和二值化方法。
C语言调用OpenCv
#include "stdafx.h"
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
#include "winbase.h"
int _tmain(int argc, _TCHAR* argv[])
{
//初始化图像
IplImage * pIplSource=cvLoadImage("E:\\xrwang\\ImageProcessLearn\\Debug\\wky_tms_2272x1704.jpg");
IplImage * pIplGrayscale=cvCreateImage(cvSize(pIplSource->width,pIplSource->height),IPL_DEPTH_8U,1);
IplImage * pIplThreshold=cvCreateImage(cvSize(pIplSource->width,pIplSource->height),IPL_DEPTH_8U,1);
//执行灰度化和二值化，并输出所用时间
LARGE_INTEGER frequency,count1,count2,count3;
double time1,time2;
QueryPerformanceFrequency(&frequency);
for(int i=0;i<10;i++)
{
QueryPerformanceCounter(&count1);
cvCvtColor(pIplSource,pIplGrayscale,CV_BGR2GRAY);
QueryPerformanceCounter(&count2);
cvThreshold(pIplGrayscale,pIplThreshold,128,255,CV_THRESH_BINARY);
QueryPerformanceCounter(&count3);
time1=(double)1000.0*(count2.QuadPart-count1.QuadPart)/frequency.QuadPart;
time2=(double)1000.0*(count3.QuadPart-count2.QuadPart)/frequency.QuadPart;
printf("灰度：%g毫秒，二值化：%g毫秒\r\n",time1,time2);
}
//显示图像
cvNamedWindow("grayscale",0);
cvNamedWindow("threshold",0);
cvResizeWindow("grayscale",600,480);
cvResizeWindow("threshold",600,480);
cvShowImage("grayscale",pIplGrayscale);
cvShowImage("threshold",pIplThreshold);
cvWaitKey(0);
//销毁对象
cvDestroyAllWindows();
cvReleaseImage(&pIplThreshold);
cvReleaseImage(&pIplGrayscale);
cvReleaseImage(&pIplSource);
return 0;
}
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
#include "winbase.h"
int _tmain(int argc, _TCHAR* argv[])
{
//初始化图像
IplImage * pIplSource=cvLoadImage("E:\\xrwang\\ImageProcessLearn\\Debug\\wky_tms_2272x1704.jpg");
IplImage * pIplGrayscale=cvCreateImage(cvSize(pIplSource->width,pIplSource->height),IPL_DEPTH_8U,1);
IplImage * pIplThreshold=cvCreateImage(cvSize(pIplSource->width,pIplSource->height),IPL_DEPTH_8U,1);
//执行灰度化和二值化，并输出所用时间
LARGE_INTEGER frequency,count1,count2,count3;
double time1,time2;
QueryPerformanceFrequency(&frequency);
for(int i=0;i<10;i++)
{
QueryPerformanceCounter(&count1);
cvCvtColor(pIplSource,pIplGrayscale,CV_BGR2GRAY);
QueryPerformanceCounter(&count2);
cvThreshold(pIplGrayscale,pIplThreshold,128,255,CV_THRESH_BINARY);
QueryPerformanceCounter(&count3);
time1=(double)1000.0*(count2.QuadPart-count1.QuadPart)/frequency.QuadPart;
time2=(double)1000.0*(count3.QuadPart-count2.QuadPart)/frequency.QuadPart;
printf("灰度：%g毫秒，二值化：%g毫秒\r\n",time1,time2);
}
//显示图像
cvNamedWindow("grayscale",0);
cvNamedWindow("threshold",0);
cvResizeWindow("grayscale",600,480);
cvResizeWindow("threshold",600,480);
cvShowImage("grayscale",pIplGrayscale);
cvShowImage("threshold",pIplThreshold);
cvWaitKey(0);
//销毁对象
cvDestroyAllWindows();
cvReleaseImage(&pIplThreshold);
cvReleaseImage(&pIplGrayscale);
cvReleaseImage(&pIplSource);
return 0;
}
C#调用各种类库处理图像using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using AForge.Imaging.Filters;
using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.CvEnum;
namespace ImageProcessLearn
{
public partial class FormMain : Form
{
public FormMain()
{
InitializeComponent();
}
//窗体加载时
private void FormMain_Load(object sender, EventArgs e)
{
//显示原始图像
pbSource.Image = Image.FromFile("wky_tms_2272x1704.jpg");
}
//使用选定的类库处理图像
private void btnProcess_Click(object sender, EventArgs e)
{
if (rbAForge.Checked)
{
ProcessImageWithAforge();
}
else if (rbEmgucv.Checked)
{
ProcessImageWithEmgucv();
}
else if (rbOpencv.Checked)
{
ProcessImageWithOpencv();
}
else if (rbOwnMethod.Checked)
ProcessImageWithOwnMethod();
}
/// <summary>
/// 使用AForge.net处理图像
/// </summary>
private void ProcessImageWithAforge()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
sw.Start();
Grayscale grayscaleFilter = new Grayscale(0.299, 0.587, 0.114);
Bitmap bitmapGrayscale = grayscaleFilter.Apply((Bitmap)pbSource.Image);
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = bitmapGrayscale;
//二值化
sw.Reset();
sw.Start();
Threshold thresholdFilter = new Threshold(128);
Bitmap bitmapThreshold = thresholdFilter.Apply(bitmapGrayscale);
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = bitmapThreshold;
//输出所用时间
txtResult.Text += string.Format("类库：AForge.net，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 使用EmguCv处理图像
/// </summary>
private void ProcessImageWithEmgucv()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
Image<Bgr, Byte> imageSource = new Image<Bgr, byte>((Bitmap)pbSource.Image);
sw.Start();
Image<Gray, Byte> imageGrayscale = imageSource.Convert<Gray, Byte>();
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = imageGrayscale.ToBitmap();
//二值化
sw.Reset();
sw.Start();
Image<Gray, Byte> imageThreshold = imageGrayscale.ThresholdBinary(new Gray(128), new Gray(255));
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = imageThreshold.ToBitmap();
//输出所用时间
txtResult.Text += string.Format("类库：EmguCv，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 使用Open Cv P/Invoke处理图像
/// </summary>
unsafe private void ProcessImageWithOpencv()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
Image<Bgr, Byte> imageSource = new Image<Bgr, byte>((Bitmap)pbSource.Image);
IntPtr ptrSource = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MIplImage)));
Marshal.StructureToPtr(imageSource.MIplImage, ptrSource, true);
sw.Start();
IntPtr ptrGrayscale = CvInvoke.cvCreateImage(imageSource.Size, IPL_DEPTH.IPL_DEPTH_8U, 1);
CvInvoke.cvCvtColor(ptrSource, ptrGrayscale, COLOR_CONVERSION.CV_BGR2GRAY);
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = ImageConverter.IplImagePointerToBitmap(ptrGrayscale);
//二值化
sw.Reset();
sw.Start();
IntPtr ptrThreshold = CvInvoke.cvCreateImage(imageSource.Size, IPL_DEPTH.IPL_DEPTH_8U, 1);
CvInvoke.cvThreshold(ptrGrayscale, ptrThreshold, 128d, 255d, THRESH.CV_THRESH_BINARY);
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = ImageConverter.IplImagePointerToBitmap(ptrThreshold);
//释放资源
//CvInvoke.cvReleaseImage(ref ptrThreshold);
//CvInvoke.cvReleaseImage(ref ptrGrayscale);
Marshal.FreeHGlobal(ptrSource);
//输出所用时间
txtResult.Text += string.Format("类库：OpenCv P/Invoke，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 使用自定义的方法处理图像
/// </summary>
private void ProcessImageWithOwnMethod()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
sw.Start();
Bitmap bitmapGrayscale = Grayscale((Bitmap)pbSource.Image);
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = bitmapGrayscale;
//二值化
sw.Reset();
sw.Start();
Bitmap bitmapThreshold = Threshold(bitmapGrayscale, 128);
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = bitmapThreshold;
//输出所用时间
txtResult.Text += string.Format("类库：自定义方法，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 将指定图像转换成灰度图
/// </summary>
/// <param name="bitmapSource">源图像支持3通道或者4通道图像，支持Format24bppRgb、Format32bppRgb和Format32bppArgb这3种像素格式</param>
/// <returns>返回灰度图，如果转化失败，返回null。</returns>
private 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;
}
/// <summary>
/// 将指定的灰度图像转换成二值图像。如果某个像素的值大于等于阀值，该像素置为白色；否则置为黑色。
/// 目前支持8bpp和16bpp两种灰度图像的转换，对于8bpp，阀值介于0~255之间；对于16bpp，阀值介于0~65535之间。
/// </summary>
/// <param name="bitmapGrayscale">灰度图像</param>
/// <param name="thresholdValue">阀值</param>
/// <returns>返回转换之后的二值图像；如果转换失败，返回null。</returns>
private Bitmap Threshold(Bitmap bitmapGrayscale,int thresholdValue)
{
Bitmap bitmapThreshold = null;
if (bitmapGrayscale != null)
{
int width = bitmapGrayscale.Width;
int height = bitmapGrayscale.Height;
Rectangle rect = new Rectangle(0, 0, width, height);
PixelFormat pixelFormat = bitmapGrayscale.PixelFormat;
if (pixelFormat == PixelFormat.Format8bppIndexed)
{
if (thresholdValue >= 0 && thresholdValue <= 255)
{
bitmapThreshold = (Bitmap)bitmapGrayscale.Clone();
byte white = 255;
byte black = 0;
BitmapData data = bitmapThreshold.LockBits(rect, ImageLockMode.ReadWrite, pixelFormat);
unsafe
{
byte* ptrStart = (byte*)data.Scan0.ToPointer();
byte* ptr1;
for (int row = 0; row < height; row++)
{
ptr1 = ptrStart + data.Stride * row;
for (int col = 0; col < width; col++)
{
*ptr1 = (*ptr1 < thresholdValue) ? black : white;
ptr1++;
}
}
}
bitmapThreshold.UnlockBits(data);
}
}
else if (pixelFormat == PixelFormat.Format16bppGrayScale)
{
bitmapThreshold = (Bitmap)bitmapGrayscale.Clone();
UInt16 white = 65535;
UInt16 black = 0;
BitmapData data = bitmapThreshold.LockBits(rect, ImageLockMode.ReadWrite, pixelFormat);
unsafe
{
byte* ptrStart = (byte*)data.Scan0.ToPointer();
UInt16* ptr1;
for (int row = 0; row < height; row++)
{
ptr1 = (UInt16*)(ptrStart + data.Stride * row);
for (int col = 0; col < width; col++)
{
*ptr1 = (*ptr1 < thresholdValue) ? black : white;
ptr1++;
}
}
}
bitmapThreshold.UnlockBits(data);
}
}
return bitmapThreshold;
}
}
}
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using AForge.Imaging.Filters;
using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.CvEnum;
namespace ImageProcessLearn
{
public partial class FormMain : Form
{
public FormMain()
{
InitializeComponent();
}
//窗体加载时
private void FormMain_Load(object sender, EventArgs e)
{
//显示原始图像
pbSource.Image = Image.FromFile("wky_tms_2272x1704.jpg");
}
//使用选定的类库处理图像
private void btnProcess_Click(object sender, EventArgs e)
{
if (rbAForge.Checked)
{
ProcessImageWithAforge();
}
else if (rbEmgucv.Checked)
{
ProcessImageWithEmgucv();
}
else if (rbOpencv.Checked)
{
ProcessImageWithOpencv();
}
else if (rbOwnMethod.Checked)
ProcessImageWithOwnMethod();
}
/// <summary>
/// 使用AForge.net处理图像
/// </summary>
private void ProcessImageWithAforge()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
sw.Start();
Grayscale grayscaleFilter = new Grayscale(0.299, 0.587, 0.114);
Bitmap bitmapGrayscale = grayscaleFilter.Apply((Bitmap)pbSource.Image);
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = bitmapGrayscale;
//二值化
sw.Reset();
sw.Start();
Threshold thresholdFilter = new Threshold(128);
Bitmap bitmapThreshold = thresholdFilter.Apply(bitmapGrayscale);
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = bitmapThreshold;
//输出所用时间
txtResult.Text += string.Format("类库：AForge.net，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 使用EmguCv处理图像
/// </summary>
private void ProcessImageWithEmgucv()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
Image<Bgr, Byte> imageSource = new Image<Bgr, byte>((Bitmap)pbSource.Image);
sw.Start();
Image<Gray, Byte> imageGrayscale = imageSource.Convert<Gray, Byte>();
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = imageGrayscale.ToBitmap();
//二值化
sw.Reset();
sw.Start();
Image<Gray, Byte> imageThreshold = imageGrayscale.ThresholdBinary(new Gray(128), new Gray(255));
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = imageThreshold.ToBitmap();
//输出所用时间
txtResult.Text += string.Format("类库：EmguCv，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 使用Open Cv P/Invoke处理图像
/// </summary>
unsafe private void ProcessImageWithOpencv()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
Image<Bgr, Byte> imageSource = new Image<Bgr, byte>((Bitmap)pbSource.Image);
IntPtr ptrSource = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MIplImage)));
Marshal.StructureToPtr(imageSource.MIplImage, ptrSource, true);
sw.Start();
IntPtr ptrGrayscale = CvInvoke.cvCreateImage(imageSource.Size, IPL_DEPTH.IPL_DEPTH_8U, 1);
CvInvoke.cvCvtColor(ptrSource, ptrGrayscale, COLOR_CONVERSION.CV_BGR2GRAY);
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = ImageConverter.IplImagePointerToBitmap(ptrGrayscale);
//二值化
sw.Reset();
sw.Start();
IntPtr ptrThreshold = CvInvoke.cvCreateImage(imageSource.Size, IPL_DEPTH.IPL_DEPTH_8U, 1);
CvInvoke.cvThreshold(ptrGrayscale, ptrThreshold, 128d, 255d, THRESH.CV_THRESH_BINARY);
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = ImageConverter.IplImagePointerToBitmap(ptrThreshold);
//释放资源
//CvInvoke.cvReleaseImage(ref ptrThreshold);
//CvInvoke.cvReleaseImage(ref ptrGrayscale);
Marshal.FreeHGlobal(ptrSource);
//输出所用时间
txtResult.Text += string.Format("类库：OpenCv P/Invoke，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 使用自定义的方法处理图像
/// </summary>
private void ProcessImageWithOwnMethod()
{
Stopwatch sw = new Stopwatch(); //计时器
//灰度
sw.Start();
Bitmap bitmapGrayscale = Grayscale((Bitmap)pbSource.Image);
sw.Stop();
double timeGrayscale = sw.Elapsed.TotalMilliseconds;
if (pbGrayscale.Image != null)
{
pbGrayscale.Image.Dispose();
pbGrayscale.Image = null;
}
pbGrayscale.Image = bitmapGrayscale;
//二值化
sw.Reset();
sw.Start();
Bitmap bitmapThreshold = Threshold(bitmapGrayscale, 128);
sw.Stop();
double timeThreshold = sw.Elapsed.TotalMilliseconds;
if (pbThreshold.Image != null)
{
pbThreshold.Image.Dispose();
pbThreshold.Image = null;
}
pbThreshold.Image = bitmapThreshold;
//输出所用时间
txtResult.Text += string.Format("类库：自定义方法，灰度：{0:F05}毫秒，二值化：{1:F05}毫秒\r\n", timeGrayscale, timeThreshold);
}
/// <summary>
/// 将指定图像转换成灰度图
/// </summary>
/// <param name="bitmapSource">源图像支持3通道或者4通道图像，支持Format24bppRgb、Format32bppRgb和Format32bppArgb这3种像素格式</param>
/// <returns>返回灰度图，如果转化失败，返回null。</returns>
private 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;
}
/// <summary>
/// 将指定的灰度图像转换成二值图像。如果某个像素的值大于等于阀值，该像素置为白色；否则置为黑色。
/// 目前支持8bpp和16bpp两种灰度图像的转换，对于8bpp，阀值介于0~255之间；对于16bpp，阀值介于0~65535之间。
/// </summary>
/// <param name="bitmapGrayscale">灰度图像</param>
/// <param name="thresholdValue">阀值</param>
/// <returns>返回转换之后的二值图像；如果转换失败，返回null。</returns>
private Bitmap Threshold(Bitmap bitmapGrayscale,int thresholdValue)
{
Bitmap bitmapThreshold = null;
if (bitmapGrayscale != null)
{
int width = bitmapGrayscale.Width;
int height = bitmapGrayscale.Height;
Rectangle rect = new Rectangle(0, 0, width, height);
PixelFormat pixelFormat = bitmapGrayscale.PixelFormat;
if (pixelFormat == PixelFormat.Format8bppIndexed)
{
if (thresholdValue >= 0 && thresholdValue <= 255)
{
bitmapThreshold = (Bitmap)bitmapGrayscale.Clone();
byte white = 255;
byte black = 0;
BitmapData data = bitmapThreshold.LockBits(rect, ImageLockMode.ReadWrite, pixelFormat);
unsafe
{
byte* ptrStart = (byte*)data.Scan0.ToPointer();
byte* ptr1;
for (int row = 0; row < height; row++)
{
ptr1 = ptrStart + data.Stride * row;
for (int col = 0; col < width; col++)
{
*ptr1 = (*ptr1 < thresholdValue) ? black : white;
ptr1++;
}
}
}
bitmapThreshold.UnlockBits(data);
}
}
else if (pixelFormat == PixelFormat.Format16bppGrayScale)
{
bitmapThreshold = (Bitmap)bitmapGrayscale.Clone();
UInt16 white = 65535;
UInt16 black = 0;
BitmapData data = bitmapThreshold.LockBits(rect, ImageLockMode.ReadWrite, pixelFormat);
unsafe
{
byte* ptrStart = (byte*)data.Scan0.ToPointer();
UInt16* ptr1;
for (int row = 0; row < height; row++)
{
ptr1 = (UInt16*)(ptrStart + data.Stride * row);
for (int col = 0; col < width; col++)
{
*ptr1 = (*ptr1 < thresholdValue) ? black : white;
ptr1++;
}
}
}
bitmapThreshold.UnlockBits(data);
}
}
return bitmapThreshold;
}
}
}
分别用上述5种形式处理10次，记录下运行时间，去掉每种的最大和最小数据，然后计算平均值。结果如下所示（单位是毫秒）：
语言 | 类库 | 灰度化 | 二值化 | 性能排名 |
C | OpenCv | 16.89721 | 7.807766 | 1 |
C# | Aforge.net | 48.9403 | 25.32473 | 5 |
C# | EmguCv | 18.86898 | 13.74628 | 3 |
C# | OpenCv(P/Invoke) | 18.68938 | 10.0149 | 2 |
C# | 自定义处理方法 | 48.33593 | 21.46168 | 4 |
测试环境如下：CPU-奔腾4 2.4G，内存-512M，操作系统-Windows XP SP2，显卡-nVidia GForce4 64M，进程数-49，线程数-611，句柄数-13004，可用内存101M。
毫无疑问，用C语言调用OpenCv的性能最好，两种纯.net的方式性能最差。
C语言调用OpenCv的处理效果如下所示：
C#的处理效果如下：
结论
将上面的内容汇总结果如下表所示：
类库 | OpenCv | EmguCv | AForge.net |
许可协议 | BSD | GPL v3或商业授权 | LGPL v3 |
下载 | 方便 | 方便 | 方便 |
安装 | 比较容易 | 容易 | 容易 |
文档资料 | 中等 | 少 | 少 |
易用性 | 比较差 | 比较好 | 好 |
性能 | 很好 | 比较好 | 不好 |
综上所述，我的选择是使用EmguCv作为我的图像处理类库，在必要的时候用P/Invoke的形式调用没有被封装的OpenCv函数。你呢？
感谢您耐心看完本文，希望对您有所帮助。
博客园的文本编辑器太操蛋了，辛苦打了一个多小时的字，突然弹出一个错误提示无法继续了。提醒大家注意：如果博客内容较长，一定要用别的工具（例如WORD）编写好，然后再复制到博客园的编辑器。