Opencv4基于C++基础入门笔记:图像 颜色 事件响应 图形 视频 直方图

 效果图◕‿◕:opencv人脸识别效果图(请叫我真爱粉)✌✌✌先看一下效果图勾起你的兴趣! 

文章目录:

一:环境配置搭建

二:图像

1.图像读取与显示

main.cpp 

运行结果

2.图像色彩空间转换

2.1 换色彩 

test.h 

test.cpp

main.cpp  

 运行结果

2.2 照片换背景

test.h       

test.cpp       

main.cpp       

运行结果       

3.图像对象的创建Mat

test.h

test.cpp 

main.cpp

运行结果

4.图像像素 

4.1 图像像素的读写

test.h       

test.cpp   

main.cpp     

运行结果

4.2 图像像素的算术操作

test.h       

test.cpp       

main.cpp       

运行结果       

4.3 图像像素的逻辑操作(或 与 非 异或)

test.h       

test.cpp       

main.cpp       

运行结果       

4.4 图像像素值统计

test.h

test.cpp       

main.cpp       

运行结果       

4.5 图像像素类型的转换与归一化

test.h       

test.cpp       

main.cpp       

运行结果       

5.图像通道分离与合并与混合

test.h       

test.cpp       

main.cpp       

运行结果       

6.图像的放缩与差值

test.h       

test.cpp       

main.cpp       

运行结果       

7.图像的旋转

7.1 定义好的角度

test.h       

test.cpp       

main.cpp       

运行结果

7.2 自定义角度

原理 

test.h       

test.cpp       

main.cpp       

运行结果       

8.图像模糊

8.1 图像卷积操作

test.h

test.cpp       

main.cpp       

运行结果       

8.2 高斯模糊

test.h

test.cpp       

main.cpp       

运行结果       

8.3 高斯双边模糊

test.h

test.cpp       

main.cpp       

运行结果       

三:颜色

1.颜色表操作

test.h       

test.cpp       

main.cpp       

运行结果       

2.随机数与随机颜色

test.h       

test.cpp       

main.cpp       

运行结果       

四:事件响应 

1.滚动条 

1.1 滚动条调整图像亮度

test.h       

test.cpp       

main.cpp       

运行结果   

1.2 滚动条参数传递(亮度和对比度)

test.h       

test.cpp       

main.cpp       

运行结果       

2.键盘响应

test.h       

test.cpp       

main.cpp       

运行结果       

3.鼠标响应

test.h       

test.cpp       

main.cpp       

运行结果       

五:图形

1.图像几何形状绘制

test.h       

test.cpp       

main.cpp       

运行结果       

2.多边形填充与绘制

test.h       

test.cpp       

main.cpp       

运行结果       

六:视频

1.视频文件摄像头使用

test.h       

test.cpp       

main.cpp       

运行结果       

2.视频处理与保存

test.h       

test.cpp       

main.cpp       

运行结果       

七:直方图

1.图像的直方图

test.h       

test.cpp       

main.cpp       

运行结果       

2.二维2D直方图

test.h       

test.cpp       

main.cpp       

运行结果       

3.直方图的均衡化

test.h       

test.cpp       

main.cpp       

运行结果       

Opencv4基于C++的 实时人脸检测


来源: OpenCV4 C++ 快速入门视频30讲 - 系列合集 10小时        资源-sorce-cpp

评价

讲的如何?
    老师讲的很好,有干货!看这门课最好有点点基础,没有基础细心的花点时间仔细学也是可以看懂的!


启示?
    作为入门课程,的确可以打开我们一些眼界,有点新鲜有点意思!


我的笔记:(含注解,知识点分类)
    我是怎么学的?我是零基础,基本上先看代码,自己一行一行的看,不懂的看老师怎么讲,再百度
    看那个?看笔记看test.cpp就可以了,里面都是正在的封装功能函数
    每个知识点可以干什么?我都运行出来了,可以更加直观的看效果    

学多久?
    别看这个课时10来个小时,但是下载软件配置环境,理解代码敲代码我花了2.5天,如果你们不敲代码可能就会快很多的!        

我的代码:点我查看 

学习路线 

入门:OpenCV图象读写、视频读写、基本像素处理、色彩空间转化

初级:OpenCV图象卷积处理、二值图象分析、形态学处理、视频分析

中级:OpenCV图象特征提取与应用、深度神经网络,机器学习

高级:Pytorch深度学习、OpenVINO开发、torchvision对象检测框架
      tensorflow对象检测框架、模型从设计、训练、部署

一:环境配置搭建

OpenCV4基于C++基础入门笔记:OpenCV环境配置搭建

进入“资源属性管理器如”何返回“解决方案资源管理器”?
    点击窗口——>重置窗口布局——>是



注    释: CTRL+K+C 
取消注释: CTRL+K+U

二:图像

1.图像读取与显示

main.cpp 

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow



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

using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_GRAYSCALE);	    //第二个参数代表显示一张灰度图像
	
	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");	
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 
	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果

2.图像色彩空间转换

2.1 换色彩 

test.h 

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge); 
};

test.cpp

这里需要包含工程的目录:点击工程名TestOpenCV右键属性——>VC++目录——>包含目录F:\VC2015\TestOpenCV\TestOpenCV

#include<test.h>

//色彩转换
void QuickDemo::colorSpace_Demo(Mat & image)
{
	Mat a, b;								//定义2个矩阵类的图像a和b,
	cvtColor(image, b, COLOR_BGR2HSV);		//图像转换函数,可以把image转成b,第三个参数是转成的类型	COLOR_BGR2HSV  = 40BGR到HSV
	cvtColor(image, a, COLOR_BGR2GRAY);		//图像转换函数,可以把image转成a,第三个参数是转成的类型	COLOR_BGR2GRAY = 6彩色到灰度

	imshow("HSV", b);
	imshow("灰度", a);

	//保存图片,前面是保存图的地址,后面是保存图的名称
	imwrite("F:/images/hsv.jpg", b);					
	imwrite("F:/images/gray.jpg", a);
}

main.cpp  

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度       黑色轮廓线条(细致)
		//COLOR_GRAY2BGR = 8灰度到彩色    
		//COLOR_BGR2HSV  = 40BGR到HSV        黑白抠图 
		//COLOR_HSV2BGR  = 54HSV到BGR        黑色轮廓线条(粗略)
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 



	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		  qd.colorSpace_Demo(src);



	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

 运行结果

2.2 照片换背景

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像色彩空间转换
	//RGB色彩空间
	//HSV色彩空间
	//YUV色彩空间
	//YCrCb色彩空间
	
	//色彩空间转换:cvtColor(输入图像,输出图像,转换的颜色空间类型)
	//提取指定色彩范围区域:inRange(输入图像,最小值,最大值,提取指定范围的像素)

void QuickDemo::inrange_demo(Mat &image)							//可以替换照片背景,可以从ps相关来理解
{
	Mat hsv;
	cvtColor(image, hsv, COLOR_BGR2HSV);							//色彩空间转换

	Mat mask;
	//自己的照片背景颜色【去除】
		//inRange(hsv, Scalar(35, 43, 46), Scalar(77, 255, 255), mask);	//绿色
		inRange(hsv, Scalar(100, 43, 46), Scalar(124, 255, 255), mask);	//绿色
	imshow("mask", hsv);			//原图

	Mat redback = Mat::zeros(image.size(), image.type());
	
	//需要替换的背景颜色【替换】
		//redback = Scalar(40, 40, 200);	//红色
		redback = Scalar(230, 20, 20);		//蓝色

	bitwise_not(mask, mask);		//取反 黑白版图(根据颜色去背景):去掉背景色(无颜色)+抠出人物(人物颜色不一样)
	imshow("mask", mask);	

	image.copyTo(redback, mask);	//蒙版之后的图:换背景=背景颜色+人物图实图								
	imshow("roi区域提取", redback);	
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		qd.inrange_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

3.图像对象的创建Mat

test.h

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
};

test.cpp 

#include<test.h>

//图像对象的创建
void QuickDemo::mat_creation_demo(Mat &image)
{
	Mat m1, m2;
	m1 = image.clone();
	image.copyTo(m2);		//复制

	//创建空白图像		ones&zeros是初始化的方法
	Mat m3 = Mat::ones(Size(400,400), CV_8UC3);	//创建400*400;的CV8位的;无符号uU=nsigned char;通道为n=3数据的宽度和长度是由通道数决定的
	m3 = Scalar(255, 0, 0);//改变m3的颜色为蓝色

	//用来查看宽度,高度与通道数
	/*std::cout << "width:"<<m3.cols<<"height"<< m3.rows <<"channels"<<m3.channels()<< std::endl;
	std::cout << m3 << std::endl;*/


	Mat m4 = m3.clone();	 //克隆
	//m3.copyTo(m4);		 //把M3赋值给M4,M4就是蓝色
	m4 = Scalar(0, 255, 255);//改变m4的颜色为黄色

	//这里还有其他的
		//Mat m3 = m4;		//赋值
		//Mat kernel = (Mat_<char>(3,3) << 0, -1, 0,-1,5,-1,0,-1,-1 );


	imshow("图像3", m3);	//标题和图像名称   显示图像m3 纯蓝色
	imshow("图像4", m4);	//标题和图像名称
}

main.cpp

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 



	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		qd.mat_creation_demo(src);



	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果

4.图像像素 

4.1 图像像素的读写

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
};

test.cpp   

#include<test.h>


//图像像素的读写	第一种是数组访问模式
void QuickDemo::pixel_visit_demo1(Mat &image)
{
	int dims = image.channels();
	int h = image.rows;
	int w = image.cols;
	for (int row = 0; row < h; row++)
	{
		for (int col = 0; col < w; col++)
		{
			if (dims == 1) //单通道的灰度图像
			{
				int pv = image.at<uchar>(row, col);  //得到像素值
				image.at<uchar>(row, col) = 255 - pv;//给像素值重新赋值

			}
			if (dims == 3) //三通道的彩色图像
			{
				Vec3b bgr = image.at<Vec3b>(row, col);		//opencv特定的类型,获取三维颜色,3个值
				image.at<Vec3b>(row, col)[0] = 255 - bgr[0];
				image.at<Vec3b>(row, col)[1] = 255 - bgr[1];
				image.at<Vec3b>(row, col)[2] = 255 - bgr[2];//对彩色图像读取它的像素值,并且对像素值进行改写。
			}
		}
	}
	namedWindow("像素读写演示", WINDOW_FREERATIO);
	imshow("像素读写演示", image);
}

//图像像素的读写	第二种为指针访问模式
void QuickDemo::pixel_visit_demo2(Mat &image)
{
	int dims = image.channels();
	int h = image.rows;
	int w = image.cols;
	for (int row = 0; row < h; row++)
	{
		uchar *current_row = image.ptr<uchar>(row);

		for (int col = 0; col < w; col++)
		{
			if (dims == 1) //单通道的灰度图像
			{
				int pv = *current_row;	   //得到像素值
				*current_row++ = 255 - pv; //给像素值重新赋值

			}
			if (dims == 3) //三通道的彩色图像
			{
				*current_row++ = 255 - *current_row; //指针每做一次运算,就向后移动一位
				*current_row++ = 255 - *current_row;
				*current_row++ = 255 - *current_row;
			}
		}
	}
	namedWindow("像素读写演示", WINDOW_FREERATIO);
	imshow("像素读写演示", image);

}

main.cpp     

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		qd.pixel_visit_demo2(src);	//指针



	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果

4.2 图像像素的算术操作

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像像素的算术操作
void QuickDemo::operators_demo(Mat &image)
{
	Mat dst = Mat::zeros(image.size(), image.type());
	Mat m   = Mat::zeros(image.size(), image.type());
	dst = image - Scalar(50, 50, 50);	//素点减50
	m = Scalar(50, 50, 50);

	//下面是内部的函数调用
	add(image, m, dst);				//加法操作 api
	imshow("加法操作", dst);
	namedWindow("加法操作", WINDOW_FREERATIO);

	//subtract(image, m, dst);		//减法操作 api
	//imshow("减法操作", dst);

	//multiply(image, m, dst);		//乘法操作 api
	//imshow("乘法操作", dst);

	//divide(image, m, dst);		//除法操作 api
	//imshow("除法操作", dst);


//	//加法操作底层
//	int dims = image.channels();
//	int h = image.rows;
//	int w = image.cols;
//	for (int row = 0; row < h; row++)
//	{
//		for (int col = 0; col < w; col++)
//		{
//			Vec3b p1 = image.at<Vec3b>(row, col); //opencv特定的类型,获取三维颜色,3个值
//			Vec3b p2 = m.at<Vec3b>(row, col);
//			dst.at<Vec3b>(row, col)[0] = saturate_cast<uchar>(p1[0] + p2[0]);	//saturate_cast用来防爆,小于0就是0,大于255就是255
//			dst.at<Vec3b>(row, col)[1] = saturate_cast<uchar>(p1[1] + p2[1]);
//			dst.at<Vec3b>(row, col)[2] = saturate_cast<uchar>(p1[2] + p2[2]);	//对彩色图像读取它的像素值,并且对像素值进行改写。
//		}
//	}
//	imshow("加法操作", dst);
//
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		qd.operators_demo(src);



	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

 

4.3 图像像素的逻辑操作(或 与 非 异或)

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像像素的逻辑操作
void QuickDemo::bitwise_demo(Mat &image)
{
	Mat m1 = Mat::zeros(Size(256, 256), CV_8UC3);
	Mat m2 = Mat::zeros(Size(256, 256), CV_8UC3);

	//图像,形状大小位置,颜色,线宽(>0表示绘制 <0表示填充),线条样式,逆时针方向
	//颜色B G R
	rectangle(m1, Rect(100, 100, 80, 80), Scalar(255, 255, 0), -1, LINE_8, 0);
	rectangle(m2, Rect(150, 150, 80, 80), Scalar(0, 255, 255), -1, LINE_8, 0);
	imshow("m1", m1);
	imshow("m2", m2);

	Mat dst;
	bitwise_and(m1, m2, dst);	//位操作与
	bitwise_or(m1, m2, dst);	//位操作或
	bitwise_not(image, dst);	//取反操作
	bitwise_xor(m1, m2, dst);	//异或操作
	imshow("像素位操作", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		qd.bitwise_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}


运行结果       

 

4.4 图像像素值统计

test.h

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像像素值统计
	//最小(min)
	//最大(max)
	//均值(mean)
	//标准方差(standard deviation)
	//最大最小值minMaxLoc
	//计算均值与标准方差meanStdDev

void QuickDemo::pixel_statistic_demo(Mat &image)
{
	double minv, maxv;			//定义最值
	Point minLoc, maxLoc;		//定义最值地址

	std::vector<Mat>mv;			//mv是一个Mat类型的容器 装在这个容器内
	split(image, mv);
	for (int i = 0; i < mv.size(); i++)
	{
		//求出图像的最大值和最小值
		minMaxLoc(mv[i], &minv, &maxv, &minLoc, &maxLoc, Mat());	
		std::cout << "通道:" << i << "最小值:" << minv << "最大值:" << maxv << std::endl;
	}

	Mat mean, stddev;
		//求出图像的均值和方差
		Mat redback = Mat::zeros(image.size(), image.type());
	/*	redback = Scalar(40, 40, 200);
		meanStdDev(redback, mean, stddev);
		imshow("redback", redback);*/

		meanStdDev(image, mean, stddev);	
		std::cout << "均值:" << mean << std::endl;
		std::cout << "方差:" << stddev << std::endl;
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		qd.pixel_statistic_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

4.5 图像像素类型的转换与归一化

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像像素类型的转换与归一化
	//将图像或图像中的某个区域(如ROI)的像素值范围缩放到0到1之间,或者根据需要缩放到指定的范围
	//这是一种常用的图像预处理步骤,可以用于图像的对比度拉伸、色彩均衡、直方图均衡化等操作

	//归一化类型有四种,分别是NORM_L2、NORM_L1、NORM_INF、NORM_MINMAX12
	//	NORM_L2:默认值。计算L2范数,使用欧几里得距离
	//	NORM_L1:计算L1范数,即绝对值之和
	//	NORM_INF:计算最大元素的绝对值
	//	NORM_MINMAX:将像素值缩放到[0, 1]的范围内
void QuickDemo::norm_demo(Mat &image)
{
	Mat dst;
	//打印出来图片的类型
	std::cout << image.type() << std::endl;	

	//将dst数据转换成浮点型float32位数据
	image.convertTo(image, CV_32F);
	std::cout << image.type() << std::endl;

	//图像进行归一化操作:输入图像,输出图像,缩放因子-通常取值为1.0,偏移量-通常取值为0.0,归一化的类型
	normalize(image, dst, 1.0,0.0, NORM_MINMAX);
	std::cout << dst.type() << std::endl;

	imshow("图像的归一化", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		qd.norm_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

5.图像通道分离与合并与混合

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);

};

test.cpp       

#include<test.h>


//通道的分离与合并
void QuickDemo::channels_demo(Mat &image)
{
	//容器
	std::vector<Mat>mv;
	//1.通道分离
	split(image, mv);
	//0,1,2三个通道分别代表BGR
		//imshow("蓝色", mv[0]);
		//imshow("绿色", mv[1]);
		//imshow("红色", mv[2]);

	Mat dst;
	//选择一个通道打开,其他关闭
		mv[0] = 0;
		mv[2] = 0;
	//2.通道合并
	merge(mv, dst);
	imshow("蓝色", dst);

	//3.通道混合
	int from_to[] = { 0,2,1,1,2,0 };				//两两依次一组
	mixChannels(&image, 1, &dst, 1, from_to, 3);	//3表示3个通道
	imshow("通道混合", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		qd.channels_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}


运行结果       

6.图像的放缩与差值

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像的放缩与差值
void QuickDemo::resize_demo(Mat &image)
{
	Mat zoomin, zoomout;

	int h = image.rows;
	int w = image.cols;

	//调整大小的图像,是否需要缩小图像,新的图像大小,在缩小图像时要在哪个位置开始采样,在缩小图像时要在哪个位置开始采样,插值方法
	//resize(image, zoomin, Size(w/2, h/2), 0, 0, INTER_LINEAR);
	//imshow("zoomin", zoomin);

	resize(image, zoomout, Size(w*3 , h*3), 0, 0, INTER_LINEAR);
	imshow("zoomin", zoomout);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		qd.resize_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

 

7.图像的旋转

7.1 定义好的角度

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像的旋转:定义好的
void QuickDemo::flip_demo(Mat &image)
{
	Mat dst;
	flip(image, dst, 0);//上下翻转 x对称

	flip(image, dst, 1);//左右翻转 y对称

	flip(image, dst, -1);//旋转180°

	imshow("图像翻转", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		qd.flip_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果

7.2 自定义角度

原理 

旋转矩阵的第三个元素是0,这是因为在2D平面中进行旋转时,图像在Z轴上的位置没有变化 

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像的旋转:自定义
void QuickDemo::rotate_demo(Mat &image)
{
	Mat dst, M;			//用于存储旋转后的图像和旋转矩阵
	int h = image.rows;	//定义输入图片的高度
	int w = image.cols;	//定义输入图片的宽度

	//旋转矩阵
		//2D旋转的变换矩阵:图像的中心点,旋转的角度(单位是度),旋转的缩放因子(1.0表示不进行缩放)
		M = getRotationMatrix2D(Point(w / 2, h / 2), 45, 1.0);

		//矩阵旋转获取角度	旋转矩阵是一个2x3的矩阵
		//旋转矩阵的第三个元素是0,这是因为在2D平面中进行旋转时,图像在Z轴上的位置没有变化
		//[cos(angle)   sin(angle)  0]
		//[-sin(angle)  cos(angle)  0]
			// 获取旋转矩阵的第一行第一列元素的绝对值,即cos(45度)
			double cos = abs(M.at<double>(0, 0));	
			// 获取旋转矩阵的第一行第二列元素的绝对值,即sin(45度)
			double sin = abs(M.at<double>(0, 1));

		//这里怎么算的:我放了张图
			// 根据旋转矩阵的元素计算旋转后的图像的宽度,等于cos(45度)*原宽度+sin(45度)*原高度
			int nw = cos * w + sin * h;
			// 根据旋转矩阵的元素计算旋转后的图像的高度,等于sin(45度)*原宽度+cos(45度)*原高度
			int nh = sin * w + cos * h;

	// 将旋转矩阵的第三列的第一项加上(旋转后的图像宽度的一半减去原图像宽度的一半),以调整旋转后的图像的中心位置
	M.at<double>(0, 2) += (nw / 2 - w / 2);
	// 将旋转矩阵的第三列的第二项加上(旋转后的图像高度的一半减去原图像高度的一半),以调整旋转后的图像的中心位置
	M.at<double>(1, 2) += (nh / 2 - h / 2);

	//图像进行放射变换:输入图像,输出图像,仿射变换矩阵(决定了图像的变换方式),输出图像的大小,双线性插值法,无填充(0表示无颜色合成),填充颜色
	warpAffine(image, dst, M, Size(nw, nh), INTER_LINEAR, 0, Scalar(255, 255, 0));

	imshow("旋转演示", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		qd.rotate_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

8.图像模糊

blur图像模糊、GaussianBlur高斯模糊和bilateralFilter的高斯双边模糊区别:
	blur				图像模糊:即普通的模糊,对图像进行相同像素之间的融合,得到整个图像都模糊的效果
	GaussianBlur		高斯模糊:图像整体都变模糊,边缘信息丢失严重
	bilateralFilter 高斯双边模糊:图像边缘清晰,中间部分有一定程度的模糊,边缘信息得以保留

8.1 图像卷积操作

test.h

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

		//图像直方图
		void QuickDemo::histogram_demo(Mat &image);

		//二维直方图
		void QuickDemo::histogram_2d_demo(Mat &image);

		//直方图的均衡化
		void QuickDemo::histogram_eq_demo(Mat &image);

		//图像卷积操作
		void QuickDemo::blur_demo(Mat &image);


};

test.cpp       

#include<test.h>


//图像卷积操作
void QuickDemo::blur_demo(Mat &image) {
	Mat dst;

	//原始图像,卷积之后的图像,卷积的矩阵大小,卷积的起始点
	blur(image, dst, Size(15, 15), Point(-1, -1));

	imshow("图像卷积操作 图像模糊", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		//qd.video_demo2(src);

		//图像直方图
		//qd.histogram_demo(src);

		//二维直方图
		//qd.histogram_2d_demo(src);

		//直方图的均衡化
		//qd.histogram_eq_demo(src);

		//图像卷积操作
		qd.blur_demo(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

8.2 高斯模糊

test.h

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

		//图像直方图
		void QuickDemo::histogram_demo(Mat &image);

		//二维直方图
		void QuickDemo::histogram_2d_demo(Mat &image);

		//直方图的均衡化
		void QuickDemo::histogram_eq_demo(Mat &image);

		//图像卷积操作
		void QuickDemo::blur_demo(Mat &image);

		//高斯模糊
		void QuickDemo::gaussian_blur_demo(Mat &image);

};

test.cpp       

#include<test.h>


//高斯模糊
void QuickDemo::gaussian_blur_demo(Mat &image) {
	Mat dst;

	//初始图像,处理后的图像,高斯矩阵大小,sigmaX在X方向上的标准偏差-控制了模糊的程度和模糊的方向
		//较大的sigmaX值会导致更宽的模糊效果,而较小的值则会产生更锐利的模糊效果
	GaussianBlur(image, dst, Size(0, 0), 15);

	imshow("高斯模糊", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		//qd.video_demo2(src);

		//图像直方图
		//qd.histogram_demo(src);

		//二维直方图
		//qd.histogram_2d_demo(src);

		//直方图的均衡化
		//qd.histogram_eq_demo(src);

		//图像卷积操作
		//qd.blur_demo(src);

		//高斯模糊
		qd.gaussian_blur_demo(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

8.3 高斯双边模糊

test.h

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

		//图像直方图
		void QuickDemo::histogram_demo(Mat &image);

		//二维直方图
		void QuickDemo::histogram_2d_demo(Mat &image);

		//直方图的均衡化
		void QuickDemo::histogram_eq_demo(Mat &image);

		//图像卷积操作
		void QuickDemo::blur_demo(Mat &image);

		//高斯模糊
		void QuickDemo::gaussian_blur_demo(Mat &image);

		//高斯双边模糊
		void QuickDemo::bifilter_demo(Mat &image);

};

test.cpp       

#include<test.h>


//高斯双边模糊
void QuickDemo::bifilter_demo(Mat &image) {
	Mat dst;

	//输入图像,输出图像,滤波过程中像素之间的距离,颜色空间中的标准偏差,像素空间中的标准偏差
	bilateralFilter(image, dst, 0, 100, 10);

	imshow("高斯双边模糊", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		//qd.video_demo2(src);

		//图像直方图
		//qd.histogram_demo(src);

		//二维直方图
		//qd.histogram_2d_demo(src);

		//直方图的均衡化
		//qd.histogram_eq_demo(src);

		//图像卷积操作
		//qd.blur_demo(src);

		//高斯模糊
		//qd.gaussian_blur_demo(src);

		//高斯双边模糊
		qd.bifilter_demo(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

三:颜色

1.颜色表操作

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);

};

test.cpp       

#include<test.h>


//opencv自带颜色操作
void QuickDemo::color_style_demo(Mat &image)
{
	//各种色彩
	int colormap[] = {
		COLORMAP_AUTUMN ,
		COLORMAP_BONE,
		COLORMAP_CIVIDIS,
		COLORMAP_DEEPGREEN,
		COLORMAP_HOT,
		COLORMAP_HSV,
		COLORMAP_INFERNO,
		COLORMAP_JET,
		COLORMAP_MAGMA,
		COLORMAP_OCEAN,
		COLORMAP_PINK,
		COLORMAP_PARULA,
		COLORMAP_RAINBOW,
		COLORMAP_SPRING,
		COLORMAP_TWILIGHT,
		COLORMAP_TURBO,
		COLORMAP_TWILIGHT,
		COLORMAP_VIRIDIS,
		COLORMAP_TWILIGHT_SHIFTED,
		COLORMAP_WINTER
	};

	Mat dst;
	int index = 0;
	while (true)
	{
		char c = waitKey(100);		//停顿100ms 做视频处理都是1
		if (c == 27) {			    //esc 退出应用程序
			break;
		}
		if (c == 49)				//key#1 按下按键1时,保存图片到指定位置
		{
			std::cout << "你按下了 #1" << std::endl;
			imwrite("F:/images/gray.jpg", dst);
		}
		applyColorMap(image, dst, colormap[index % 19]);	//循环展示19种图片	(输入图像,输出图像,匹配颜色)
		index++;
		imshow("循环播放", dst);
	}
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		qd.color_style_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}


运行结果       

颜色不停自动变换 

 

2.随机数与随机颜色

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

};

test.cpp       

#include<test.h>


//随机数与随机颜色
void QuickDemo::random_drawing()
{
	Mat canvas = Mat::zeros(Size(512, 512), CV_8UC3);
	int w = canvas.cols;
	int h = canvas.rows;

	//初始化
	RNG rng(2);

	while (true)
	{
		int c = waitKey(10);
		if (c == 27)
		{
			break;
		}
		//rng.uniform(low, high)将生成一个在范围[low, high)内的均匀分布的随机数
		int x1 = rng.uniform(0, canvas.cols);
		int y1 = rng.uniform(0, h);
		int x2 = rng.uniform(0, canvas.cols);
		int y2 = rng.uniform(0, h);

		int b = rng.uniform(0, 255);
		int g = rng.uniform(0, 255);
		int r = rng.uniform(0, 255);

		canvas = Scalar(0, 0, 0);

		line(canvas, Point(x1, y1), Point(x2, y2), Scalar(b, g, r), 8, LINE_AA, 0);	
		imshow("随机绘制演示", canvas);
	}
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		qd.random_drawing();


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

不停移动变换颜色 

四:事件响应 

1.滚动条 

1.1 滚动条调整图像亮度

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo(Mat &image);
};

test.cpp       

#include<test.h>


//滚动条调整图像亮度
Mat  src, dst, m;
int lightness = 50;								//定义初始的亮度为50
static void on_track(int, void*)
{
	m = Scalar(lightness, lightness, lightness);//创建调整亮度的数值
	subtract(src, m, dst);						//定义亮度变化为——减
	imshow("亮度调整", dst);					//显示调整亮度之后的图片
}
void QuickDemo::tracking_bar_demo(Mat &image)
{
	namedWindow("亮度调整", WINDOW_AUTOSIZE);
	dst = Mat::zeros(image.size(), image.type());//图片的初始化创建一个和image大小相等,种类相同的图像
	  m = Mat::zeros(image.size(), image.type());//图片的初始化创建一个和image大小相等,种类相同的图像
	src = image;								 //给src赋值
	int max_value = 100;						 //定义最大值为100
	createTrackbar("Value Bar:", "亮度调整", &lightness, max_value, on_track);//调用函数实现功能。
	on_track(50, 0);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		qd.tracking_bar_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}


运行结果   

 

1.2 滚动条参数传递(亮度和对比度)

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);


};

test.cpp       

#include<test.h>


//滚动条参数传递(亮度和对比度)
static void on_lightness(int b, void* userdata)//亮度 目标图像
{
	Mat image = *((Mat*)userdata);
	Mat dst = Mat::zeros(image.size(), image.type());
	Mat m = Mat::zeros(image.size(), image.type());

	m = Scalar(b, b, b);

	//第一个图像 第一个图像的权重 第二个图像 第二个图像的权重 加到权重总和上的标量值 目标图像
	addWeighted(image, 1.0, m, 0, b, dst);		//融合两张图
	imshow("亮度&对比度调整", dst);
}
static void on_contrast(int b, void* userdata)  //对比度 目标图像
{
	Mat image = *((Mat*)userdata);
	Mat dst = Mat::zeros(image.size(), image.type());
	Mat m = Mat::zeros(image.size(), image.type());

	double contrast = b / 100.0;

	addWeighted(image, contrast, m, 0.0, 0, dst);//融合两张图
	imshow("亮度&对比度调整", dst);
}
void QuickDemo::tracking_bar_demo2(Mat &image)
{
	namedWindow("亮度&对比度调整", WINDOW_AUTOSIZE);

	int lightness = 50;
	int max_value = 100;
	int contrast_value = 100;

	//				 取名			窗口名			滑块初始值  滚动的最大值 接收回调函数  用户传给回调函数的数据
	createTrackbar("Value Bar:", "亮度&对比度调整", &lightness, max_value, on_lightness, (void*)(&image));
	createTrackbar("Contrast Bar:", "亮度&对比度调整", &contrast_value, 200, on_contrast, (void*)(&image));
	on_lightness(50, &image);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		qd.tracking_bar_demo2(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}


运行结果       

2.键盘响应

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);

};

test.cpp       

#include<test.h>


//键盘响应
void QuickDemo::key_demo(Mat &image)	//先要鼠标点击图片再按键盘
{
	Mat dst = Mat::zeros(image.size(), image.type());
	while (true)
	{
		char c = waitKey(100);//停顿100ms 做视频处理都是1
		if (c == 27) {		  //esc 退出应用程序
			break;
		}
		if (c == 49)//key#1
		{
			std::cout << "你按下了 #1" << std::endl;
			cvtColor(image, dst, COLOR_BGR2GRAY);
		}
		if (c == 50)//key#2
		{
			std::cout << "你按下了 #2" << std::endl;
			cvtColor(image, dst, COLOR_BGR2HSV);
		}
		if (c == 51)//key#3
		{
			std::cout << "你按下了 #3" << std::endl;
			dst = Scalar(50, 50, 50);
			add(image, dst, dst);
		}
		imshow("键盘响应", dst);
		std::cout << c << std::endl;
	}
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		qd.key_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}


运行结果       

 

 

3.鼠标响应

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

};

test.cpp       

#include<test.h>


//鼠标操作与响应
	Point sp(-1, -1);//鼠标的开始的位置
	Point ep(-1, -1);//鼠标放下的位置
	Mat temp;

//处理绘图事件:事件,x 和 y表示鼠标的坐标位置,标志或状态信息,指向用户数据的指针
static void on_draw(int event, int x, int y, int flags, void *userdata)
//event:表示发生的事件类型
//	EVENT_MOUSEMOVE(鼠标移动)
//	EVENT_LBUTTONDOWN(鼠标左键按下)
//	EVENT_RBUTTONDOWN(鼠标右键按下)
{
	//获取用户数据
	Mat image = *((Mat*)userdata);
	if (event == EVENT_LBUTTONDOWN)		//如果鼠标的左键按下   显示起点	
	{
		sp.x = x;
		sp.y = y;
		std::cout << "起点" << sp << std::endl;
	}
	else if (event == EVENT_LBUTTONUP)	//鼠标左键弹起事件		在新窗口显示图
	{
		ep.x = x;
		ep.y = y;
		int dx = ep.x - sp.x;
		int dy = ep.y - sp.y;

		if (dx > 0 && dy > 0)
		{
			//区域
			Rect box(sp.x, sp.y, dx, dy);		

			//绘制一个窗口盒子
			rectangle(image, box, Scalar(0, 0, 255), 2, 8, 0);
			imshow("截取显示区域窗口", image(box));

			//复位,为下一次做准备
			sp.x = -1;
			sp.y = -1;
		}
	}
	else if (event == EVENT_MOUSEMOVE)	//鼠标移动			   在原图附件上面取图
	{
		if (sp.x > 0 && sp.y > 0)
		{
			ep.x = x;
			ep.y = y;
			int dx = ep.x - sp.x;
			int dy = ep.y - sp.y;
			if (dx > 0 && dy > 0)
			{
				//截取绘制区域
				Rect box(sp.x, sp.y, dx, dy);

				//在原图附件上显示绘制的矩形
				rectangle(image, box, Scalar(0, 0, 255), 2, 8, 0);
				imshow("鼠标绘制", image);

				//复制到
				temp.copyTo(image);
			}
		}
	}
}
void QuickDemo::mouse_drawing_demo(Mat &image)
{
	//自动调整大小的窗
	namedWindow("鼠标绘制", WINDOW_AUTOSIZE);

	//窗口的名称,回调函数,指向void的指针
	setMouseCallback("鼠标绘制", on_draw, (void*)(&image));

	//原图附件
	imshow("鼠标绘制", image);

	//克隆显示(从原图附件截取的图片 克隆 到新建窗口)
	

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		qd.mouse_drawing_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

五:图形

1.图像几何形状绘制

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像几何形状的绘制
void QuickDemo::drawing_demo(Mat &image)
{//
	矩形
	//	Rect rect;
	//		rect.x = 30;
	//		rect.y = 90;
	//		rect.width = 50;
	//		rect.height = 50;
	//	//输入图像,矩形对象,颜色,线条宽度,线条类型,填充方式(0不填充)
	//	rectangle(image, rect, Scalar(255, 0, 0), 6, 8, 0);
	//	imshow("图形的绘制", image);

	圆形		
	//	//输入图像,圆的中心点坐标(以像素为单位),圆的半径,颜色,线条宽度,线条类型,填充方式
	//	circle(image, Point(50, 90), 15, Scalar(255, 0, 0), 2, LINE_AA, 0);
	//	imshow("图形的绘制", image);
	
	对两个图像进行加权合并
	//	Mat dst;
	//	Mat bg = Mat::zeros(image.size(), image.type());
	//	//输入图像,图像的权重(取值范围为[0,1]),输入图像,图像的权重(取值范围为[0,1]),像素值的加权和(范围为[-128,127]),输出图像
	//	addWeighted(image, 0.7, bg, 0.3, 0, image);
	//	imshow("图形的绘制", image);

	直线
	//	//输入图像,起点,终点,颜色,线条宽度,线条类型,填充方式
	//	line(image, Point(10, 50), Point(100, 50), Scalar(0, 0, 255), 8, LINE_AA, 0);
	//	imshow("图形的绘制", image);
	
	//椭圆
		RotatedRect rtt;
			//指定椭圆的位置、大小和方向
			rtt.center = Point(90, 90);
			rtt.size = Size(20, 50);
			rtt.angle = 0.0;
		//输入图像,位置 大小 方向,颜色,线条宽度,线条类型
		ellipse(image, rtt, Scalar(0, 0, 255), 2, 8);
		imshow("图形的绘制", image);


}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		qd.drawing_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

 

 

 

2.多边形填充与绘制

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

};

test.cpp       

#include<test.h>


//多边形填充与绘制
void QuickDemo::polyline_drawing_demo(Mat &image)
{
	Mat canvas = Mat::zeros(Size(512, 512), CV_8UC3);
		//各个点
		Point p1(100, 100);
		Point p2(350, 100);
		Point p3(450, 280);
		Point p4(320, 450);
		Point p5(80, 400);

	//写入到容器
	std::vector<Point>pts;
	pts.push_back(p1);
	pts.push_back(p2);
	pts.push_back(p3);
	pts.push_back(p4);
	pts.push_back(p5);

	//绘制多边形轮廓填充[只能填充]:地方,包含多线段顶点坐标的数组,颜色,线段绘制方式,对齐坐标的位数
	//fillPoly(canvas, pts, Scalar(122, 155, 255), 8, 0);

	//绘制多边形轮廓:地方,包含多线段顶点坐标的数组,线段是否封闭,颜色,线宽,线段绘制方式,对齐坐标的位数
	//polylines(canvas, pts, true, Scalar(0, 0, 255), 2, 8, 0);

	std::vector<std::vector<Point>>contours;
	//把各个点导入数组
	contours.push_back(pts);
	//绘制多边形轮廓填充[能填充,还可以绘制]:地方,包含多线段顶点坐标的数组,-1表示填充(正表示多边形的绘制 为负表示多边形的填充),轮廓的颜色,轮廓的线宽
	drawContours(canvas, contours, -1, Scalar(0, 0, 255), -1);

	imshow("多边形绘制", canvas);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		qd.polyline_drawing_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

六:视频

1.视频文件摄像头使用

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo(Mat &image);

};

test.cpp       

#include<test.h>


//视频文件摄像头使用
void QuickDemo::video_demo(Mat &image)
{
	//读取视频的地址
	VideoCapture capture("F:/images/beauty.mp4");  
	Mat frame;

	while (true)
	{
		//读取视频
		capture.read(frame); 
		if (frame.empty())
		{
			break;
		}

		//图像镜像操作:左右翻转
		//flip(frame, frame, 1);

		imshow("视频播放", frame);

		//对视频调用之前的demo:色彩转换
		//colorSpace_Demo(frame);

		//控制速度
		int c = waitKey(10);

		if (c == 27) { //esc 退出应用程序
			break;
		}
	}

	//释放相机的资源
	capture.release();
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		qd.video_demo(src);


	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

2.视频处理与保存

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

};

test.cpp       

#include<test.h>


//视频处理与保存
void QuickDemo::video_demo2(Mat &image)
{
	//读取视频的地址
	VideoCapture capture("F:/images/beauty.mp4");

	int frame_width = capture.get(CAP_PROP_FRAME_WIDTH);		//获取视频的宽度
	int frame_height = capture.get(CAP_PROP_FRAME_HEIGHT);		//获取视频的高度
	int count = capture.get(CAP_PROP_FRAME_COUNT);				//视频总的帧数												 
	double fps = capture.get(CAP_PROP_FPS);						//获取帧率

	std::cout << "宽度" << frame_width << std::endl;
	std::cout << "高度" << frame_height << std::endl;
	std::cout << "帧数" << count << std::endl;
	std::cout << "帧率" << fps << std::endl;

	//保存地址,获取图片的格式,图片的帧数,视频宽高,真
	VideoWriter writer("F:/images/test.mp4", capture.get(CAP_PROP_FOURCC), fps, Size(frame_width, frame_height), true);


	Mat frame;
	while (true)
	{
		//读取视频
		capture.read(frame);
		if (frame.empty())
		{
			break;
		}

		//图像镜像操作:左右翻转
		//flip(frame, frame, 1);

		imshow("视频播放", frame);

		//对视频调用之前的demo:色彩转换
		//colorSpace_Demo(frame);

		//控制速度
		int c = waitKey(30);

		if (c == 27) { //esc 退出应用程序
			break;
		}
	}

	capture.release();	//释放相机的资源
	writer.release();	//释放存放的资源
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		qd.video_demo2(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

七:直方图

1.图像的直方图

图像直方图的解释:将一幅图像的每个通道的像素强度分布以直方图的形式展现出来,便于观察和分析图像的亮度分布特征
    是一种用于计算机视觉和图像识别的特征描述符

    直方图主要基于图像局部方块的边缘方向直方图
    它将图像划分为小的细胞单元,每个细胞单元包含9个方向的边缘强度
    然后,将这些边缘强度分布(即直方图)组合起来,形成整个图像的直方图
    这个直方图描述了图像中物体的形状信息


广泛地应用于
    图像处理的各个领域,特别是灰度图像的阈值分割、基于颜色的图像检索以及图像分类、反向投影跟踪


分类
    灰度直方图
    颜色直方图


优缺点
    直方图的优点是:
        图像平移、旋转、缩放不变性
        它对图像的几何和光照变化具有鲁棒性
        它能够有效地描述物体的边缘和轮廓信息
        它对背景噪声不敏感

    直方图的缺点是:
        直方图通常需要组合许多小块的信息,这可能会导致对图像中物体的部分缺失或变形
        它不能提供物体的空间位置信息
        直方图的计算复杂度较高


作用:
    用于图像分割:对于具有双峰性的图像,可以利用大津法对图像进行分割,这种方法对图像的几何和光照变化具有鲁棒性
    用于图像识别:通过研究质量波动状况之后,就能掌握过程的状况,从而确定在什么地方集中力量进行质量改进工作
    用于行人检测:如果图像中没有人跟有人的直方图是不同的,通过比较两幅图像的直方图,可以判断这两幅图像是否相似

其他概念:
    Bins是指直方图的大小范围
        对于像素值取值在0~255之间的,最少有256个bin
        此外还可以有16、32、48、128等,256除以bin的大小应该是整数倍

    直方图归一化
        是一种图像处理方法,可以将直方图的像素分布调整为均匀分布的状态,使得图像的对比度得到提升

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

		//图像直方图
		void QuickDemo::histogram_demo(Mat &image);

};

test.cpp       

#include<test.h>


//图像直方图
void QuickDemo::histogram_demo(Mat &image) {
	// 三通道分离
		std::vector<Mat> bgr_plane;
		//split函数被用于将一个BGR图像(即具有三个颜色通道的图像)拆分为三个单独的通道,每个通道都包含一个单通道的图像
		split(image, bgr_plane);

	// 定义参数变量
		const int channels[1] = { 0 };
		const int bins[1] = { 256 };			//存储直方图的bin(大小范围)
		float hranges[2] = { 0,255 };			//通道的强度范围
		const float* ranges[1] = { hranges };

	//存储计算得到的直方图
	Mat b_hist;
	Mat g_hist;
	Mat r_hist;
	// 计算Blue, Green, Red通道的直方图:计算图像的直方图
		//1~4:要计算直方图的图像,通道数,直方图的掩膜图像的通道索引,空的掩膜图像(使用掩膜计算直方图的图像区域)
		//5~8:存储计算得到的直方图,直方图的维度是一维,灰度图像的强度值范围为0到255,包含每个通道的强度范围数组
		calcHist(&bgr_plane[0], 1, channels, Mat(), b_hist, 1, bins, ranges);
		//calcHist(&bgr_plane[0], 1, 0, Mat(), b_hist, 1, bins, ranges);
		calcHist(&bgr_plane[1], 1, channels, Mat(), g_hist, 1, bins, ranges);
		calcHist(&bgr_plane[2], 1, channels, Mat(), r_hist, 1, bins, ranges);


	// 显示直方图:创建一个大小为400x512的黑色图像(所有像素值初始化为0)
		int hist_w = 512;											//直方图的每个条形的宽度
		int hist_h = 400;											//直方图的高度
		int bin_w = cvRound((double)hist_w / bins[0]);				//每个直方图条形的宽度
			//cvRound():返回跟参数最接近的整数值,即四舍五入
			//cvRound()函数转换为整数,以确保绘制的直线端点与像素中心对齐
		Mat histImage = Mat::zeros(hist_h, hist_w, CV_8UC3);		//存储创建的直方图图像
			//将数据类型设置为CV_8UC3。这表示每个像素使用8位无符号整数,并且具有三个通道(红、绿、蓝)
		
	// 对每个通道的直方图进行归一化:像素均匀分布
		//1~4:输入数组进行归一化的直方图数据,输出数组,归一化的最小值,归一化的最大值
		//5~7:归一化类型(将原始数据线性缩放到指定范围),用于存储归一化后的数据的矩阵,传递给函数作为可选的矩阵参数
		normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
		normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());
		normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat());

	// 画曲线,将直方图数据可视化:绘制出每个通道的直方图,并将它们叠加在同一个图像上,以展示图像的颜色分布
		//方法一:嵌套
		for (int i = 1; i < bins[0]; i++) {		
			//在图像上绘制直线
				line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(b_hist.at<float>(i - 1))),		//输入图像,起点,终点
					//计算当前bin的横坐标:列表的索引是从0开始的,所以需要减去1才能对应到bin的索引
					//计算当前bin的纵坐标:b_hist.at<float>(i - 1)获取第i个bin的直方图值,,将纵坐标取反,即从直方图高度减去该值,以得到图像中对应的像素位置
					
					//在给定的代码中,hist_h是直方图的基线(即y=0的位置)是固定的
					//而cvRound(b_hist.at<float>(i - 1))则是第i个直方图的峰值
					//因此,通过减去cvRound(b_hist.at<float>(i - 1)),我们可以将直方图向下移动,使其与基线对齐
					//减去cvRound(b_hist.at<float>(i - 1))是为了将直方图向下移动一定的距离

			//定位直线起点和终点在图像中的位置			起点 终点,颜色,线宽为2个像素,线类型为8,没有像素偏移
				//通过使用Point对象,我们可以方便地指定直线的起点和终点在图像中的准确位置
				Point(bin_w*(i), hist_h - cvRound(b_hist.at<float>(i))), Scalar(255, 0, 0), 2, 8, 0);	//起点,终点,蓝色

			line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(g_hist.at<float>(i - 1))),
				Point(bin_w*(i), hist_h - cvRound(g_hist.at<float>(i))), Scalar(0, 255, 0), 2, 8, 0);	//绿色

			line(histImage, Point(bin_w*(i - 1), hist_h - cvRound(r_hist.at<float>(i - 1))),
				Point(bin_w*(i), hist_h - cvRound(r_hist.at<float>(i))), Scalar(0, 0, 255), 2, 8, 0);	//红色
		}
		
		//方法二:这个比较好理解
		for (int i = 0; i < 256; i++) {
			Point p01(bin_w * i, hist_h - cvRound(b_hist.at<float>(i)));
			Point p02(bin_w * i + 1, hist_h - cvRound(b_hist.at<float>(i + 1)));
			line(histImage, p01, p02, Scalar(255, 0, 0), 1, 8, 0);

			Point p11(bin_w * i, hist_h - cvRound(g_hist.at<float>(i)));
			Point p12(bin_w * i + 1, hist_h - cvRound(g_hist.at<float>(i + 1)));
			line(histImage, p11, p12, Scalar(0, 255, 0), 1, 8, 0);

			Point p21(bin_w * i, hist_h - cvRound(r_hist.at<float>(i)));
			Point p22(bin_w * i + 1, hist_h - cvRound(r_hist.at<float>(i + 1)));			
			line(histImage, p21, p22, Scalar(0, 0, 255), 1, 8, 0);

		}


	// 显示直方图
		namedWindow("直方图曲线", WINDOW_AUTOSIZE);
		imshow("直方图曲线", histImage);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		//qd.video_demo2(src);

		//图像直方图
		qd.histogram_demo(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

2.二维2D直方图

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

		//图像直方图
		void QuickDemo::histogram_demo(Mat &image);

		//二维直方图
		void QuickDemo::histogram_2d_demo(Mat &image);

};

test.cpp       

#include<test.h>


//二维2D直方图
void QuickDemo::histogram_2d_demo(Mat &image) {
		Mat hsv,hs_hist;	//输入输出图像
		cvtColor(image, hsv, COLOR_BGR2HSV);

		int hbins = 30, sbins = 32;							//h30行,s32列
		int hist_bins[] = { hbins, sbins };					//直方图的bin数量

		float h_range[] = { 0, 180 };
		float s_range[] = { 0, 256 };
		const float* hs_ranges[] = { h_range, s_range };	//包含每个通道的取值范围的数组

	//计算一维数组的直方图
		int hs_channels[] = { 0, 1 };
		//计算一维数组的直方图:1~5:输入图像的指针,直方图的通道数,包含通道名称的数组,存储计算得到的直方图,输出图像即直方
		//					  6~10:直方图的维度-2D,直方图的bin数量,包含每个通道的取值范围的数组,是否将输入图像归一化,是否计算累积分布函数
		calcHist(&hsv, 1, hs_channels, Mat(), hs_hist, 2, hist_bins, hs_ranges, true, false);

	//存储下面画的矩形
		double maxVal = 0;
		//这个函数的作用是在给定的数组或矩阵中寻找元素的最大值,并返回它们的位置
			//参数:计算最小值和最大值的输入数组或图像,要计算的维度或轴的参数- 0表示在第一个维度,存储计算得到的最大值,范围或边界,范围或边界
			minMaxLoc(hs_hist, 0, &maxVal, 0, 0);

		int scale = 10;
		//sbins*scale行和hbins*scale列,数据类型为CV_8UC3,即8位无符号整数(每个通道一个)
		Mat hist2d_image = Mat::zeros(sbins*scale, hbins * scale, CV_8UC3);

	//叠加矩形
		for (int h = 0; h < hbins; h++) {
			for (int s = 0; s < sbins; s++)
			{
				//位于横h,列s处的频次
				float binVal = hs_hist.at<float>(h, s);
				//颜色
				int intensity = cvRound(binVal * 255 / maxVal);

				//画矩形
				rectangle(hist2d_image,									//输入图像
						 Point(h*scale, s*scale),						//左上角的坐标
						 Point((h + 1)*scale - 1, (s + 1)*scale - 1),	//右下角的坐标
						Scalar::all(intensity),							//颜色
						-1);											//线条宽度
			}
		}

		//将灰度图像转换为彩色图像,以便更好地可视化直方图数据
		//通过对每个像素应用颜色映射来将灰度值映射为彩色值,从而将灰度图像转换为彩色图像
		//输入的2D直方图图像-通常为灰度图像,输出图像-即应用颜色映射后的图像,颜色映射类型-这里使用的是JET颜色映射
		applyColorMap(hist2d_image, hist2d_image, COLORMAP_JET);

	// 显示直方图
		imshow("二维直方图", hist2d_image);
		//imwrite("F:/images/zhifangtu.jpg", hist2d_image);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		//qd.video_demo2(src);

		//图像直方图
		//qd.histogram_demo(src);

		//二维直方图
		qd.histogram_2d_demo(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

3.直方图的均衡化

test.h       

#include<opencv2/opencv.hpp>
using namespace cv;

//创建一个QuickDemo对象
class QuickDemo 
{
	public:
		//色彩转换
		void colorSpace_Demo(Mat &imge);
		//图像对象的创建
		void mat_creation_demo(Mat &imge);
		//图像像素的读写
		void pixel_visit_demo1(Mat &image);	//数组
		void pixel_visit_demo2(Mat &image);	//指针
		//图像像素的算术操作
		void operators_demo(Mat &image);
		//滚动条调整图像亮度
		void tracking_bar_demo1(Mat &image);
		//滚滚动条参数传递(亮度和对比度)
		void tracking_bar_demo2(Mat &image);
		//键盘响应
		void key_demo(Mat &image);
		//opencv自带颜色操作
		void color_style_demo(Mat &image);
		//图像像素的逻辑操作
		void bitwise_demo(Mat &image);
		//通道的分离与合并
		void channels_demo(Mat &image);
		//图像色彩空间转换
		void inrange_demo(Mat &image);

		//图像像素值统计
		void pixel_statistic_demo(Mat &image);

		//图像几何形状的绘制
		void drawing_demo(Mat &image);

		//随机数与随机颜色
		void QuickDemo::random_drawing();

		//多边形填充与绘制
		void QuickDemo::polyline_drawing_demo(Mat &image);

		//鼠标操作与响应
		void QuickDemo::mouse_drawing_demo(Mat &image);

		//图像像素类型的转换与归一化
		void QuickDemo::norm_demo(Mat &image);

		//图像的放缩与差值
		void QuickDemo::resize_demo(Mat &image);

		//图像的旋转:定义好的
		void QuickDemo::flip_demo(Mat &image);

		//图像的旋转:自定义
		void QuickDemo::rotate_demo(Mat &image);

		//视频文件摄像头使用
		void QuickDemo::video_demo1(Mat &image);

		//视频处理与保存
		void QuickDemo::video_demo2(Mat &image);

		//图像直方图
		void QuickDemo::histogram_demo(Mat &image);

		//二维直方图
		void QuickDemo::histogram_2d_demo(Mat &image);

		//直方图的均衡化
		void QuickDemo::histogram_eq_demo(Mat &image);

};

test.cpp       

#include<test.h>


//直方图的均衡化
void QuickDemo::histogram_eq_demo(Mat &image) {
	Mat gray;

	//图像转换
	cvtColor(image, gray, COLOR_BGR2GRAY);
	imshow("灰度图像", gray);

	Mat dst;
	//输入,输出
	equalizeHist(gray, dst);
	imshow("直方图均衡化演示", dst);
}

main.cpp       

//知识点	IM表示图片
	//读取图像:imread
	//显示图像:imshow
	//色彩空间转换函数(B G R):cvtColor
		//COLOR_BGR2GRAY = 6彩色到灰度
		//COLOR_GRAY2BGR = 8灰度到彩色
		//COLOR_BGR2HSV  = 40BGR到HSV
		//COLOR_HSV2BGR  = 54HSV到BGR
	//保存图片:imwrite(保存路径,内存对象)



#include<opencv2/opencv.hpp>
#include<iostream>
#include<test.h>


using namespace std;
using namespace cv;
int main()
{
	//读取进来的数据以矩阵的形势
	Mat src = imread("F:/images/gril.jpg", IMREAD_ANYCOLOR);	    //第二个参数代表显示一张灰度图像

																	//看是否是空图片
	if (src.empty())
	{
		printf("图片不存在");
		return -1;
	}
	//创建了一个新窗口:超过屏幕的图像无法显示时候调用此函数
	namedWindow("输入窗口", WINDOW_FREERATIO);					   //参数1表示名称,参数二代表窗口自由显示

	//表示显示在新创建的输入窗口上
	imshow("输入窗口", src);									   //第一个参数表示窗口名称,src表示数据对象Mat 


	//在主函数中调用之前创建的类对象	
	QuickDemo qd;
		//色彩转换
		//qd.colorSpace_Demo(src);

		//图像对象的创建
		//qd.mat_creation_demo(src);

		//图像像素的读写
		//qd.pixel_visit_demo1(src);	//数组
		//qd.pixel_visit_demo2(src);	//指针

		//图像像素的算术操作
		//qd.operators_demo(src);

		//滚动条调整图像亮度
		//qd.tracking_bar_demo1(src);

		//滚动条参数传递(亮度和对比度)
		//qd.tracking_bar_demo2(src);

		//键盘响应
		//qd.key_demo(src);

		//opencv自带颜色操作
		//qd.color_style_demo(src);

		//图像像素的逻辑操作
		//qd.bitwise_demo(src);

		//通道的分离与合并
		//qd.channels_demo(src);

		//图像色彩空间转换
		//qd.inrange_demo(src);

		//图像像素值统计
		//qd.pixel_statistic_demo(src);

		//图像几何形状的绘制
		//qd.drawing_demo(src);

		//随机数与随机颜色
		//qd.random_drawing();

		//多边形填充与绘制
		//qd.polyline_drawing_demo(src);

		//鼠标操作与响应
		//qd.mouse_drawing_demo(src);

		//图像像素类型的转换与归一化
		//qd.norm_demo(src);

		//图像的放缩与差值
		//qd.resize_demo(src);

		//图像的旋转:定义好的
		//qd.flip_demo(src);

		//图像的旋转:自定义
		//qd.rotate_demo(src);

		//视频文件摄像头使用
		//qd.video_demo1(src);

		//视频处理与保存
		//qd.video_demo2(src);

		//图像直方图
		//qd.histogram_demo(src);

		//二维直方图
		//qd.histogram_2d_demo(src);

		//直方图的均衡化
		qd.histogram_eq_demo(src);

	waitKey(0);													   //执行到这句,程序阻塞。参数表示延时时间。单位ms毫秒
	destroyAllWindows();										   //销毁前面创建的显示窗口
	return 0;
}

运行结果       

Opencv4基于C++的 实时人脸检测

Opencv4基于C++的 实时人脸检测

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/77484.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

java八股文面试[java基础]——String StringBuilder StringBuffer

String类型定义&#xff1a; final String 不可以继承 final char [] 不可以修改 String不可变的好处&#xff1a; hash值只需要算一次&#xff0c;当String作为map的key时&#xff0c; 不需要考虑hash改变 天然的线程安全 知识来源&#xff1a; 【基础】String、StringB…

latex 笔记:cs论文需要的排版格式

主要针对英文文献 1 基本环境 连字符 不同长度的"-"表示不同含义。 一个"-"长度的连字符用于词中两个"-"长度的连字符常用于制定范围三个"-"长度的连字符是破折号数学中的负数要用数学环境下的-得到 强调 在正式文章中, 通常不…

探索区块链世界:去中心化应用(DApp)的崭新前景

随着科技的不断发展&#xff0c;区块链技术逐渐引领着数字时代的潮流。在这个充满创新和变革的领域中&#xff0c;去中心化应用&#xff08;DApp&#xff09;成为了备受瞩目的焦点。DApp 不仅改变了传统应用程序的范式&#xff0c;还在金融、社交、游戏等多个领域展现出了广阔的…

File Upload

File Upload 文件上传功能是大部分WEB应用的常用功能&#xff0c;网站允许用户自行上传头像、照片、一些服务类网站需要用户上传证明材料的电子档、电商类网站允许用户上传图片展示商品情况等。然而&#xff0c;看似不起眼的文件上传功能如果没有做好安全防护措施&#xff0c;…

【数理知识】向量与基的内积,Matlab 代码验证

序号内容1【数理知识】向量的坐标基表示法&#xff0c;Matlab 代码验证2【数理知识】向量与基的内积&#xff0c;Matlab 代码验证 文章目录 1. 向量与基的内积2. 二维平面向量举例3. 代码验证Ref 1. 向量与基的内积 假设存在一个二维平面内的向量 a ⃗ \vec{a} a &#xff0c…

具身智能:人工智能的下一个浪潮

原创 | 文 BFT机器人 特斯拉 2023 年股东会上&#xff0c;马斯克强调了人形机器人对特斯拉未来的重要性&#xff0c;并预测其将成为公司的主要长期价值来源。他进一步表示&#xff1a;“如果人形机器人和人的比例大致为2比1&#xff0c;那么人们对机器人的需求可能达到100亿乃…

W5100S-EVB-PICO 做UDP Server进行数据回环测试(七)

前言 前面我们用W5100S-EVB-PICO 开发板在TCP Client和TCP Server模式下&#xff0c;分别进行数据回环测试&#xff0c;本章我们将用开发板在UDP Server模式下进行数据回环测试。 UDP是什么&#xff1f;什么是UDP Server&#xff1f;能干什么&#xff1f; UDP (User Dataqram …

爬虫逆向实战(十三)--某课网登录

一、数据接口分析 主页地址&#xff1a;某课网 1、抓包 通过抓包可以发现登录接口是user/login 2、判断是否有加密参数 请求参数是否加密&#xff1f; 通过查看“载荷”模块可以发现有一个password加密参数&#xff0c;还有一个browser_key这个可以写死不需要关心 请求头…

【Image captioning】ruotianluo/self-critical.pytorch之1—数据集的加载与使用

【Image captioning】ruotianluo/self-critical.pytorch之1—数据集的加载与使用 作者&#xff1a;安静到无声 个人主页 数据加载程序示意图 使用方法 示例代码 #%%from __future__ import absolute_import from __future__ import division from __future__ import print_…

导读-Linux简介

Linux简介 ​ 总所周知&#xff0c;计算机系统包含硬件和软件两部分。硬件部分被称为裸机&#xff0c;主要包括中央处理器&#xff08;CPU&#xff09;、内存、外存和各种外部设备。软件部分主要包括系统软件和应用软件两部分。系统软件包括操作系统、汇编语言、编译程序、数据…

AD域控制器将辅域控制器角色提升为主域控制器

背景 域控服务器迁移&#xff0c;已将新机器添加为该域的辅域控制器。 主域控制器&#xff1a;test-dc-01 辅域控制器&#xff1a;test-dc-02 需求将主辅域的角色进行互换&#xff0c;test-dc-01更换为辅域&#xff0c;test-dc-02更换为主域。 操作步骤 方法1 命令行修改AD域…

2023国赛数学建模思路 - 复盘:校园消费行为分析

文章目录 0 赛题思路1 赛题背景2 分析目标3 数据说明4 数据预处理5 数据分析5.1 食堂就餐行为分析5.2 学生消费行为分析 建模资料 0 赛题思路 &#xff08;赛题出来以后第一时间在CSDN分享&#xff09; https://blog.csdn.net/dc_sinor?typeblog 1 赛题背景 校园一卡通是集…

ubuntu16编译内核源码并替换

文章目录 1.找到和ubuntu内核版本相同的内核源码包2.下载下面三个文件3.相关步骤4.安装编译环境软件参考&#xff1a; 1.找到和ubuntu内核版本相同的内核源码包 4.15.0-112.113 : linux package : Ubuntu (launchpad.net) 2.下载下面三个文件 3.相关步骤 uname -r #查看内核…

python3实现线性规划求解

Background 对于数学规划问题&#xff0c;有很多的实现。MatlabYALMIPCPLEX这个组合应该是比较主流的&#xff0c;尤其是在电力相关系统中占据着比较重要的地位。MATLAB是一个强大的数值计算工具&#xff0c;用于数学建模、算法开发和数据分析。Yalmip是一个MATLAB工具箱&#…

阿里云Alibaba Cloud Linux镜像系统介绍_常见问题解答FAQ

阿里云服务器操作系统Alibaba Cloud Linux镜像怎么样&#xff1f;可以代替CentOS吗&#xff1f;Alibaba Cloud Linux兼容性如何&#xff1f;有人维护吗&#xff1f;漏洞可以修复吗&#xff1f;Alibaba Cloud Linux完全兼容CentOS&#xff0c;并由阿里云官方免费提供长期维护。 …

【不带权重的TOPSIS模型详解】——数学建模

目录索引 定义&#xff1a;问题引入&#xff1a;不合理之处&#xff1a;进行修改&#xff1a; 指标分类&#xff1a;指标正向化&#xff1a;极小型指标正向化公式&#xff1a;中间型指标正向化公式&#xff1a;区间型指标正向化公式&#xff1a; 标准化处理(消去单位)&#xff…

UML-时序图

目录 时序图 时序图构成: 对象: 消息: 生命线(激活): 活动条: 时序图举例: 时序图 时序图也叫顺序图、序列图. 时序图描述按照时间的先后顺序对象之间的动作过程&#xff0c;是由生命线和消息组成 时序图构成: 对象: 对象是类的实例&#xff0c;对象是通过类来创建的&…

远程桌面配置指南:保留TCP地址、配置隧道和使用固定TCP地址

远程桌面配置指南&#xff1a;保留TCP地址、配置隧道和使用固定TCP地址 文章目录 远程桌面配置指南&#xff1a;保留TCP地址、配置隧道和使用固定TCP地址第一步&#xff1a;保留TCP地址第二步&#xff1a;为远程桌面隧道配置固定的TCP地址第三步&#xff1a;使用固定TCP地址远程…

前端练手小项目--自定义时间(html+css+js)

自定义时间 写文章的因 关于要写这篇文章的原因 是记录在工作上遇到的困难需求&#xff0c;是希望能给大家提供一些解决问题的思路 接下来我描述这个需求的多样性&#xff0c;难点在哪。 勾选勾选框开始时间与结束时间默认显示昨天与今天。取消勾选框开始时间与结束时间清空。…

6.1 安全漏洞与网络攻击

数据参考&#xff1a;CISP官方 目录 安全漏洞及产生原因信息收集与分析网络攻击实施后门设置与痕迹清除 一、安全漏洞及产生原因 什么是安全漏洞 安全漏洞也称脆弱性&#xff0c;是计算机系统存在的缺陷 漏洞的形式 安全漏洞以不同形式存在漏洞数量逐年递增 漏洞产生的…