各种图像处理类库的比较及选择(The Comparison of Image Processing Libraries)

前言

近期需要做一些图像处理方面的学习和研究，首要任务就是选择一套合适的图像处理类库。目前较知名且功能完善的图像处理类库有OpenCv、EmguCv、AForge.net等等。本文将从许可协议、下载、安装、文档资料、易用性、性能等方面对这些类库进行比较，然后给出选择建议，当然也包括我自己的选择。

许可协议

以上三种类库都可以用于开发商业产品，但是EmguCv需要付费；因为我只是用来学习和研究，所以这些许可协议对我无所谓。不过鉴于我们身在中国，如果脸皮厚点，去他丫的许可协议。

下载

可以很方便的下载到这些类库，下载地址分别为：

安装

这些类库的安装都比较简单，直接运行安装程序，并点“下一步”即可完成。但是OpenCv在安装完之后还需要一些额外的处理才能在VS2008里面使用，在http://www.opencv.org.cn有一篇名为《VC2008 Express下安装OpenCv 2.0》的文章专门介绍了如何安装OpenCv。

相信看这篇文章的人都不会被安装困扰。

文档资料 

OpenCv有一些中文资料，另外两种的资料全是英文的；不过EmguCv建立在OpenCv的基础上，大部分OpenCv的资料可以用于EmguCv；而AForge.net是原生的.net类库，对GDI+有很多扩展，一些MSDN的资料可以借鉴。如果在查词典的基础上还看不懂英文文档，基本上可以放弃使用这些类库了。

易用性

易用性这玩意，主观意志和个人能力对它影响很大，下面是我的看法：

最近几年一直用的是C# ，把C和C++忘记得差不多了，况且本来C/C++我就不太熟，所以对OpenCv的看法恐怕有偏见。

性能

这些类库能做的事情很多，我选了最基础的部分来进行性能测试，那就是将一幅彩色图像转换成灰度图，然后再将灰度图转换成二值图像。因为图像处理大部分时间都用于内存读写及运算（特别是矩阵运算），所以这两种操作有一定的代表性。

我分别用以下方式实现了图像的灰度化及二值化：（1）C语言调用OpenCv库；（2）C#调用AForge.net库；（3）C#调用EmguCv库；（4）C#中用P/INVOKE的形式调用OpenCv函数；（5）C#调用自己写的灰度和二值化方法。

#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;
}

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;
        }
    }
}

     分别用上述5种形式处理10次，记录下运行时间，去掉每种的最大和最小数据，然后计算平均值。结果如下所示（单位是毫秒）：

测试环境如下：CPU-奔腾4 2.4G，内存-512M，操作系统-Windows XP SP2，显卡-nVidia GForce4 64M，进程数-49，线程数-611，句柄数-13004，可用内存101M。

毫无疑问，用C语言调用OpenCv的性能最好，两种纯.net的方式性能最差。

 C语言调用OpenCv的处理效果如下所示：

C#的处理效果如下：

结论

将上面的内容汇总结果如下表所示：

综上所述，我的选择是使用EmguCv作为我的图像处理类库，在必要的时候用P/Invoke的形式调用没有被封装的OpenCv函数。你呢？

感谢您耐心看完本文，希望对您有所帮助。

博客园的文本编辑器太操蛋了，辛苦打了一个多小时的字，突然弹出一个错误提示无法继续了。提醒大家注意：如果博客内容较长，一定要用别的工具（例如WORD）编写好，然后再复制到博客园的编辑器。