利用Opencv实现画实习圆及正六边形

最新推荐文章于 2022-05-24 00:00:00 发布
最新推荐文章于 2022-05-24 00:00:00 发布
阅读量814 收藏
点赞数
分类专栏： Opencv C++ 画多边形及圆 文章标签： Opencv 画圆及正六边形
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Frank0216/article/details/89419024
版权 
#include<opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include<vector>
#include <iostream>
#include <cmath>

#define R 5
#define Length 15
#define Higth 50


using namespace std;
using namespace cv;

int main()
{
	Mat src(640, 480, CV_8UC3);
	src.setTo(0);

	//第一行，红色行
	vector<Point > contour;
	contour.reserve(6);
	contour.push_back(Point(Length, Higth));
	contour.push_back(Point(Length / 2, (Higth + Length / 2 * sqrt(3))));
	contour.push_back(Point(Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour.push_back(Point(2 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour.push_back(Point(5 * Length / 2, (Higth + (Length / 2 * sqrt(3)))));
	contour.push_back(Point(2 * Length, Higth));

	vector<std::vector<cv::Point >> contours;
	contours.push_back(contour);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(Length + Length / 2, (Higth + (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour1;
	contour1.reserve(6);
	contour1.push_back(Point(Length + 3 * Length, Higth));
	contour1.push_back(Point(Length / 2 + 3 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour1.push_back(Point(Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour1.push_back(Point(2 * Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour1.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour1.push_back(Point(2 * Length + 3 * Length, Higth));

	vector<std::vector<cv::Point >> contours1;
	contours1.push_back(contour1);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours1, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours1, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(5 * Length / 2 + 2 * Length, (Higth + (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour2;
	contour2.reserve(6);
	contour2.push_back(Point(Length + 6 * Length, Higth));
	contour2.push_back(Point(Length / 2 + 6 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour2.push_back(Point(Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour2.push_back(Point(2 * Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour2.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour2.push_back(Point(2 * Length + 6 * Length, Higth));

	vector<std::vector<cv::Point >> contours2;
	contours2.push_back(contour2);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours2, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours2, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(5 * Length / 2 + 5 * Length, (Higth + (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour3;
	contour3.reserve(6);
	contour3.push_back(Point(Length + 9 * Length, Higth));
	contour3.push_back(Point(Length / 2 + 9 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour3.push_back(Point(Length + 9 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour3.push_back(Point(2 * Length + 9 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour3.push_back(Point(5 * Length / 2 + 9 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour3.push_back(Point(2 * Length + 9 * Length, Higth));

	vector<std::vector<cv::Point >> contours3;
	contours3.push_back(contour3);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours3, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours3, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(5 * Length / 2 + 8 * Length, (Higth + (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);


	//第二行，绿色行
	vector<Point > contour01;
	contour01.reserve(6);
	contour01.push_back(Point(5 * Length / 2, (Higth + (Length / 2 * sqrt(3)))));
	contour01.push_back(Point(2 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour01.push_back(Point(5 * Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour01.push_back(Point(7 * Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour01.push_back(Point(4 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour01.push_back(Point(7 * Length / 2, (Higth + (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours01;
	contours01.push_back(contour01);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours01, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours01, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour02;
	contour02.reserve(6);
	contour02.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour02.push_back(Point(2 * Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour02.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour02.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour02.push_back(Point(4 * Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour02.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours02;
	contours02.push_back(contour02);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours02, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours02, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour03;
	contour03.reserve(6);
	contour03.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + (Length / 2 * sqrt(3)))));
	contour03.push_back(Point(2 * Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour03.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour03.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour03.push_back(Point(4 * Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour03.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours03;
	contours03.push_back(contour03);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours03, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours03, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第三行，蓝色行
	vector<Point > contour001;
	contour001.reserve(6);
	contour001.push_back(Point(Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour001.push_back(Point(Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour001.push_back(Point(Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour001.push_back(Point(2 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour001.push_back(Point(5 * Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour001.push_back(Point(2 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours001;
	contours001.push_back(contour001);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours001, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours001, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour002;
	contour002.reserve(6);
	contour002.push_back(Point(Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour002.push_back(Point(Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour002.push_back(Point(Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour002.push_back(Point(2 * Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour002.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour002.push_back(Point(2 * Length + 3 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours002;
	contours002.push_back(contour002);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours002, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours002, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour003;
	contour003.reserve(6);
	contour003.push_back(Point(Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour003.push_back(Point(Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour003.push_back(Point(Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour003.push_back(Point(2 * Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour003.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour003.push_back(Point(2 * Length + 6 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours003;
	contours003.push_back(contour003);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours003, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours003, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour004;
	contour004.reserve(6);
	contour004.push_back(Point(Length + 9 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));
	contour004.push_back(Point(Length / 2 + 9 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour004.push_back(Point(Length + 9 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour004.push_back(Point(2 * Length + 9 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour004.push_back(Point(5 * Length / 2 + 9 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour004.push_back(Point(2 * Length + 9 * Length, (Higth + 2 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours004;
	contours004.push_back(contour004);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours004, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours004, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 9 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第四行，红色行
	vector<Point > contour5;
	contour5.reserve(6);
	contour5.push_back(Point(5 * Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour5.push_back(Point(2 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour5.push_back(Point(5 * Length / 2, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour5.push_back(Point(7 * Length / 2, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour5.push_back(Point(4 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour5.push_back(Point(7 * Length / 2, (Higth + 3 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours5;
	contours5.push_back(contour5);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours5, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours5, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour6;
	contour6.reserve(6);
	contour6.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour6.push_back(Point(2 * Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour6.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour6.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour6.push_back(Point(4 * Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour6.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours6;
	contours6.push_back(contour6);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours6, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours6, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour7;
	contour7.reserve(6);
	contour7.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));
	contour7.push_back(Point(2 * Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour7.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour7.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour7.push_back(Point(4 * Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour7.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 3 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours7;
	contours7.push_back(contour7);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours7, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours7, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第五行，绿色行
	vector<Point > contour04;
	contour04.reserve(6);
	contour04.push_back(Point(Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour04.push_back(Point(Length / 2, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour04.push_back(Point(Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour04.push_back(Point(2 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour04.push_back(Point(5 * Length / 2, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour04.push_back(Point(2 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours04;
	contours04.push_back(contour04);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours04, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours04, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 , (Higth + 5 *(Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour05;
	contour05.reserve(6);
	contour05.push_back(Point(Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour05.push_back(Point(Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour05.push_back(Point(Length + 3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour05.push_back(Point(2 * Length + 3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour05.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour05.push_back(Point(2 * Length + 3 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours05;
	contours05.push_back(contour05);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours05, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours05, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour06;
	contour06.reserve(6);
	contour06.push_back(Point(Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour06.push_back(Point(Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour06.push_back(Point(Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour06.push_back(Point(2 * Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour06.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour06.push_back(Point(2 * Length + 6 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours06;
	contours06.push_back(contour06);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours06, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours06, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour07;
	contour07.reserve(6);
	contour07.push_back(Point(Length + 9 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));
	contour07.push_back(Point(Length / 2 + 9 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour07.push_back(Point(Length + 9 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour07.push_back(Point(2 * Length + 9 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour07.push_back(Point(5 * Length / 2 + 9 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour07.push_back(Point(2 * Length + 9 * Length, (Higth + 4 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours07;
	contours07.push_back(contour07);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours07, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours07, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 9 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第六行，蓝色行
	vector<Point > contour005;
	contour005.reserve(6);
	contour005.push_back(Point(5 * Length / 2, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour005.push_back(Point(2 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour005.push_back(Point(5 * Length / 2, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour005.push_back(Point(7 * Length / 2, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour005.push_back(Point(4 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour005.push_back(Point(7 * Length / 2, (Higth + 5 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours005;
	contours005.push_back(contour005);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours005, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours005, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour006;
	contour006.reserve(6);
	contour006.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour006.push_back(Point(2 * Length + 3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour006.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour006.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour006.push_back(Point(4 * Length + 3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour006.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours006;
	contours006.push_back(contour006);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours006, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours006, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length+3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour007;
	contour007.reserve(6);
	contour007.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));
	contour007.push_back(Point(2 * Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour007.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour007.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour007.push_back(Point(4 * Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour007.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 5 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours007;
	contours007.push_back(contour007);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours007, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours007, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第七行，红色行
	vector<Point > contour8;
	contour8.reserve(6);
	contour8.push_back(Point(Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour8.push_back(Point(Length / 2, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour8.push_back(Point(Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour8.push_back(Point(2 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour8.push_back(Point(5 * Length / 2, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour8.push_back(Point(2 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours8;
	contours8.push_back(contour8);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours8, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours8, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length /2, (Higth + 7 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);
	
	vector<Point > contour9;
	contour9.reserve(6);
	contour9.push_back(Point(Length + 3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour9.push_back(Point(Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour9.push_back(Point(Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour9.push_back(Point(2 * Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour9.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour9.push_back(Point(2 * Length + 3 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours9;
	contours9.push_back(contour9);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours9, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours9, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour10;
	contour10.reserve(6);
	contour10.push_back(Point(Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour10.push_back(Point(Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour10.push_back(Point(Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour10.push_back(Point(2 * Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour10.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour10.push_back(Point(2 * Length + 6 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours10;
	contours10.push_back(contour10);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours10, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours10, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour11;
	contour11.reserve(6);
	contour11.push_back(Point(Length + 9 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));
	contour11.push_back(Point(Length / 2 + 9 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour11.push_back(Point(Length + 9 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour11.push_back(Point(2 * Length + 9 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour11.push_back(Point(5 * Length / 2 + 9 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour11.push_back(Point(2 * Length + 9 * Length, (Higth + 6 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours11;
	contours11.push_back(contour11);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours11, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours11, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 9 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第八行，绿色行
	vector<Point > contour08;
	contour08.reserve(6);
	contour08.push_back(Point(5 * Length / 2, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour08.push_back(Point(2 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour08.push_back(Point(5 * Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour08.push_back(Point(7 * Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour08.push_back(Point(4 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour08.push_back(Point(7 * Length / 2, (Higth + 7 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours08;
	contours08.push_back(contour08);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours08, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours08, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length , (Higth + 8 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour09;
	contour09.reserve(6);
	contour09.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour09.push_back(Point(2 * Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour09.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour09.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour09.push_back(Point(4 * Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour09.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours09;
	contours09.push_back(contour09);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours09, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours09, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour010;
	contour010.reserve(6);
	contour010.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));
	contour010.push_back(Point(2 * Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour010.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour010.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour010.push_back(Point(4 * Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour010.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 7 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours010;
	contours010.push_back(contour010);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours010, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours010, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第九行，蓝色行
	vector<Point > contour008;
	contour008.reserve(6);
	contour008.push_back(Point(Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour008.push_back(Point(Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour008.push_back(Point(Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour008.push_back(Point(2 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour008.push_back(Point(5 * Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour008.push_back(Point(2 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours008;
	contours008.push_back(contour008);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours008, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours008, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour009;
	contour009.reserve(6);
	contour009.push_back(Point(Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour009.push_back(Point(Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour009.push_back(Point(Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour009.push_back(Point(2 * Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour009.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour009.push_back(Point(2 * Length + 3 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours009;
	contours009.push_back(contour009);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours009, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours009, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour0010;
	contour0010.reserve(6);
	contour0010.push_back(Point(Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour0010.push_back(Point(Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour0010.push_back(Point(Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour0010.push_back(Point(2 * Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour0010.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour0010.push_back(Point(2 * Length + 6 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours0010;
	contours0010.push_back(contour0010);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours0010, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours0010, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour0011;
	contour0011.reserve(6);
	contour0011.push_back(Point(Length + 9 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));
	contour0011.push_back(Point(Length / 2 + 9 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour0011.push_back(Point(Length + 9 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour0011.push_back(Point(2 * Length + 9 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour0011.push_back(Point(5 * Length / 2 + 9 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour0011.push_back(Point(2 * Length + 9 * Length, (Higth + 8 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours0011;
	contours0011.push_back(contour0011);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours0011, true, Scalar(255, 0, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours0011, Scalar(255, 0, 0));//fillPoly函数的第二个参数是二维数组！！


	circle(src, Point(3 * Length / 2 + 9 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第十行，红色行
	vector<Point > contour12;
	contour12.reserve(6);
	contour12.push_back(Point(5 * Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour12.push_back(Point(2 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour12.push_back(Point(5 * Length / 2, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour12.push_back(Point(7 * Length / 2, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour12.push_back(Point(4 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour12.push_back(Point(7 * Length / 2, (Higth + 9 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours12;
	contours12.push_back(contour12);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours12, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours12, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour13;
	contour13.reserve(6);
	contour13.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour13.push_back(Point(2 * Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour13.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour13.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour13.push_back(Point(4 * Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour13.push_back(Point(7 * Length / 2 + 3 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours13;
	contours13.push_back(contour13);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours13, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours13, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！
	
	circle(src, Point(3 * Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour14;
	contour14.reserve(6);
	contour14.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));
	contour14.push_back(Point(2 * Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour14.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour14.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour14.push_back(Point(4 * Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour14.push_back(Point(7 * Length / 2 + 6 * Length, (Higth + 9 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours14;
	contours14.push_back(contour14);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours14, true, Scalar(0, 0, 255), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours14, Scalar(0, 0, 255));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	//第十一行，绿色行
	vector<Point> contour011;
	contour011.reserve(6);
	contour011.push_back(Point(Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour011.push_back(Point(Length / 2, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour011.push_back(Point(Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour011.push_back(Point(2 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour011.push_back(Point(5 * Length / 2, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour011.push_back(Point(2 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours011;
	contours011.push_back(contour011);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours011, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours011, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2, (Higth + 11 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour012;
	contour012.reserve(6);
	contour012.push_back(Point(Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour012.push_back(Point(Length / 2 + 3 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour012.push_back(Point(Length + 3 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour012.push_back(Point(2 * Length + 3 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour012.push_back(Point(5 * Length / 2 + 3 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour012.push_back(Point(2 * Length + 3 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours012;
	contours012.push_back(contour012);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours012, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours012, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 3 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour013;
	contour013.reserve(6);
	contour013.push_back(Point(Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour013.push_back(Point(Length / 2 + 6 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour013.push_back(Point(Length + 6 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour013.push_back(Point(2 * Length + 6 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour013.push_back(Point(5 * Length / 2 + 6 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour013.push_back(Point(2 * Length + 6 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours013;
	contours013.push_back(contour013);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours013, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours013, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 6 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	vector<Point > contour014;
	contour014.reserve(6);
	contour014.push_back(Point(Length + 9 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));
	contour014.push_back(Point(Length / 2 + 9 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour014.push_back(Point(Length + 9 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour014.push_back(Point(2 * Length + 9 * Length, (Higth + 12 * (Length / 2 * sqrt(3)))));
	contour014.push_back(Point(5 * Length / 2 + 9 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))));
	contour014.push_back(Point(2 * Length + 9 * Length, (Higth + 10 * (Length / 2 * sqrt(3)))));

	vector<std::vector<cv::Point >> contours014;
	contours014.push_back(contour014);
	//填充区域之前，首先采用polylines()函数，可以使填充的区域边缘更光滑
	cv::polylines(src, contours014, true, Scalar(0, 255, 0), 0, 4);//第2个参数可以采用contour或者contours，均可
	cv::fillPoly(src, contours014, Scalar(0, 255, 0));//fillPoly函数的第二个参数是二维数组！！

	circle(src, Point(3 * Length / 2 + 9 * Length, (Higth + 11 * (Length / 2 * sqrt(3)))), R, Scalar(255, 255, 255), -10, 4, 0);

	cv::imshow("原图", src);
	cv::waitKey(0);

	return 0;
}

 

Frank0216
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python画六边形
11-22
通过python中的tkinter库的组件运用可视化窗口画六边形及六边形的旋转，其中可改为画多边形。
opencv中 画六边形
u012719076的博客
04-20 793
转自：http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/point_polygon_test.html#point-polygon-test 已知一个包含顺序点的数组，需要画出六边形 const int r = 100; Mat src = Mat::zeros(Size(4 * r, 4 * r), CV_8UC1); ///..
OpenCV 绘制正多边形
激萌の小宅的博客
10-24 1375
 OpenCV 绘制正多边形 #include &lt;iostream&gt; #include &lt;opencv2\core\core.hpp&gt; #include &lt;opencv2\opencv.hpp&gt; #include &lt;opencv2\highgui\highgui.hpp&gt; #include &lt;opencv2\cont...
一种确定六边形螺栓中心（形心）的Opencv方法——Python实现
xiaohouzi112233的博客
03-21 2338
图像处理方法——六边形求中心点/形心
OpenCV绘制正多边形的方法
08-26
主要为大家详细介绍了OpenCV绘制正多边形的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
利用opencv实现RGB实心多边形及圆
04-20
利用Opencv实现画正六边形及实习圆，利用RGB实现对实习圆及正六边形着色。
Java+opencv3.2.0实现hough圆检测功能
08-28
Java+OpenCV 3.2.0实现霍夫圆检测功能 Java+OpenCV 3.2.0实现霍夫圆检测功能是指使用Java语言结合OpenCV 3.2.0库来实现霍夫圆检测算法的功能。本文将详细介绍霍夫圆检测的原理、实现步骤和示例代码，以便读者更好地...
利用C#版OpenCV实现圆心求取实例代码
01-20
1.OpenCVSharp的下载 可以直接从上面的github上下载源码，自行编译引用； 也可用vs中的nuget包管理器下载； 打开【工具】->【库程序包管理器】->【管理解决方案的NuGet程序包】，在其中搜索Open
基于C++OpenCV实现的直线检测、圆检测.zip
06-13
资源包含文件：设计报告word+源码及可执行exe文件 输入一张彩色图像，要求能够检测出其中的直线、圆。 直线检测——利用 Hough 变换 •构造 Hough 空间 直线检测的 Hough 空间是对直角坐标系下的(x, y)映射到极坐标...
基于opencv利用圆盘靶标的相机标定
02-13
本项目基于OpenCV库，利用圆盘靶标来执行相机标定过程，适用于对称和非对称圆盘靶标。以下是对这个过程的详细阐述： 首先，我们需要理解相机标定的概念。相机标定是确定相机内在参数（如焦距、主点坐标）以及外在...
如何在Opencv 窗口画多边形 并保存下来
tzm0412的专栏
12-30 1649
#include #include #include static std::vector vctvctPoint;cv::Mat org = cv::Mat(750,1000,CV_8U,cv::Scalar(0)), img = cv::Mat(750, 1000, CV_8UC3, cv::Scalar(255,255,255,255)), tmp;void on_mouse(int eve
opencv绘制多边形
yl
09-17 3292
opencv2.4.4 今天用cvFilllPoly()进行图像的绘制，其中遇到一些参数的问题，个人理解如下： CVAPI(void)  cvFillPoly( CvArr* img, CvPoint** pts, const int* npts,                          int contours, CvScalar color,                
【OpenCV学习】绘制图形其二
user_from_future的博客
05-24 680
绘制图形其二 画多边形 填充多边形 添加文字
OpenCV 学习笔记-day16 正多边形绘制demo
qq_44799835的博客
02-23 3088
OpenCV 学习笔记day16 随机数与随机颜色 day16 随机数与随机颜色 给定边数n，中点坐标Point p；p.a(横坐标),p.b（纵坐标）和中点到顶点的距离d， 来绘制多边形 首先确定多边形每一条边的旋转角度 angle，并转成弧度制，这个角度指的是中点到顶点连线与x轴的夹角 double angle = 360.0 / n / 180.0PI; 找到顶点坐标与旋转角度和中心点坐标的关系（注意第一次的旋转角度为0） for (int i = 0; i < n; i++) { Point
OpenCV图像处理基础——基于C++实现
04-10
OpenCV图像处理基础——基于C++实现版本视频培训课程概况：教程中会讲解到OpenCV的基础知识及使用方法，并基于OpenCV实现基础的图像处理算法；除此之外课程包含如下的内容： 图像颜色空间及类型转换及应用（BGR、YUV、YCrCb颜色空间、人像肤色检测）、图像直方图及其应用（直方图均衡化、色阶及对比度调节）、图像几何变换（平移、翻转、缩放等）、图像滤镜操作（卡通特效、畸变图像、马赛克）、图像滤波处理（人像磨皮、美颜）、图像形态学操作、多尺度及图像金字塔及视频操作处理等。下方的拓扑图给出了课程的章节目录及每一章中各个小节涉及到的主要内容：
OpenCV4学习笔记（40）——FAST特征提取算法与BRIEF特征描述算法
邱小兵的博客
04-08 2935
在上一篇博文《OpenCV4学习笔记（38）》中记录的SIFT算法是一种包含了特征提取和描述的算法，而今天要整理记录的是分别对应于图像特征的提取和描述两个方面的FAST特征提取算法和BRIEF特征描述算法。 FAST特征提取算法 FAST（Features from Accelerated Segment Test-加速段测试特征）特征点提取算法，是一种简单快速的特征提取算法，因为其具有比较...
【OpenCV 4开发详解】轮廓外接多边形
小白学视觉
03-18 2698
本文首发于“小白学视觉”微信公众号，欢迎关注公众号 本文作者为小白，版权归人民邮电出版社发行所有，禁止转载，侵权必究！ 经过几个月的努力，小白终于完成了市面上第一本OpenCV 4入门书籍《OpenCV 4开发详解》。为了更让小伙伴更早的了解最新版的OpenCV 4，小白与出版社沟通，提前在公众号上连载部分内容，请持续关注小白。 由于噪声和光照的影响，物体的轮廓会出现不规则的形状，根据不规...
工业缺陷检测项目实战(一)——基于opencv的工件缺陷检测C++和python实现
热门推荐
weixin_39735688的博客
11-17 2万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
OpenCV学习笔记4-绘制图形和填充多边形(附代码实现)
Aaron的博客
04-02 2890
通过OpenCV绘制图形和填充多边形
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值