OpenCV进阶--图像像素操作处理

最新推荐文章于 2024-10-14 20:14:06 发布

茄子焦糖

最新推荐文章于 2024-10-14 20:14:06 发布

阅读量1.5k

点赞数 1

分类专栏： OpenCV学习笔记文章标签： opencv

本文链接：https://blog.csdn.net/qq_54922862/article/details/120377143

版权

OpenCV学习笔记专栏收录该内容

13 篇文章 3 订阅

订阅专栏

一、图像像素统计

1.1寻找图像像素最大值与最小值

OpenCV中提供了寻找像素最大值、最小值的函数minMaxLoc(),该函数的代码原型如下：

void cv::minMaxLoc(InputArray src,
                    double *minVal,
                    double *maxVal = 0,
                    Point *minLoc = 0,
                    Point *maxLoc = 0,
                    InputArray mask = noArray()
                    )

src：需要寻找最大值和最小值的图像或矩阵，要求必须是单通道矩阵。

minVal：图像或者矩阵的最小值。

maxVal：图像或者矩阵的最大值。

minLoc：图像或者矩阵中的最小值在矩阵中的坐标。

maxLoc：图像或者矩阵中的最大值在矩阵中的坐标。

mask：掩膜，用于设置在图像或矩阵中的指定区域寻找最值。

新的数据类型Point。该数据类型是用于表示图像的像素坐标，由于图像的像素坐标轴以左上角为坐标原点，水平方向为x轴，垂直方向为y轴。在OpenCV中对于二维坐标和三维坐标都设置了多种数据类型，针对二维坐标数据类型，定义了整数cv::Point2i(或者cv::Point）、double型坐标cv::Point2d,浮点型坐标cv::Point2f,对于三维坐标，同样定义了上述的数据类型，只需将其中的数字“2”变成“3”。

该函数实现的功能是寻找图像中特定区域内的最值，函数第一个参数是输入单通道矩阵。需要注意，该变量必须是一个单通道的矩阵数据，如果是多通道的矩阵数据，需要用cv::Mat::rehsape()将单通道变成多通道。

CV::Mat::reshape()函数原型：

Mat cv::Mat::reshape(int cn,
                     int rows = 0
                      )

cn：转换后矩阵的通道数。

rows：转换后矩阵的行数。如果参数为0，则转换后行数与转换前相同。

代码实例：

#include<opencv2/opencv.hpp>
#include<iostream>
#include<vector>

using namespace std;
using namespace cv;

int main()
{
	system("color F0");       //更改输出界面颜色
	float a[12] = { 1, 2, 3, 4, 5, 10, 6, 7, 8, 9, 10, 0 };
	Mat img = Mat(3, 4, CV_32FC1, a);        //单通道矩阵
	Mat imgs = Mat(2, 3, CV_32FC2, a);		//多通道矩阵
	double minVal, maxVal;      //用于存放矩阵中的最大值和最小值
	Point minIdx, maxIdx;         //用于存放矩阵中的最大值和最小值在矩阵中的位置


	/*寻找单通道矩阵中的最值*/
	minMaxLoc(img, &minVal, &maxVal, &minIdx, &maxIdx);
	cout << "img中最大值是：" << maxVal << " " << "在矩阵中的位置：" << maxIdx << endl;
	cout << "img中最小值是：" << minVal << " " << "在矩阵中的位置：" << minIdx << endl;

	/*寻找多通道矩阵中的最值*/
	Mat imgs_re = imgs.reshape(1, 4);
	minMaxLoc(imgs_re, &minVal, &maxVal, &minIdx, &maxIdx);
	

	cout << "imgs中最大值是：" << maxVal << " " << "在矩阵中的位置：" << maxIdx << endl;
	cout << "imgs中最小值是：" << minVal << " " << "在矩阵中的位置：" << minIdx << endl;



	return 0;
}

1.2计算图像的平均值和标准差

图像的平均值表示图像整体的亮度程度，图像的平均值越大，则图像整体越亮。标准差表示图像中明暗变化的对比程度，标准差越大，表示图像中明暗变化越明显。OpenCV中提供了mean()函数用于计算图像的平均值，提供了meanStdDev()函数用于同时计算图像的平均值和标准差。

mean()函数原型：

cv::Scalar cv::mean(InputArray src,
                    InputArray mask = noArray()
                    )

src：待求平均值的图像矩阵。

mask：掩膜，用于标记求取哪些区域的平局值。

数学原理：（本人不会使用公式编译器，拿着图片凑合一下吧）

meanStdDev()函数可以同时求取图像每个通道的平均值和标准差，其函数原原型如下：

void cv::meanStdDev(InputArray src,
                    OutputArray mean,
                    OutoutArray stddev,
                    InputArray mask = noArray()
                    )

src：待求平均值的图像矩阵。

mean：图像每个通道的平均值，参数为Mat类型变量。

stddev：图像每个通道的标准差，参数为Mat类型变量。

mask：掩膜，用于标记求取那些区域的平均值和标准差。

该函数的计算原理如下：

代码实例：

#include<opencv2/opencv.hpp>
#include<iostream>
#include<vector>

using namespace std;
using namespace cv;

int main()
{
	system("color F0");       //更改输出界面颜色
	float a[12] = { 1, 2, 3, 4, 5, 10, 6, 7, 8, 9, 10, 0 };
	Mat img = Mat(3, 4, CV_32FC1, a);        //单通道矩阵
	Mat imgs = Mat(2, 3, CV_32FC2, a);		//多通道矩阵
	
	cout << "/* 用mean求取图像的平均值 */" << endl;
	Scalar myMean;
	myMean = mean(imgs);
	cout << "imgs平均值=" << myMean << endl;
	cout << "imgs第一个通道的平均值=" << myMean[0] << "   "
			<< "imgs第二个通道的平均值=" << myMean[1] << endl << endl;


	cout << "/* 用meanSTDDev同时求取图像的平均值和标准差 */" << endl;
	Mat myMeanMat, myStddevMat;
	meanStdDev(img, myMeanMat, myStddevMat);
	cout << "img平均值=" << myMeanMat << endl;
	cout << "img标准差=" << myStddevMat << endl << endl;
	meanStdDev(imgs, myMeanMat, myStddevMat);
	cout << "imgs平均值=" << myMeanMat << endl;
	cout << "imgs标准差=" << myStddevMat << endl << endl;
	return 0;
}

二、两图像间的像素操作

2.1两幅图像的比较运算

在OpenCV中提供了求取两幅图像每一个像素较大或者较小灰度值的max()、min()函数，这两个函数分别比较两幅图像中没每一个元素灰度值的大小，保留较大（较小）的灰度值。函数原型如下：

void cv::max(InputArray src1,
             InputArray src2,
             OutputArray dst
            )
void cv::min(InputArray src1,
             InputArray src2,
             OutputArray dst
            )

src1：第一个图像矩阵，可以是任意通道数的矩阵。

src2：第二个图像矩阵，尺寸和通道数以及数据类型都需要与src1一致。

dst：保留对应位置较大（较小）灰度值后的图像矩阵，尺寸、通道数和数据类型与src1一致。

实例代码：

#include<opencv2/opencv.hpp>
#include<iostream>
#include<vector>

using namespace std;
using namespace cv;

int main()
{
	float a[12] = { 1, 2, 3.3, 4, 5, 9, 5, 7, 8.2, 9, 10, 2 };
	float b[12] = { 1, 2.2, 3, 1, 3, 10, 6, 7, 8, 9.3, 10, 1 };
	Mat imga = Mat(3, 4, CV_32FC1, a);
	Mat imgb = Mat(3, 4, CV_32FC1, b);
	Mat imgas = Mat(2, 3, CV_32FC1, a);
	Mat imgbs = Mat(2, 3, CV_32FC1, b);

	//对两个单通道矩阵进行比较
	Mat myMax, myMin;
	max(imga, imgb, myMax);
	min(imgb, imgb, myMin);

	//对两个多通道矩阵进行比较
	Mat myMaxs, myMins;
	max(imgas, imgas, myMaxs);
	max(imgas, imgbs, myMaxs);

	//对两幅彩色图像进行比较运算
	Mat img0 = imread("img1.png");
	Mat img1 = imread("img2.png");
	if (img0.empty() || img1.empty())
	{
		cout << "请确认图像文件名称是否正确" << endl;
		return -1;
	}
	/*img0.resize(200, 300);
	img1.resize(200, 300);*/
	Mat comMin, comMax;
	max(img0, img1, comMax);
	min(img0, img1, comMin);
	imshow("comMin", comMin);
	imshow("comMax", comMax);


	//对两幅灰度图像进行比较运算
	Mat img0G, img1G, comMinG, comMaxG;
	cvtColor(img0, img0G, COLOR_BGR2GRAY);
	cvtColor(img1, img1G, COLOR_BGR2GRAY);
	max(img0G, img1G, comMaxG);
	min(img0G, img1G, comMaxG);
	imshow("comMinG", comMinG);
	imshow("comMaxG", comMaxG);
	waitKey(0);
	return 0;
}

2.2两幅图像的逻辑运算

OpenCV中针对两个图像之间的“与”“或”异或”以及“非”运算分别提供了bitwise_and(), bitwise_or(), bitwise_xor(), bitwise_not()函数。

图像逻辑运算规则
图像数据类型	像素值1	像素值2	与	或	异或	非（像素1）
二值	0	0	0	0	0	1
二值	1	0	0	1	1	0
二值	0	1	0	1	1	1
二值	1	1	1	1	0	0
8位	0	0	0	0	0	255
8位	5	6	4	7	3	250

图像逻辑运算的规则。图像间的逻辑运算与数字间的运算相同。像素的“非”运算只能针对一个数值进行，因此在上图中对像素求非运算时对图像1的像素值进行“非”运算。若果像素取值只有0和1，那么上图的前四行数据正好对应了所有的运算规则，但是CV_8U类型的图像像素值是从0到255，此时逻辑运算就需要将像素值转成二进制后再进行，以为CV_8U类型是8位数据，对0求非是11111111，也就是255。

函数原型：

//与
void cv::bitwise_and(InputArray src1,
                     InputArray src2,
                     OutputArray dst,
                     InputArray mask = noArray()
                     )

//或
void cv::bitwise_or(InputArray src1,
                     InputArray src2,
                     OutputArray dst,
                     InputArray mask = noArray()
                     )

//异或
void cv::bitwise_xor(InputArray src1,
                     InputArray src2,
                     OutputArray dst,
                     InputArray mask = noArray()
                     )

//非
void cv::bitwise_xor(InputArray src1,
                     InputArray src2,
                     OutputArray dst,
                     InputArray mask = noArray()
                     )

src1：第一个图像矩阵，可以是多通道矩阵图像数据。

src2：第二个图像矩阵，尺寸、通道数和数据类型都需要与src1一致。

dst：逻辑运算输出结果，尺寸、通道数和数据类型都与src1一致。

mask：掩膜，用于设置图像过矩阵中逻辑运算的范围。

代码实例：

#include<opencv2/opencv.hpp>
#include<iostream>
#include<vector>

using namespace std;
using namespace cv;

int main()
{
	Mat img = imread("img.png");
	if (img.empty())
	{
		cout << "请确认图像文件名称是否正确" << endl;
		return -1;
	}

	//创建两个黑白图像
	Mat img0 = Mat::zeros(200, 200, CV_8UC1);
	Mat img1 = Mat::zeros(200, 200, CV_8UC1);
	Rect rect0(50, 50, 100, 100);
	img0(rect0) = Scalar(255);
	Rect rect1(100, 100, 100, 100);
	img1(rect1) = Scalar(255);
	imshow("img0", img0);
	imshow("img1", img1);

	//进行逻辑运算
	Mat myAnd, myOr, myXor, myNot, imgNot;
	bitwise_not(img0, myNot);
	bitwise_and(img0, img1, myAnd);
	bitwise_or(img0, img1, myOr);
	bitwise_xor(img0, img1, myXor);
	bitwise_not(img, imgNot);
	imshow("myAnd", myAnd);
	imshow("myOr", myOr);
	imshow("myXor", myXor);
	imshow("myNot", myNot);
	imshow("imgNot", imgNot);
	waitKey(0);
	return 0;
}