OpenCV，多种Mat图像元素访问方式的速度对比

本文部分文字为转载，仅供个人学习记录，如果无意中侵犯了您的版权请联系本人：[email protected]，.本人会及时编辑掉

原作者：http://blog.csdn.net/ljbkiss/article/details/7381208

图像对象：lena.png; 512*512;后面为循环次数;运行时间为us;
测试环境：intel core i3, 2G RAM 破台式, Win7-x64, VS2012, OpenCV2.4.9

测试代码如下：

// ConsoleAppOpenCvMatTest.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/contrib/contrib.hpp>
#include <iostream>
#include <fstream>
using namespace cv;
using namespace std;

/*
为了输出看是否每种方法取得是相同的像素，不要对大图像进行此操作，会很慢的哦！
下面的例子，在输出时使用的是30*40的图像。
测试时间时要注释掉，否则I/O操作将极大影响处理时间。
*/
//#define PIXEL_OUT//测试的时候可以去掉这个注释，但是很耗时


int main(int argc,char *argv[])
{
	ofstream fout("pixels.txt");

#ifdef PIXEL_OUT
	Mat img=imread("cat.jpg");
#else
	Mat img=imread("lena.png");
#endif

	if(!img.data)
	{
		cout<<"load image failed!"<<endl;
		return -1;
	}
	Mat temp;
	img.convertTo(temp, CV_32FC3);
	namedWindow("show");
	int i,j;
	TickMeter tm;//用于计时
	double process_time[7]={0.0};//用于存储测试时间结果
	int loop_times =1;
	for(int n=0; n<loop_times; ++n)
	{
		////////////////////////======section1======//////////////////////////
		/*
		多通道图像，先将通道split分开，然后针对特定的通道进行处理，
		每个元素的获取采用的是首先获得行指针，然后逐个获得单通道元素。
		既可以进行元素为单位的处理，也可以进行跨行的局部块为单位的处理。
		*/
		fout<<"-------1-------"<<endl;
		tm.reset();//
		tm.start();
		vector<Mat> spl;		
		split(temp, spl);
		for (i=0; i<temp.rows; ++i)//每行
		{
			float *pt = spl[1].ptr<float>(i);
			for (j=0; j<temp.cols; ++j)
			{
				float mm = pt[j];
				mm /= 20.6f;
#ifdef PIXEL_OUT
				fout<<mm<<" ";
#endif
			}
		}
		merge(spl, temp);
		tm.stop();
		process_time[0] += tm.getTimeMicro();
		cout<<"method=1,process time="<<tm.getTimeMicro()<<endl;

		//////////////////////////=========section2=========////////////////////////////////
		/*
		没有将多通道分开，而是直接对原始Mat操作，也是首先获得单行的指针，然后获得每个元素的；
		每个元素是多通道的，可以通过[]来获得单个通道的单个元素。可以以元素为单位处理，也可以进行
		跨行的局部块处理。
		*/
		fout<<"-------2-------"<<endl;
		tm.reset();
		tm.start();
		for (i=0; i<temp.rows; ++i)
		{
			float *pts = temp.ptr<float>(i);
			for (j=0; j<temp.cols; ++j)
			{
				float mm = pts[3*j+1];
				mm /=20.6f;
#ifdef PIXEL_OUT
				fout<<mm<<" ";
#endif
			}
		}
		tm.stop();
		process_time[1] += tm.getTimeMicro();
		cout<<"method=2,process time="<<tm.getTimeMicro()<<endl;

		//////////////////////////============section3==========//////////////////////////////	
		/*
		对连续存储的Mat每个元素的获取，将整个Mat矩阵看做是一个m*n列，1行的数组，在手册提倡的方法中
		是最快的。但是缺点是丢失了行列信息，只能进行以元素为单位的处理，或者说本行局部的处理，不能进行
		跨行的局部块处理。
		*/
		fout<<"-------3-------"<<endl;
		tm.reset();
		tm.start();
		int col=temp.cols, row = temp.rows;
		if (temp.isContinuous())
		{
			col*=row;
			row =1;
		}
		for (i=0; i<row; ++i)
		{
			const float *pt = temp.ptr<float>(i);
			for (j=0; j<col;++j)
			{
				float mm=pt[3*j+1];
				mm /= 20.6f;
#ifdef PIXEL_OUT
				fout<<mm<<" ";
#endif
			}
		}
		tm.stop();
		process_time[2] += tm.getTimeMicro();
		cout<<"method=3,process time="<<tm.getTimeMicro()<<endl;

		///////////////////////////===========section4===============/////////////////////////////////
		/*
		直接对原始存储指针的处理，需要对指针比较熟悉，特别是对Mat的数据类型必须清楚，所有类型的Mat的存储都是uchar的即字节为
		单位的，但是不同的存储类型决定了对指针的解释不同。这样获得的是原始的多通道的第一个通道的指针，访问其他通道时需要进行
		合适的偏移，ex：下面的是对通道2的访问。该方法可以说最灵活，但是因为直接操作指针所以也最容易出错；既可以处理像素为单位，
		也可以处理跨行的局部块为单位。类似于C接口时的元素获取方法。
		*/
		fout<<"-------4-------"<<endl;
		tm.reset();
		tm.start();
		int step0=temp.step[0],step1=temp.step[1];
		for (i=0; i<temp.rows; ++i)
		{
			for (j=0; j<temp.cols; ++j)
			{
				float *pix = (float *)(temp.data+i*step0+j*step1);
				float tt= *(pix+1)/20.6f;
#ifdef PIXEL_OUT
				fout<<tt<<" ";
#endif
			}
		}
		tm.stop();
		process_time[3] += tm.getTimeMicro();
		cout<<"method=4,process time="<<tm.getTimeMicro()<<endl;

		//////////////////////////============section5==========//////////////////////////////	
		/*
		与上面的获取方法本质一样，只是首先进行了矩阵的连续性判断，其他的一样；但是丢失了行列信息，
		只能进行元素的局部性处理。
		*/
		fout<<"-------5-------"<<endl;
		tm.reset();
		tm.start();
		int step00=temp.step[0],step01=temp.step[1];
		int col2=temp.cols, row2 = temp.rows;
		if (temp.isContinuous())
		{
			col2*=row2;
			row2 =1;
		}
		for (i=0; i<row2; ++i)
		{
			for (j=0; j<col2;++j)
			{
				float *mm= (float *)(temp.data+i*step00+j*step01);
				float tt = *(mm+1)/20.6f;
#ifdef PIXEL_OUT
				fout<<tt<<" ";
#endif
			}
		}
		tm.stop();	
		process_time[4] += tm.getTimeMicro();
		cout<<"method=5,process time="<<tm.getTimeMicro()<<endl;

		//////////////////////////=========section6=========////////////////////////////////
		/*
		采用迭代器的获取方法，速度最慢，可能好处就是可以使用STL标准库的算法，同样也没有了行列信息。
		*/
		fout<<"-------6-------"<<endl;
		tm.reset();
		tm.start();
		MatConstIterator_<Vec3f> iters = temp.begin<Vec3f>(),end=temp.end<Vec3f>();
		for(; iters!=end; ++iters)
		{
			Vec3f vec3f = *iters;
			vec3f.val[1] /= 20.6f;
#ifdef PIXEL_OUT
			fout<<vec3f.val[1]<<" ";
#endif
		}
		tm.stop();
		process_time[5] += tm.getTimeMicro();
		cout<<"method=6,process time="<<tm.getTimeMicro()<<endl;	
		
		//////////////////////////=========section7=========////////////////////////////////
		/*
		没有将多通道分开，而是直接对原始Mat操作 直接获得每个元素；
		每个元素是多通道的，将其视为了向量，所以可以通过[]来获得单个通道的单个元素。可以以元素为单位处理，
		也可以进行跨行的局部块处理。速度也很慢！
		*/
		fout<<"-------7-------"<<endl;
		tm.reset();
		tm.start();
		for (i=0; i<temp.rows; ++i)
		{
			for (j=0; j<temp.cols; ++j)
			{			
				float mm = temp.at<Vec3f>(i,j)[1];
				mm /=20.6f;
#ifdef PIXEL_OUT
				fout<<mm<<" ";
#endif
			}
		}
		tm.stop();
		process_time[6] += tm.getTimeMicro();
		cout<<"method=7,process time="<<tm.getTimeMicro()<<endl;

	}

	cout<<"---------------------------------"<<endl;
	for (int m=0; m<7; ++m)
	{
		cout<<m+1<<"="<<process_time[m]/loop_times<<endl;
	}

	//////////////=====================end====================///////////
	imshow("show", img);
	waitKey(0);
	return 0;
}

测试结果：

本例子说明了：

1，由于split和merge操作比较耗时，方式1是最慢的方法，但是使用很方便

2，方式2,3,最快，4,5速度较快，6,7最慢