编程语言
首页 > 编程语言> > OpenCV3编程入门（毛星云）读书笔记（一）

OpenCV3编程入门（毛星云）读书笔记（一）

作者：互联网

开始

cv版本2.4.9

编译器vs2019

资料书：OpenCV3编程入门（毛星云）

配置

按照网上教程。

遇到的问题

运行测试程序遇到的问题：

OpenCV Error: Assertion failed (size.width>0 && size.height>0) in cv::imshow, file ........\opencv\modules\highgui\src\window.cpp, line 261

原因是由于图片的地址错误。图片应该存在项目下。

image-20211111180520544

测试程序

#include <opencv2/opencv.hpp>
using namespace cv;
int main() {
	/*Mat img = imread("1.jpg");*///这里的图片存在项目下（文件中）
	Mat img = imread("D:\\cv\\opencv_demo\\1.jpg");//注意地址间是\\
	imshow("[载入的图片]", img);
	waitKey(6000);
}

在运行过程中，如果出现XXX未定义等情况，最好将cv删掉重新解压使用

简单几个例子

1、图像腐蚀

用暗色部分腐蚀掉图片中的亮色部分

#include <opencv2/opencv.hpp>
using namespace cv;
//图片腐蚀
int main() {
	Mat scrimage = imread("1.jpg");
	imshow("原图", scrimage);
	//腐蚀操作
	Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));
	Mat dstImage;
	erode(scrimage, dstImage, element);//进行图像腐蚀
	imshow("效果图", dstImage);
	waitKey();
	return 0;
}
image-20211111181443987

2、图像模糊

#include <opencv2/opencv.hpp>
using namespace cv;
//图片模糊
int main() {
	Mat scrImage = imread("1.jpg");
	imshow("原图", scrImage);
	Mat dstImage;
	blur(scrImage, dstImage, Size(7, 7));//图片模糊
	imshow("效果图", dstImage);
	waitKey();
}
image-20211111182422873

3、canny边缘检测

载入图像，先转为灰度图，再用blur进行图片模糊降噪，用canny进行边缘检测

#include <opencv2/opencv.hpp>
using namespace cv;
//图片边缘检测
int main() {
	Mat srcImage = imread("2.jpg");
	imshow("原图", srcImage);
	Mat dstImage,edge,grayImage;
	dstImage.create(srcImage.size(), srcImage.type());//设置和原图一样的矩阵
	cvtColor(srcImage, grayImage, CV_BGR2GRAY);//在dstImage矩阵上生成图
	blur(grayImage, edge, Size(3, 3));
	Canny(edge, edge, 3, 9, 3);
	imshow("效果图", edge);
	waitKey();
	return 0;
}
image-20211111184037827

4、读取并播放视频

#include <opencv2\opencv.hpp>
using namespace cv;
int main(){
    VideoCapture capture("1.avi");//存储位置相同
    while(1){
        Mat frame;
        capture>>frame;
        imshow("读取视频",frame);
        waitKey(30);
    }
    return 0;
}

5、截取摄像头图像并canny处理

#include <opencv2/opencv.hpp>
using namespace cv;
int main() {
	VideoCapture capture(0);//表示使用摄像头
	Mat edges;
	while (1) {
		Mat frame;
		capture >> frame;
		cvtColor(frame, edges, CV_BGR2GRAY);
		blur(edges, edges, Size(7, 7));
		Canny(edges, edges, 0, 30, 3);
		imshow("结果", edges);
		if (waitKey(30) >= 0) {
			break;
		}
	}
	return 0;
}

//输出当前cv版本
printf("\t版本 OpenCV" CV_VERSION);

HighGUI图形用户界面初步

cv2开始使用Mat为数据类型进行图像存取

图像的载入、显示及输出

imread()

读取文件中的图像

Mat imread(const string& filename,int flags=1);

const string&filename：填入图片的路径名

int flags：载入标识，指定加载图像的颜色类型。默认值为1，可忽略。

取个各值意义：

​ -1：废除

​ 0：图像转换成灰度后返回

​ 1：转换图像到彩色再返回（默认值）

​ 2：若取该值且载入的图像的深度为16或32位，就返回对应深度的图像，否则就转换为8位图像再返回

如果不想使用以上固定的赋值方式，还可：

​ falgs>0 返回三通道的彩色图像

​ flags=0 返回灰度图像（就是灰色的）

​ flags<0返回包含Alpha通道的加载图像

imshow()

在指定窗口中显示一幅图像

void imshow(const string& winname,InputArray mat)

const strings& winname：需要显示的窗口的标识名称

InputArray mat：需要显示的图像

如果窗口是用CV_WINDOW_AUTOSIZE(默认值)标志创建，那么显示图像的原始大小，否则将图像进行缩放以适合窗口。

注意：在这里遇到的InputArray类型可以直接看作是Mat类型来使用

namedWindow()

创建一个窗口

如果只是简单的显示图像，不需要这一步，直接imread、imshow即可。但是如果需要在显示窗口之前就用到窗口名时，如添加滑动条，就需要先创建出窗口，显式规定窗口名称

void namedWindow(const string& winname,int flags = WINDOW_AUTOSIZE)

winname：填写被用作窗口的标识符的窗口名称

flags：窗口的标识,它可以填以下值

​ WINDOW_NORMAL：用户可以改变窗口的大小（或者是CV_WINDOW_NORMAL）

​ WINDOW_AUTOSIZE：自动调整窗口大小，用户不可手动修改（默认）

​ WINDOW_OPENGL: 窗口创建时会支持Open GUI

以上标识，在CV2中也可写为CV_标识

注意namedwindow建的窗口要与后续imread显示图片使用的名字一样

imwrite()

输出图像到文件

bool imwrite(const string& filename,InputArray img,const vector& params=vector())

filename：写入的文件名。要带上后缀

img：Mat数据类型的图像数据

params：特定格式保存的参数编码。有默认值。要填写的话查一下。

#include <opencv2/opencv.hpp>
#include <vector>
using namespace cv;
using namespace std;
void createAlphaMat(Mat& mat)
{
	for (int i = 0; i < mat.rows; ++i) {
		for (int j = 0; j < mat.cols; ++j) {
			Vec4b& rgba = mat.at<Vec4b>(i, j);
			rgba[0] = UCHAR_MAX;
			rgba[1] = saturate_cast<uchar>((float(mat.cols - j)) / ((float)mat.cols) * UCHAR_MAX);
			rgba[2] = saturate_cast<uchar>((float(mat.rows - i)) / ((float)mat.rows) * UCHAR_MAX);
			rgba[3] = saturate_cast<uchar>(0.5 * (rgba[1] + rgba[2]));
		}
	}
}
int main()
{
	//创建带alpha通道的Mat
	Mat mat(480, 640, CV_8UC4);
	createAlphaMat(mat);

	vector<int>compression_params;
	compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);//CV2版本
	//compression_params.push_back(IMWRITE_PNG_COMPRESSION);//CV3版本
	compression_params.push_back(9);
//这里是对imwrite中params参数的输入设置
    
	//显示图片
	try {
		imwrite("透明Alpha值图.png", mat, compression_params);
		imshow("生成的png图", mat);
		fprintf(stdout, "PNG图片文件的alpha数据保存完毕~\n可以在工程目录下查看由imwrite函数生成的图片\n");
		waitKey(0);
	}
	catch (runtime_error& ex) {
		fprintf(stderr, "图像转换成PNG格式发生错误：%s\n", ex.what());
		return 1;
	}

	return 0;
}

上述代码重点在于imwrite的使用方式，不需要纠结它的画法

CV_IMWRITE_PNG_COMPRESSION：png格式图片

CV_IMWRITE_JPEG_QUALITY：jpeg格式

图像混合

#include <opencv2/opencv.hpp>
#include <vector>
using namespace cv;
using namespace std;
int main()
{
	Mat image = imread("dota.jpg", 199);
	Mat logo = imread("1.jpg");
	namedWindow("原图");
	imshow("原图", image);
	Mat imageROI;
	//imageROI = image(Rect(800, 350, logo.cols, logo.rows));
	imageROI = image(Range(100, 100 + logo.rows), Range(200, 200 + logo.cols));
    //100和200表示起始点的位置
	addWeighted(imageROI, 0.5, logo, 0.3, 0., imageROI);
	namedWindow("修改后");
	imshow("修改后", image);
	imwrite("生成.jpg", image);
	waitKey(0);
	return 0;
}

将两张图片贴在一起。需要注意的点是使用Range计算logo图所贴在dota图上位置时，要计算好位置，否则会出现越界的错误

滑动条创建

依附于窗口存在

createTrackbar()

创建一个可以调整数值的滑动条

int createTrackbar(const string& trackbarname,const string& winname,int value,int count,TrackbarCallback onChange=0,void userdata=0)**

trackbarname：轨迹条的名字

winname：窗口的名字（对应namedWindow）

value：指向整型的指针，表示滑块位置

count：表示滑块可以达到的最大位置的值。滑块最小位置的值为0.

onChange：默认为0.指向回调函数指针，滑块位置改变函数就回调。函数回调原型必须是

void XX(int,void*)形式

userdata：默认为0.用户传回回调函数的数据，用来处理轨迹条事件。如果value为全局变量，则不需要管该函数

#include <opencv2/opencv.hpp>
#include <vector>
using namespace cv;
using namespace std;
//滑动条控制混合图像
#define WINDOW_NAME "线性混合示例"
//这里定义的窗口名为了在函数和main中都可以指向同一个窗口
const int g_nMaxAlphaValue = 100;//Alpha值的最大值
int g_nAlphaValueSlider;//滑动条对应的变量
double g_dAlphaValue;
double g_dBetaValue;

//声明存储图像的变量
Mat g_srcImage1;
Mat g_srcImage2;
Mat g_dstImage;

void on_Trackbar(int, void*)
{
	//求出当前alpha值相对于最大值的比例
	g_dAlphaValue = (double)g_nAlphaValueSlider / g_nMaxAlphaValue;
	//则beta值为1减去alpha值
	g_dBetaValue = (1.0 - g_dAlphaValue);

	//根据alpha和beta值进行线性混合
	addWeighted(g_srcImage1, g_dAlphaValue, g_srcImage2, g_dBetaValue, 0.0, g_dstImage);

	//显示效果图
	imshow(WINDOW_NAME, g_dstImage);
}
int main(int argc, char** argv)
{

	//加载图像 (两图像的尺寸需相同)
	g_srcImage1 = imread("3.1.jpg");
	g_srcImage2 = imread("3.2.jpg");
	if (!g_srcImage1.data) { printf("读取第一幅图片错误，请确定目录下是否有imread函数指定图片存在~！ \n"); return -1; }
	if (!g_srcImage2.data) { printf("读取第二幅图片错误，请确定目录下是否有imread函数指定图片存在~！\n"); return -1; }

	//设置滑动条初值为70
	g_nAlphaValueSlider = 70;

	//创建窗体
	namedWindow(WINDOW_NAME, 1);

	//在创建的窗体中创建一个滑动条控件
	char TrackbarName[50];//滑动条前说明字符的长度
	sprintf(TrackbarName, "透明值 %d", g_nMaxAlphaValue);

	createTrackbar(TrackbarName, WINDOW_NAME, &g_nAlphaValueSlider, g_nMaxAlphaValue, on_Trackbar);
	//这里的第三个参数value为全局变量，所以最后一个参数可以省略。on_Trackbar为回调函数

	//结果在回调函数中显示
	on_Trackbar(g_nAlphaValueSlider, 0);///显示的拖动的值。刚打开为默认值

	//按任意键退出
	waitKey(0);

	return 0;
}
image-20211117211308114

可以通过上面的滑动条修改图片的透明度

image-20211117211427537 image-20211117211500061

getTrackbarPos()

获取当前轨迹条的位置并返回。

int getTrackbarPos(const string& trackname,const string& winname)：trackname为轨迹条名字，winname为轨迹条父窗口名字

鼠标操作

void setMouseCallback(const string& winname,MouseCallback onm ouse,void* userdata = 0)

winname:窗口名字

onmouse：指定窗口里每次鼠标时间发生的时候，被调用的函数指针

userdata：用户定义的传递到回调函数的参数，默认值为0

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

#define WINDOW_NAME "【程序窗口】"        //为窗口标题定义的宏 


//-----------------------------------【全局函数声明部分】------------------------------------
//		描述：全局函数的声明
//------------------------------------------------------------------------------------------------
void on_MouseHandle(int event, int x, int y, int flags, void* param);
void DrawRectangle(cv::Mat& img, cv::Rect box);

//-----------------------------------【全局变量声明部分】-----------------------------------
//		描述：全局变量的声明
//-----------------------------------------------------------------------------------------------
Rect g_rectangle;
bool g_bDrawingBox = false;//是否进行绘制
RNG g_rng(12345);

//-----------------------------------【main( )函数】--------------------------------------------
//		描述：控制台应用程序的入口函数，我们的程序从这里开始执行
//-------------------------------------------------------------------------------------------------
int main(int argc, char** argv)
{
	//【1】准备参数
	g_rectangle = Rect(-1, -1, 0, 0);
	Mat srcImage(600, 800, CV_8UC3), tempImage;
	srcImage.copyTo(tempImage);
	g_rectangle = Rect(-1, -1, 0, 0);
	srcImage = Scalar::all(0);

	//【2】设置鼠标操作回调函数
	namedWindow(WINDOW_NAME);
	setMouseCallback(WINDOW_NAME, on_MouseHandle, (void*)&srcImage);

	//【3】程序主循环，当进行绘制的标识符为真时，进行绘制
	while (1)
	{
		srcImage.copyTo(tempImage);//拷贝源图到临时变量
		if (g_bDrawingBox) DrawRectangle(tempImage, g_rectangle);//当进行绘制的标识符为真，则进行绘制
		imshow(WINDOW_NAME, tempImage);
		if (waitKey(10) == 27) break;//按下ESC键，程序退出
	}
	return 0;
}

//--------------------------------【on_MouseHandle( )函数】-----------------------------
//		描述：鼠标回调函数，根据不同的鼠标事件进行不同的操作
//-----------------------------------------------------------------------------------------------
void on_MouseHandle(int event, int x, int y, int flags, void* param)
{

	Mat& image = *(cv::Mat*) param;
	switch (event)
	{
		//鼠标移动消息
	case EVENT_MOUSEMOVE:
	{
		if (g_bDrawingBox)//如果是否进行绘制的标识符为真，则记录下长和宽到RECT型变量中
		{
			g_rectangle.width = x - g_rectangle.x;
			g_rectangle.height = y - g_rectangle.y;
		}
	}
	break;
	//左键按下消息
	case EVENT_LBUTTONDOWN:
	{
		g_bDrawingBox = true;
		g_rectangle = Rect(x, y, 0, 0);//记录起始点
	}
	break;
	//左键抬起消息
	case EVENT_LBUTTONUP:
	{
		g_bDrawingBox = false;//置标识符为false
		//对宽和高小于0的处理
		if (g_rectangle.width < 0)
		{
			g_rectangle.x += g_rectangle.width;
			g_rectangle.width *= -1;
		}

		if (g_rectangle.height < 0)
		{
			g_rectangle.y += g_rectangle.height;
			g_rectangle.height *= -1;
		}
		//调用函数进行绘制
		DrawRectangle(image, g_rectangle);
	}
	break;
	}
}
//-----------------------------------【DrawRectangle( )函数】------------------------------
//		描述：自定义的矩形绘制函数
//-----------------------------------------------------------------------------------------------
void DrawRectangle(cv::Mat& img, cv::Rect box)
{
	cv::rectangle(img, box.tl(), box.br(), cv::Scalar(g_rng.uniform(0, 255), g_rng.uniform(0, 255), g_rng.uniform(0, 255)));//随机颜色
}

数据结构及基本绘图

图片在设备中是以像素点矩阵的形式存在的

Mat

Mat是一个类，有两个数据部分组成：矩阵头和一个指向存储所有像素值的矩阵的指针。

自动开辟空间，不需要手动释放空间

在使用图像处理函数时，会在函数中传递大量的图片。传递大量图片时图片的复制会降低程序的运行速度。所以引入了引用计数机制。

引用计数机制：每个Mat对象有自己的信息头，但是共享同一个矩阵。这通过让矩阵指针指向同一地址而实现。拷贝构造函数只复制信息头和矩阵指针，而不复制矩阵。

Mat A,C;
A = imread("1.jpg");
c = A;//这里C和A指向的都是同一个矩阵，任意一个做出修改都会导致矩阵发生变化

当矩阵属于多个对象时，由最后一个对象来清理它

如果想要复制矩阵本身，则可以使用函数clone()或者copyTo()

Mat F = A.clone();
Mat C;
A.copyTo(C);//A为被复制的矩阵

++++++++++++++++++++++++++++++++++++++++++++

存储像素值需要指定颜色空间和数据类型。

颜色系统有很多：

  1. RGB：最常见
  2. HSV和HLS：把颜色分为色调、饱和度和亮度、明度。对光照条件不敏感
  3. YCrCb：在JPEG格式中常用

如何存储一个原色决定在其定义域上能够控制的精度。最小为char，也可以用有符号型或无符号型。RGB中 三个char已经可以表示1600万种可能的颜色。但是如果用float或double又能给出更加精密的颜色分辨能力。

增加颜色尺寸也会增加图像所占的内存空间

显式创建对象

Mat不仅是图像容器类，同时也是一个通用的矩阵类。

Mat(行数,列数,CV_[][][位数] [带符号与否] [类型前缀][通道数])

Mat M(2,2,CV_8UC3,Scalar(0,0,255));
cout<<M<<endl;
//运算符<<只对二维矩阵有效
//Scalar为short型的向量，指定初始值

//构造多维
int sz[3] = {2,2,2};
Mat L(3,sz,CV_8UC,Scalar::all(0));

//使用指针创建信息头
IPlImage* img = cvLoadImage("1.jpg",1);
Mat mtx(img);

//create函数
M.create(4,4,CV_8UC(2));//此方法不能为矩阵设初值，只是改变尺寸时重新为矩阵数据开辟内存

Mat F = Mat::eye(4,4,CV_64F);

Mat C = (Mat_<double>(3,3) << 0,-1,0,-1,5,-1,2,2,2);

Mat RowClone = C.row(1).clone();

常用数据结构

Point类

表示二维坐标系下的点，即以x,y来表示

Point point;
point.x = 1;
point.y = 2;
//或者
Point point = Point(1,2);

Scalar类

用于传递像素值，它可以表示有4个像素的值，但如果只写三个也可以。

如Scalar(a,b,c)

在RGB中 a为蓝色分量，b绿色，c为红色

Size类

表示尺寸

Rect类

表示矩阵。

其成员变量有x、y、width、height表示左上角的坐标和矩形的宽和高

Size返回Size；area()返回面积；contains(Point)看点是否在矩形内；inside(Rect函数判断矩形是否在矩形内)；

tl()返回左上角坐标；br返回右下角坐标

颜色空间的转换

使用cvtColor()函数

cvtColor(输入图像，输出图像，颜色空间转换标识符，目标对象的通道数(若为0则表示目标图像取源图像的通道数))

Opencv中默认的图片通道存储顺序为BGR

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

using namespace cv;
using namespace std;

int main()
{
	Mat image1 = imread("1.1.jpg"),dstImage;  //读取图像；
	if (image1.empty())
	{
		cout << "读取错误" << endl;
		return -1;
	}
	cvtColor(image1, dstImage, COLOR_BGR2Lab);
	imshow("xiaog", dstImage);
	waitKey(0);
	return 0;
}
image-20211125131156953

基本图形绘制

在绘制前，程序源文件开头会有：

define WINDOW_WIDTH 600 //定义窗口大小的宏

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

//OpenCV3需加入头文件：
#include <opencv2/imgproc/imgproc.hpp>
//-----------------------------------【宏定义部分】-------------------------------------------- 
//		描述：定义一些辅助宏 
//------------------------------------------------------------------------------------------------ 
#define WINDOW_NAME1 "【绘制图1】"        //为窗口标题定义的宏 
#define WINDOW_NAME2 "【绘制图2】"        //为窗口标题定义的宏 
#define WINDOW_WIDTH 600//定义窗口大小的宏

void DrawEllipse(Mat img, double angle);//绘制椭圆
void DrawFilledCircle(Mat img, Point center);//绘制圆
void DrawPolygon(Mat img);//绘制多边形
void DrawLine(Mat img, Point start, Point end);//绘制线段

int main(void)
{

	// 创建空白的Mat图像
	Mat atomImage = Mat::zeros(WINDOW_WIDTH, WINDOW_WIDTH, CV_8UC3);
	Mat rookImage = Mat::zeros(WINDOW_WIDTH, WINDOW_WIDTH, CV_8UC3);

	// ---------------------<1>绘制化学中的原子示例图------------------------

	//【1.1】先绘制出椭圆
	DrawEllipse(atomImage, 90);//画椭圆，90表示该椭圆的旋转读数
	DrawEllipse(atomImage, 0);
	DrawEllipse(atomImage, 45);
	DrawEllipse(atomImage, -45);

	//【1.2】再绘制圆心
	DrawFilledCircle(atomImage, Point(WINDOW_WIDTH / 2, WINDOW_WIDTH / 2));

	// ----------------------------<2>绘制组合图-----------------------------
	//【2.1】先绘制出椭圆
	DrawPolygon(rookImage);

	// 【2.2】绘制矩形
	rectangle(rookImage,
		Point(0, 7 * WINDOW_WIDTH / 8),
		Point(WINDOW_WIDTH, WINDOW_WIDTH),
		Scalar(0, 255, 255),
		-1,
		8);

	// 【2.3】绘制一些线段
	DrawLine(rookImage, Point(0, 15 * WINDOW_WIDTH / 16), Point(WINDOW_WIDTH, 15 * WINDOW_WIDTH / 16));
	DrawLine(rookImage, Point(WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8), Point(WINDOW_WIDTH / 4, WINDOW_WIDTH));
	DrawLine(rookImage, Point(WINDOW_WIDTH / 2, 7 * WINDOW_WIDTH / 8), Point(WINDOW_WIDTH / 2, WINDOW_WIDTH));
	DrawLine(rookImage, Point(3 * WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8), Point(3 * WINDOW_WIDTH / 4, WINDOW_WIDTH));

	// ---------------------------<3>显示绘制出的图像------------------------
	imshow(WINDOW_NAME1, atomImage);
	moveWindow(WINDOW_NAME1, 0, 200);
	imshow(WINDOW_NAME2, rookImage);
	moveWindow(WINDOW_NAME2, WINDOW_WIDTH, 200);

	waitKey(0);
	return(0);
}



//-------------------------------【DrawEllipse( )函数】--------------------------------
//		描述：自定义的绘制函数，实现了绘制不同角度、相同尺寸的椭圆
//-----------------------------------------------------------------------------------------
void DrawEllipse(Mat img, double angle)
{
	int thickness = 2;
	int lineType = 8;

	ellipse(img,
		Point(WINDOW_WIDTH / 2, WINDOW_WIDTH / 2),
		Size(WINDOW_WIDTH / 4, WINDOW_WIDTH / 16),
		angle,
		0,
		360,
		Scalar(255, 129, 0),
		thickness,
		lineType);
}


//-----------------------------------【DrawFilledCircle( )函数】---------------------------
//		描述：自定义的绘制函数，实现了实心圆的绘制
//-----------------------------------------------------------------------------------------
void DrawFilledCircle(Mat img, Point center)
{
	int thickness = -1;
	int lineType = 8;

	circle(img,
		center,
		WINDOW_WIDTH / 32,
		Scalar(0, 0, 255),
		thickness,
		lineType);
}


//-----------------------------------【DrawPolygon( )函数】--------------------------
//		描述：自定义的绘制函数，实现了凹多边形的绘制
//--------------------------------------------------------------------------------------
void DrawPolygon(Mat img)
{
	int lineType = 8;

	//创建一些点
	Point rookPoints[1][20];
	rookPoints[0][0] = Point(WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8);
	rookPoints[0][1] = Point(3 * WINDOW_WIDTH / 4, 7 * WINDOW_WIDTH / 8);
	rookPoints[0][2] = Point(3 * WINDOW_WIDTH / 4, 13 * WINDOW_WIDTH / 16);
	rookPoints[0][3] = Point(11 * WINDOW_WIDTH / 16, 13 * WINDOW_WIDTH / 16);
	rookPoints[0][4] = Point(19 * WINDOW_WIDTH / 32, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][5] = Point(3 * WINDOW_WIDTH / 4, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][6] = Point(3 * WINDOW_WIDTH / 4, WINDOW_WIDTH / 8);
	rookPoints[0][7] = Point(26 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][8] = Point(26 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][9] = Point(22 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][10] = Point(22 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][11] = Point(18 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][12] = Point(18 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][13] = Point(14 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 4);
	rookPoints[0][14] = Point(14 * WINDOW_WIDTH / 40, WINDOW_WIDTH / 8);
	rookPoints[0][15] = Point(WINDOW_WIDTH / 4, WINDOW_WIDTH / 8);
	rookPoints[0][16] = Point(WINDOW_WIDTH / 4, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][17] = Point(13 * WINDOW_WIDTH / 32, 3 * WINDOW_WIDTH / 8);
	rookPoints[0][18] = Point(5 * WINDOW_WIDTH / 16, 13 * WINDOW_WIDTH / 16);
	rookPoints[0][19] = Point(WINDOW_WIDTH / 4, 13 * WINDOW_WIDTH / 16);

	const Point* ppt[1] = { rookPoints[0] };
	int npt[] = { 20 };

	fillPoly(img,
		ppt,
		npt,
		1,
		Scalar(255, 255, 255),
		lineType);
}


//-----------------------------------【DrawLine( )函数】--------------------------
//		描述：自定义的绘制函数，实现了线的绘制
//---------------------------------------------------------------------------------
void DrawLine(Mat img, Point start, Point end)
{
	int thickness = 2;
	int lineType = 8;
	line(img,
		start,
		end,
		Scalar(0, 0, 0),
		thickness,
		lineType);
}

标签：Mat,WIDTH,int,void,编程,Point,读书笔记,OpenCV3,WINDOW
来源： https://www.cnblogs.com/waydmt/p/15618094.html