opencv 3 core组件进阶(1 访问图像中的像素）

访问图像像素的三类方法

·方法一指针访问:C操作符[ ];

·方法二迭代器iterator;

·方法三动态地址计算。

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <iostream>

using namespace std;

using namespace cv;

//-----------------------------------【全局函数声明部分】-----------------------------------

//          描述：全局函数声明

//-----------------------------------------------------------------------------------------------

void colorReduce(Mat& inputImage, Mat& outputImage, int div);

void ShowHelpText();

//--------------------------------------【main( )函数】---------------------------------------

//          描述：控制台应用程序的入口函数，我们的程序从这里开始执行

//-----------------------------------------------------------------------------------------------

int main()

{

	//【1】创建原始图并显示

	Mat srcImage = imread("G:\\1.jpg");

	imshow("原始图像", srcImage);

	//【2】按原始图的参数规格来创建创建效果图

	Mat dstImage;

	dstImage.create(srcImage.rows, srcImage.cols, srcImage.type());//效果图的大小、类型与原图片相同 

	ShowHelpText();

	//【3】记录起始时间

	double time0 = static_cast<double>(getTickCount());

	//【4】调用颜色空间缩减函数

	colorReduce(srcImage, dstImage, 32);

	//【5】计算运行时间并输出

	time0 = ((double)getTickCount() - time0) / getTickFrequency();

	cout << "\t此方法运行时间为： " << time0 << "秒" << endl;  //输出运行时间

	//【6】显示效果图

	imshow("效果图", dstImage);

	waitKey(0);

}

//---------------------------------【colorReduce( )函数】---------------------------------

//          描述：使用【指针访问：C操作符[ ]】方法版的颜色空间缩减函数

//----------------------------------------------------------------------------------------------

void colorReduce(Mat& inputImage, Mat& outputImage, int div)

{

	//参数准备

	outputImage = inputImage.clone();  //拷贝实参到临时变量

	int rowNumber = outputImage.rows;  //行数

	int colNumber = outputImage.cols*outputImage.channels();  //列数 x 通道数=每一行元素的个数

	//双重循环，遍历所有的像素值

	for (int i = 0; i < rowNumber; i++)  //行循环

	{

		uchar* data = outputImage.ptr<uchar>(i);  //获取第i行的首地址

		for (int j = 0; j < colNumber; j++)   //列循环

		{

			// ---------【开始处理每个像素】-------------

			data[j] = data[j] / div * div + div / 2;

			// ----------【处理结束】---------------------

		}  //行处理结束

	}

}

//-----------------------------------【ShowHelpText( )函数】----------------------------------

//          描述：输出一些帮助信息

//----------------------------------------------------------------------------------------------

void ShowHelpText()

{

	//输出欢迎信息和OpenCV版本

	printf("\n\n\t\t\t   当前使用的OpenCV版本为：" CV_VERSION);

	printf("\n\n  ----------------------------------------------------------------------------\n");

}

用指针访问

如上所示

用迭代器

动态地址计算

大神的14种方法

//---------------------------------【头文件、命名空间包含部分】-----------------------------

//		描述：包含程序所使用的头文件和命名空间

//-------------------------------------------------------------------------------------------------

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

using namespace std;

//---------------------------------【宏定义部分】---------------------------------------------

//		描述：包含程序所使用宏定义

//-------------------------------------------------------------------------------------------------

#define NTESTS 14

#define NITERATIONS 20

//----------------------------------------- 【方法一】-------------------------------------------

//		说明：利用.ptr 和 []

//-------------------------------------------------------------------------------------------------

void colorReduce0(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols * image.channels(); //每行元素的总元素数量

	for (int j = 0; j < nl; j++)

	{

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++)

		{

			//-------------开始处理每个像素-------------------

			data[i] = data[i] / div * div + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

//-----------------------------------【方法二】-------------------------------------------------

//		说明：利用 .ptr 和 * ++

//-------------------------------------------------------------------------------------------------

void colorReduce1(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols * image.channels(); //每行元素的总元素数量

	for (int j = 0; j < nl; j++)

	{

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++)

		{

			//-------------开始处理每个像素-------------------

			*data++ = *data / div * div + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

//-----------------------------------------【方法三】-------------------------------------------

//		说明：利用.ptr 和 * ++ 以及模操作

//-------------------------------------------------------------------------------------------------

void colorReduce2(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols * image.channels(); //每行元素的总元素数量

	for (int j = 0; j < nl; j++)

	{

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++)

		{

			//-------------开始处理每个像素-------------------

			int v = *data;

			*data++ = v - v % div + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

//----------------------------------------【方法四】---------------------------------------------

//		说明：利用.ptr 和 * ++ 以及位操作

//----------------------------------------------------------------------------------------------------

void colorReduce3(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols * image.channels(); //每行元素的总元素数量

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g. 对于 div=16, mask= 0xF0

	for (int j = 0; j < nl; j++) {

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++) {

			//------------开始处理每个像素-------------------

			*data++ = *data&mask + div / 2;

			//-------------结束像素处理------------------------

		}  //单行处理结束

	}

}

//----------------------------------------【方法五】----------------------------------------------

//		说明：利用指针算术运算

//---------------------------------------------------------------------------------------------------

void colorReduce4(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols * image.channels(); //每行元素的总元素数量

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	int step = image.step; //有效宽度

	//掩码值

	uchar mask = 0xFF << n; // e.g. 对于 div=16, mask= 0xF0

	//获取指向图像缓冲区的指针

	uchar *data = image.data;

	for (int j = 0; j < nl; j++)

	{

		for (int i = 0; i < nc; i++)

		{

			//-------------开始处理每个像素-------------------

			*(data + i) = *data&mask + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束              

		data += step;  // next line

	}

}

//---------------------------------------【方法六】----------------------------------------------

//		说明：利用 .ptr 和 * ++以及位运算、image.cols * image.channels()

//-------------------------------------------------------------------------------------------------

void colorReduce5(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g. 例如div=16, mask= 0xF0

	for (int j = 0; j < nl; j++)

	{

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < image.cols * image.channels(); i++)

		{

			//-------------开始处理每个像素-------------------

			*data++ = *data&mask + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

// -------------------------------------【方法七】----------------------------------------------

//		说明：利用.ptr 和 * ++ 以及位运算(continuous)

//-------------------------------------------------------------------------------------------------

void colorReduce6(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols * image.channels(); //每行元素的总元素数量

	if (image.isContinuous())

	{

		//无填充像素

		nc = nc * nl;

		nl = 1;  // 为一维数列

	}

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g. 比如div=16, mask= 0xF0

	for (int j = 0; j < nl; j++) {

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++) {

			//-------------开始处理每个像素-------------------

			*data++ = *data&mask + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

//------------------------------------【方法八】------------------------------------------------

//		说明：利用 .ptr 和 * ++ 以及位运算 (continuous+channels)

//-------------------------------------------------------------------------------------------------

void colorReduce7(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols; //列数

	if (image.isContinuous())

	{

		//无填充像素

		nc = nc * nl;

		nl = 1;  // 为一维数组

	}

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g. 比如div=16, mask= 0xF0

	for (int j = 0; j < nl; j++) {

		uchar* data = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++) {

			//-------------开始处理每个像素-------------------

			*data++ = *data&mask + div / 2;

			*data++ = *data&mask + div / 2;

			*data++ = *data&mask + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

// -----------------------------------【方法九】 ------------------------------------------------

//		说明：利用Mat_ iterator

//-------------------------------------------------------------------------------------------------

void colorReduce8(Mat &image, int div = 64) {

	//获取迭代器

	Mat_<Vec3b>::iterator it = image.begin<Vec3b>();

	Mat_<Vec3b>::iterator itend = image.end<Vec3b>();

	for (; it != itend; ++it) {

		//-------------开始处理每个像素-------------------

		(*it)[0] = (*it)[0] / div * div + div / 2;

		(*it)[1] = (*it)[1] / div * div + div / 2;

		(*it)[2] = (*it)[2] / div * div + div / 2;

		//-------------结束像素处理------------------------

	}//单行处理结束

}

//-------------------------------------【方法十】-----------------------------------------------

//		说明：利用Mat_ iterator以及位运算

//-------------------------------------------------------------------------------------------------

void colorReduce9(Mat &image, int div = 64) {

	// div必须是2的幂

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g. 比如 div=16, mask= 0xF0

	// 获取迭代器

	Mat_<Vec3b>::iterator it = image.begin<Vec3b>();

	Mat_<Vec3b>::iterator itend = image.end<Vec3b>();

	//扫描所有元素

	for (; it != itend; ++it)

	{

		//-------------开始处理每个像素-------------------

		(*it)[0] = (*it)[0] & mask + div / 2;

		(*it)[1] = (*it)[1] & mask + div / 2;

		(*it)[2] = (*it)[2] & mask + div / 2;

		//-------------结束像素处理------------------------

	}//单行处理结束

}

//------------------------------------【方法十一】---------------------------------------------

//		说明：利用Mat Iterator_

//-------------------------------------------------------------------------------------------------

void colorReduce10(Mat &image, int div = 64) {

	//获取迭代器

	Mat_<Vec3b> cimage = image;

	Mat_<Vec3b>::iterator it = cimage.begin();

	Mat_<Vec3b>::iterator itend = cimage.end();

	for (; it != itend; it++) {

		//-------------开始处理每个像素-------------------

		(*it)[0] = (*it)[0] / div * div + div / 2;

		(*it)[1] = (*it)[1] / div * div + div / 2;

		(*it)[2] = (*it)[2] / div * div + div / 2;

		//-------------结束像素处理------------------------

	}

}

//--------------------------------------【方法十二】--------------------------------------------

//		说明：利用动态地址计算配合at

//-------------------------------------------------------------------------------------------------

void colorReduce11(Mat &image, int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols; //列数

	for (int j = 0; j < nl; j++)

	{

		for (int i = 0; i < nc; i++)

		{

			//-------------开始处理每个像素-------------------

			image.at<Vec3b>(j, i)[0] = image.at<Vec3b>(j, i)[0] / div * div + div / 2;

			image.at<Vec3b>(j, i)[1] = image.at<Vec3b>(j, i)[1] / div * div + div / 2;

			image.at<Vec3b>(j, i)[2] = image.at<Vec3b>(j, i)[2] / div * div + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

//----------------------------------【方法十三】-----------------------------------------------

//		说明：利用图像的输入与输出

//-------------------------------------------------------------------------------------------------

void colorReduce12(const Mat &image, //输入图像

	Mat &result,      // 输出图像

	int div = 64) {

	int nl = image.rows; //行数

	int nc = image.cols; //列数

	//准备好初始化后的Mat给输出图像

	result.create(image.rows, image.cols, image.type());

	//创建无像素填充的图像

	nc = nc * nl;

	nl = 1;  //单维数组

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g.比如div=16, mask= 0xF0

	for (int j = 0; j < nl; j++) {

		uchar* data = result.ptr<uchar>(j);

		const uchar* idata = image.ptr<uchar>(j);

		for (int i = 0; i < nc; i++) {

			//-------------开始处理每个像素-------------------

			*data++ = (*idata++)&mask + div / 2;

			*data++ = (*idata++)&mask + div / 2;

			*data++ = (*idata++)&mask + div / 2;

			//-------------结束像素处理------------------------

		} //单行处理结束

	}

}

//--------------------------------------【方法十四】-------------------------------------------

//		说明：利用操作符重载

//-------------------------------------------------------------------------------------------------

void colorReduce13(Mat &image, int div = 64) {

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	//掩码值

	uchar mask = 0xFF << n; // e.g. 比如div=16, mask= 0xF0

	//进行色彩还原

	image = (image&Scalar(mask, mask, mask)) + Scalar(div / 2, div / 2, div / 2);

}

//-----------------------------------【ShowHelpText( )函数】-----------------------------

//		描述：输出一些帮助信息

//----------------------------------------------------------------------------------------------

void ShowHelpText()

{

	printf("\n\n\t\t\t   当前使用的OpenCV版本为：" CV_VERSION);

	printf("\n\n  ----------------------------------------------------------------------------\n");

	printf("\n\n正在进行存取操作，请稍等……\n\n");

}

//-----------------------------------【main( )函数】--------------------------------------------

//		描述：控制台应用程序的入口函数，我们的程序从这里开始

//-------------------------------------------------------------------------------------------------

int main()

{

	int64 t[NTESTS], tinit;

	Mat image0;

	Mat image1;

	Mat image2;

	system("color 4F");

	ShowHelpText();

	image0 = imread("G:\\1.jpg");

	if (!image0.data)

		return 0;

	//时间值设为0

	for (int i = 0; i < NTESTS; i++)

		t[i] = 0;

	// 多次重复测试

	int n = NITERATIONS;

	for (int k = 0; k < n; k++)

	{

		cout << k << " of " << n << endl;

		image1 = imread("G:\\1.jpg");

		//【方法一】利用.ptr 和 []

		tinit = getTickCount();

		colorReduce0(image1);

		t[0] += getTickCount() - tinit;

		//【方法二】利用 .ptr 和 * ++

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce1(image1);

		t[1] += getTickCount() - tinit;

		//【方法三】利用.ptr 和 * ++ 以及模操作

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce2(image1);

		t[2] += getTickCount() - tinit;

		//【方法四】 利用.ptr 和 * ++ 以及位操作

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce3(image1);

		t[3] += getTickCount() - tinit;

		//【方法五】 利用指针的算术运算

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce4(image1);

		t[4] += getTickCount() - tinit;

		//【方法六】利用 .ptr 和 * ++以及位运算、image.cols * image.channels()

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce5(image1);

		t[5] += getTickCount() - tinit;

		//【方法七】利用.ptr 和 * ++ 以及位运算(continuous)

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce6(image1);

		t[6] += getTickCount() - tinit;

		//【方法八】利用 .ptr 和 * ++ 以及位运算 (continuous+channels)

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce7(image1);

		t[7] += getTickCount() - tinit;

		//【方法九】 利用Mat_ iterator

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce8(image1);

		t[8] += getTickCount() - tinit;

		//【方法十】 利用Mat_ iterator以及位运算

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce9(image1);

		t[9] += getTickCount() - tinit;

		//【方法十一】利用Mat Iterator_

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce10(image1);

		t[10] += getTickCount() - tinit;

		//【方法十二】 利用动态地址计算配合at

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce11(image1);

		t[11] += getTickCount() - tinit;

		//【方法十三】 利用图像的输入与输出

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		Mat result;

		colorReduce12(image1, result);

		t[12] += getTickCount() - tinit;

		image2 = result;

		//【方法十四】 利用操作符重载

		image1 = imread("G:\\1.jpg");

		tinit = getTickCount();

		colorReduce13(image1);

		t[13] += getTickCount() - tinit;

		//------------------------------

	}

	//输出图像

	imshow("原始图像", image0);

	imshow("结果", image2);

	imshow("图像结果", image1);

	// 输出平均执行时间

	cout << endl << "-------------------------------------------" << endl << endl;

	cout << "\n【方法一】利用.ptr 和 []的方法所用时间为 " << 1000.*t[0] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法二】利用 .ptr 和 * ++ 的方法所用时间为" << 1000.*t[1] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法三】利用.ptr 和 * ++ 以及模操作的方法所用时间为" << 1000.*t[2] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法四】利用.ptr 和 * ++ 以及位操作的方法所用时间为" << 1000.*t[3] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法五】利用指针算术运算的方法所用时间为" << 1000.*t[4] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法六】利用 .ptr 和 * ++以及位运算、channels()的方法所用时间为" << 1000.*t[5] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法七】利用.ptr 和 * ++ 以及位运算(continuous)的方法所用时间为" << 1000.*t[6] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法八】利用 .ptr 和 * ++ 以及位运算 (continuous+channels)的方法所用时间为" << 1000.*t[7] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法九】利用Mat_ iterator 的方法所用时间为" << 1000.*t[8] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法十】利用Mat_ iterator以及位运算的方法所用时间为" << 1000.*t[9] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法十一】利用Mat Iterator_的方法所用时间为" << 1000.*t[10] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法十二】利用动态地址计算配合at 的方法所用时间为" << 1000.*t[11] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法十三】利用图像的输入与输出的方法所用时间为" << 1000.*t[12] / getTickFrequency() / n << "ms" << endl;

	cout << "\n【方法十四】利用操作符重载的方法所用时间为" << 1000.*t[13] / getTickFrequency() / n << "ms" << endl;

	waitKey();

	system("pause");

	return 0;

}

不稳定的fast

#include <iostream>

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

using namespace cv;

using namespace std;

void colorReduce13(Mat &image, int div = 64) {

	int n = static_cast<int>(log(static_cast<double>(div)) / log(2.0));

	uchar mask = 0xFF << n; 

	image = (image&Scalar(mask, mask, mask)) + Scalar(div / 2, div / 2, div / 2);

}

int main()

{

	Mat srcImage = imread("G:\\1.jpg");

	imshow("原始图像", srcImage);

	double time0 = static_cast<double>(getTickCount());

	colorReduce13(srcImage, 32);

	time0 = ((double)getTickCount() - time0) / getTickFrequency();

	cout << "\t此方法运行时间为： " << time0 << "秒" << endl;  //输出运行时间

	imshow("效果图", srcImage);

	waitKey(0);

}

巴特西

opencv 3 core组件进阶(1 访问图像中的像素）

访问图像像素的三类方法

用指针访问

用迭代器

动态地址计算

大神的14种方法

不稳定的fast

最新文章

热门文章