C++OpenCV(2):图像处理基础概念与操作

文章首发于我的个人博客:欢迎大佬们来逛逛
OpenCV项目地址及源代码:点击这里

文章目录

  • 图形读取与显示
    • 加载图片
    • 显示图片
    • 打印图片信息
    • 保存图片
  • 色彩模型转换
    • RGB颜色模型
    • HSV颜色模型
    • HLS模型
    • LAB模型
  • 图像像素读写操作
  • 像素算数运算
  • 图形文字绘制
    • 绘制线
    • 绘制圆
    • 绘制矩形
    • 绘制椭圆
    • 绘制文字
    • 其他绘制函数

图形读取与显示

通过 imread 我们可以读取一个图片

其形式如下:

void imshow(const String& winname, InputArray mat);

而我们需要传递一个InputArray类型的参数,实际上就是 cv::Mat

如果创建cv::Mat呢?

可以通过它的很多的构造函数

先来了解一下图片的颜色通道

  • 颜色通道
    • RGB 图像有4 个默认通道:红色、绿色和蓝色各有一个通道,以及一个用于编辑图像复合通道(主通道)
  • 彩色深度
    • 8位色,每个像素所能显示的彩色数为2的8次方,即256种颜色。
    • 16位增强色,16位彩色,每个像素所能显示的彩色数为2的16次方,即65536种颜色。
    • 24位真彩色,每个像素所能显示的彩色数为24位,即2的24次方,约1680万种颜色。
    • 32位真彩色,即在24位真彩色图像的基础上再增加一个表示图像透明度信息的Alpha通道。
      • Alpha通道:一张图片的透明和半透明度

我们使用如下的形式来描述它的通道类型:

CV_<bit_depth>(S|U|F)C<number_of_channels>

其中:

  • bit_depth:位数,就是我们上面讲的彩色深度
  • S|U|F:即 signed ,unsigned int,float 来存储
  • number_of_channels:通道,有单通道,双通道,三通道,和四通道等等

加载图片

Mat类型的结构如下:

class  Mat
{
 
public/*
 		flag: 
 		1.数字签名 
 		2.维度
 		3.通道数
 		4.连续性
 	*/
	int flags;					
	int dims; 					//数据维数
	int rows,cols; 				//数据行列
	uchar *data;				//存储的数据		
    const uchar* datastart;		//数据开始
    const uchar* dataend;		//数据结束
    const uchar* datalimit;		//数据边界
	//其他成员  
 	//.....
 	//其他方法
 	//.....
 public: 		//构造方式
    // 默认构造函数 Mat A;
    Mat ()
    // 常用构造函数 Mat A(10,10,CV_8UC3);
    Mat (int rows, int cols, int type)
    //Mat A(300, 400, CV_8UC3,Scalar(255,255,255));
    Mat (int ndims, const int *sizes, int type, const Scalar &s)
    Mat (Size size, int type)
    Mat (int rows, int cols, int type, const Scalar &s)
    Mat (Size size, int type, const Scalar &s)
    Mat (int ndims, const int *sizes, int type)
    Mat (const Mat &m)
    Mat (int rows, int cols, int type, void *data, size_t step=AUTO_STEP)
    Mat (Size size, int type, void *data, size_t step=AUTO_STEP)
    Mat (int ndims, const int *sizes, int type, void *data, const size_t *steps=0)
    Mat (const Mat &m, const Range &rowRange, const Range &colRange=Range::all())
    //Mat D (A, Rect(10, 10, 100, 100) );
    Mat (const Mat &m, const Rect &roi)
    Mat (const Mat &m, const Range *ranges)
    
};

我们使用如下的几种方式来加载图片:

  • CV_8UC1:单通道
  • Scalar:使用BGR形式
  • clone/copyTo:从另一个Mat拷贝
void testShow() {
	cv::Mat	m1(200, 200, CV_8UC1);
	cv::imshow("1", m1);
	//std::cout << m << '\n';
	cv::Mat m2(200, 200, CV_8UC3, cv::Scalar(255, 0, 255));
	cv::imshow("2", m2);

	cv::Mat m3 = m2.clone();
	cv::imshow("3", m3);

	cv::Mat m4;
	m3.copyTo(m4);	
	cv::imshow("4", m4);

	//imread
	cv::Mat m5 = cv::imread("images/mm.png", cv::ImreadModes::IMREAD_GRAYSCALE);
	cv::imshow("5", m5);
}

显示图片

我们使用函数:imshow

我们已经直到了它的第二个参数是一个类型,用来表示以何种形式显示图片:**cv::ImreadModes**

Mat imread( const String& filename, int flags = IMREAD_COLOR );
/****************************************************************
*				filename: 文件路径
*				flags   : 显示方式
*****************************************************************/
enum ImreadModes {
       IMREAD_UNCHANGED            = -1,	//按原样返回加载的图像(带有alpha通道,否则会被裁剪)
       IMREAD_GRAYSCALE            = 0, 	//单通道灰度图像
       IMREAD_COLOR                = 1, 	//3通道BGR彩色图像 
       IMREAD_ANYDEPTH             = 2, 	//16位/32位图像,其他则转换为8位
       IMREAD_ANYCOLOR             = 4, 	//图像以任何可能的颜色格式读取
       IMREAD_LOAD_GDAL            = 8, 	//gdal驱动程序加载映像
       IMREAD_REDUCED_GRAYSCALE_2  = 16,	//单通道灰度图像,并将图像大小减小1/2 
       IMREAD_REDUCED_COLOR_2      = 17,	//3通道BGR彩色图像,使图像大小减小1/2
       IMREAD_REDUCED_GRAYSCALE_4  = 32,	//单通道灰度图像,并将图像尺寸减小1/4
       IMREAD_REDUCED_COLOR_4      = 33,	//3通道BGR彩色图像,使图像大小减小1/4
       IMREAD_REDUCED_GRAYSCALE_8  = 64,	//单通道灰度图像,并将图像尺寸减小1/8
       IMREAD_REDUCED_COLOR_8      = 65,	//3通道BGR彩色图像,使图像大小减小1/8
       IMREAD_IGNORE_ORIENTATION   = 128	//不要根据EXIF的方向标志旋转图像
};

打印图片信息

我们可以打印Mat的信息,因为它实际上就是一个矩阵,我们可以采用多种形式来格式化输出

  • C语言形式
  • numpy形式
  • python形式

….

void testPrint() {
	cv::Mat m(10, 10, CV_8UC1);
	std::cout << "Mat: \n"<<m << '\n';
	//格式化
	std::cout << "C: \n" << cv::format(m, cv::Formatter::FMT_C);
	std::cout << "numpy: \n" << cv::format(m, cv::Formatter::FMT_NUMPY);
}

保存图片

使用函数: imwrite

第一个参数为保存的图片的路径,第二个参数为保存的图片。

其中路径我们可以使用 cv::String 来传递,就是个字符串。

void testSaveFile(cv::String filename) {
	auto m = cv::imread("./images/dog.png" ,cv::ImreadModes::IMREAD_GRAYSCALE);	
	cv::imshow("dog", m);
	cv::imwrite(filename, m);
}

色彩模型转换

什么是色彩模型?

颜色模型指的是某个三维颜色空间中的一个可见光子集,它包含某个色彩域的所有色彩。一般而言,任何一个色彩域都只是可见光的子集,任何一个颜色模型都无法包含所有的可见光(通俗一点讲就是表示颜色的一种方式

RGB颜色模型

在计算机体系中,最常见的色彩模型就是**RGB颜色**模型。

它具有三维坐标的模型形式:

C++OpenCV(2):图像处理基础概念与操作_第1张图片


  • RGB16:每个像素用16个比特位表示,占2个字节
    • RGB565:RGB分量分别使用5位、6位、5位:

C++OpenCV(2):图像处理基础概念与操作_第2张图片

  • RGB555:RGB分量分别使用5位、5位、5位:

C++OpenCV(2):图像处理基础概念与操作_第3张图片
对于RGB555,如何获取各个5位上的值,即分别获取 R,G,B所代表的值?
通过位运算即可获取。

   /*
   RGB 颜色模型
   */
   struct XColor {
   	unsigned int color : 15;
   };
   void getRGB555() {
   	XColor col{};
   	col.color = 0b110000010111100;
   	std::cout << "R: " << (col.color >> 10) << '\n';
   	std::cout << "G: " << ((col.color & 0x3F0) >> 5) << '\n';
   	std::cout << "B: " << (col.color & 0x1F) << '\n';
   }
  • RGB24格式:每个像素用24比特位表示,占3个字节,在内存中RGB各排列顺序为:BGR:

C++OpenCV(2):图像处理基础概念与操作_第4张图片

  • RGB32格式:每个像素用32比特位表示,占4个字节,R,G,B分量分别用8个bit表示,存储顺序为B,G,R,最后8个字节保留

    • ARGB32:本质就是带alpha通道的RGB24,与RGB32的区别在与,保留的8个bit用来表示透明,也就是alpha的值

    C++OpenCV(2):图像处理基础概念与操作_第5张图片

    • 对于**RGB32**,如何获取各个8位上的值,即分别获取 R,G,B,Alpha所代表的值?

      • 通过位运算即可获取。
      void getRGB32() {
      	int color = 0x0F0A2B0C;
      	std::cout << "B: " << (color >> 24) << '\n';
      	std::cout << "G: " << ((color & 0x00FF0000) >> 16) << '\n';
      	std::cout << "R: " << ((color & 0x0000FF00) >> 8) << '\n';
      	std::cout << "Alpha: " << (color & 0x000000FF) << '\n';
      }
      

HSV颜色模型

HSV(Hue, Saturation,Value)也被称为六角锥体模型,即色调,饱和度,明度

C++OpenCV(2):图像处理基础概念与操作_第6张图片

将RGB转换为HSV模型:

  • **cvtColor**函数:将图像从一种颜色模型转换为另一个。
  • 起到关键作用的是第三个参数:cv::ColorConversionCodes 是一个枚举,表示了你想要从谁转换到谁,这里我们让BGR形式转换为HSV形式。
cv::Mat res;
cv::cvtColor(m1, res, cv::ColorConversionCodes::COLOR_BGR2HSV);
cv::imshow("hsv", res);

C++OpenCV(2):图像处理基础概念与操作_第7张图片

C++OpenCV(2):图像处理基础概念与操作_第8张图片


HLS模型

HLS模型分别是色调,亮度,饱和度

C++OpenCV(2):图像处理基础概念与操作_第9张图片

上图可以看出,固定一个颜色(H),那么随着饱和度(S,Chroma)的增加,颜色越来越深。

cv::cvtColor(m1, res, cv::ColorConversionCodes::COLOR_BGR2HLS);
cv::imshow("hls", res);

C++OpenCV(2):图像处理基础概念与操作_第10张图片

C++OpenCV(2):图像处理基础概念与操作_第11张图片


LAB模型

Lab颜色模型由三个要素组成,一个要素是**亮度**(L),a 和b是两个颜色通道。

  • **a**包括的颜色是从深绿色(低亮度值)到灰色(中亮度值)再到亮粉红色(高亮度值)
  • **b**是从亮蓝色(低亮度值)到灰色(中亮度值)再到黄色(高亮度值)。
  • 因此,这种颜色混合后将产生具有明亮效果的色彩。
    C++OpenCV(2):图像处理基础概念与操作_第12张图片
cv::cvtColor(m1, res, cv::ColorConversionCodes::COLOR_BGR2Lab);
cv::imshow("Lab", res);

C++OpenCV(2):图像处理基础概念与操作_第13张图片

C++OpenCV(2):图像处理基础概念与操作_第14张图片

还有很多的颜色模型都可以在 cvtColor这个函数中找到。


图像像素读写操作

openCV基本类型介绍:

  • 基本类型:
typedef unsigned uint;
typedef signed char schar;
typedef unsigned char uchar;
typedef unsigned short ushort;
  • 封装类型:Vec类似于std::vector,只不过可以指定其大小,并且命名规则为 cv:: Vec大小+ 类型
typedef Vec<uchar, 2> Vec2b;
typedef Vec<uchar, 3> Vec3b;
typedef Vec<uchar, 4> Vec4b;

typedef Vec<short, 2> Vec2s;
typedef Vec<short, 3> Vec3s;
typedef Vec<short, 4> Vec4s;

typedef Vec<ushort, 2> Vec2w;
typedef Vec<ushort, 3> Vec3w;
typedef Vec<ushort, 4> Vec4w;

typedef Vec<int, 2> Vec2i;
typedef Vec<int, 3> Vec3i;
typedef Vec<int, 4> Vec4i;
typedef Vec<int, 6> Vec6i;
typedef Vec<int, 8> Vec8i;

图像是由像素掉构成的,因此我们可以获取图像的每一个像素,这个像素是由(i,j)确定的,即在图片宽度与高度的范围下,每一个行的每一列都可以是一个像素。

我们使用 Mat 的 at 函数来获取某个位置的像素值。

注意像素具有channels的区别。

  • 如果是单通道: 则直接获取 uchar 表示一个像素(一字节)。
  • 如果是三通道: 则需要获取Vec3b 表示三个像素,可以通过[0],[1],[2]来分别操作。

以下操作对图片转换为负片,使用 255 - 当前像素值

#include 
#include 

class ImgPixel {
public:
	ImgPixel(std::string filename):m(cv::imread(filename)){}
	void show(std::string title) {
		cv::imshow(title, m);
	}
	void Visit_By_Array() {
		auto dims = m.channels(); //获取通道数
		for (int i = 0; i < m.rows; i++) {
			for (int j = 0; j < m.cols; j++) {
				if (dims == 1) {
					//如果是一通道,则直接操作
					uchar rets = m.at<uchar>(i, j);
					rets = 255 - rets;
				}
				if (dims == 3) {
					cv::Vec3b rets = m.at<cv::Vec3b>(i, j);
#if 0
					m.at<cv::Vec3b>(i, j)[0] = 255 - rets[0]; //转换为负片
					m.at<cv::Vec3b>(i, j)[1] = 255 - rets[1];
					m.at<cv::Vec3b>(i, j)[2] = 255 - rets[2];
#else 
					//安全类型转换: 超过255的赋值为 255 小于0的赋值为 0
					m.at<cv::Vec3b>(i, j)[0] = cv::saturate_cast<uchar>(rets[0] + 100);
					m.at<cv::Vec3b>(i, j)[1] = cv::saturate_cast<uchar>(rets[1] + 100);
					m.at<cv::Vec3b>(i, j)[2] = cv::saturate_cast<uchar>(rets[2] + 100);
#endif
				}
			}
		}
	}
private:
	cv::Mat m;
};
int main(){
	ImgPixel img("dog.png");
	img.show("origin");
	img.Visit_By_Array();
	img.show("convert1");

	cv::waitKey(0);
	return 0;
}

安全类型转换:saturate_cast 是openCV的一种安全转换函数,当我们对像素执行加减乘除的时候,有可能会超出 [ 0 , 255 ] [0,255] [0,255]
的范围,因此使用此函数来保证不会越界。

实际上这个函数就是:

  • 超过255:转为255
  • 小于0:转为0
template<> inline uchar saturate_cast<uchar>(int v)          { return (uchar)((unsigned)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }

像素算数运算

图像可以进行像素之间的算数运算,跟我们上节的对像素的简单减法是一样的:

我们有专门的函数:

  • add:像素加
  • subtract:像素减
  • multiply:像素乘
  • divide:像素除
  • addWeighted:对图片执行: α ⋅ i m g 1 + β ⋅ i m g 2 = r e s \alpha\cdot img_1 + \beta\cdot img_2 = res αimg1+βimg2=res 的操作,其中的 α \alpha α β \beta β就是透明度

除了基本的运算,还有二进制运算

  • and:像素按位与
  • or:按位或
  • **not:**按位取反
  • xor:按位异或

测试如下:

需要两个原图片执行下面的这些操作,我使用的图片是:(注意尺寸要一样)

C++OpenCV(2):图像处理基础概念与操作_第15张图片

然后自行执行下面代码。

C++OpenCV(2):图像处理基础概念与操作_第16张图片

#include 
#include 

class ImgOperation {
public:
	ImgOperation() :m1(cv::imread("dog.png")), m2(cv::imread("text.jpg")) {}
	void testAdd(std::string title="add") {
		cv::add(m1, m2, res);
		cv::imshow(title, res);
		cv::waitKey();
	}
	void testSub(std::string title = "subtract") {
		cv::subtract(m1, m2, res);
		cv::imshow(title, res);
		cv::waitKey();
	}
	void testMul(std::string title = "multiply") {
		cv::multiply(m1, m2, res);
		cv::imshow(title, res);
		cv::waitKey();
	}
	void testDivide(std::string title = "divide") {
		cv::divide(m1, m2, res);
		cv::imshow(title, res);
		cv::waitKey();
	}
	void testAddWeighted(std::string title="AddWeighted") {
		cv::addWeighted(m1, 0.1, m2, 0.9, 0, res);
		cv::imshow(title, res);
		cv::waitKey();
	}
	//BitWise
	void testBitWise() {
		cv::Mat _and, _or, _xor, _not;
		cv::bitwise_and(m1, m2, _and);
		cv::bitwise_or(m1, m2, _or);
		cv::bitwise_xor(m1, m2, _xor);
		cv::bitwise_not(m1, _not);

		cv::imshow("and", _and);
		cv::imshow("or", _or);
		cv::imshow("xor", _xor);
		cv::imshow("not", _not);
	}
private:
	cv::Mat m1;
	cv::Mat m2;
	cv::Mat res;
};

int main()
{
	ImgOperation opt;
	//opt.testAdd();
	//opt.testSub();
	//opt.testMul();
	//opt.testDivide();
	//opt.testAddWeighted();	
	opt.testBitWise();

	cv::waitKey();
	return 0;
}

图形文字绘制

绘制线

使用**line**函数,原型如下:

void line(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,int thickness = 1, int lineType = LINE_8, int shift = 0);
//线的样式
enum LineTypes {
    FILLED  = -1,
    LINE_4  = 4, //!< 4-connected line
    LINE_8  = 8, //!< 8-connected line
    LINE_AA = 16 //!< antialiased line
};
/*******************************************************************
*			img: 			绘制在那个图像上
*			pt1:			起点
*			pt2:			终点
*			color:			颜色
*			thickness:		厚度(宽度) 
*			lineType:		线的样式
*					FILLED: 线填充的
*					LINE_4:	4邻接连接线
*					LINE_8: 8邻接连接线
*					LINE_AA:反锯齿连接线(高斯滤波)
*			shift: 			坐标点小数点位数(可忽略不写)
*********************************************************************/

在执行 imshow的之前,在图片上画一条线:

void testDrawLine() {
		//绘制线
		cv::line(m, cv::Point(0, 0), cv::Point(300, 300), cv::Scalar(0,255,0), 3, cv::LineTypes::LINE_AA);
	}

C++OpenCV(2):图像处理基础概念与操作_第17张图片


绘制圆

使用**circle函数来绘制或者填充圆**

void circle(InputOutputArray img, Point center, int radius,const Scalar& color, int thickness = 1,int lineType = LINE_8, int shift = 0);
//线的样式
enum LineTypes {
    FILLED  = -1,
    LINE_4  = 4, //!< 4-connected line
    LINE_8  = 8, //!< 8-connected line
    LINE_AA = 16 //!< antialiased line
};
/*******************************************************************
*			img: 			绘制在那个图像上
*			center:			圆心坐标
*			radius:			半径
*			color:			颜色
*			thickness:		厚度(宽度)
*								-1: 	填充圆
*								其他值:  空心
*			lineType:		 线的样式
*					FILLED: 线填充的
*					LINE_4:	4邻接连接线
*					LINE_8: 8邻接连接线
*					LINE_AA:反锯齿连接线(高斯滤波)
*			shift: 			坐标点小数点位数(可忽略不写)
*********************************************************************/

效果如下:

  • 填充效果需要把thickness置为-1。
void testDrawCircle() {
		cv::circle(m, cv::Point(150, 150), 50, cv::Scalar(0, 255, 0),-1); //填充圆
		cv::circle(m, cv::Point(150, 150), 52, cv::Scalar(0, 0, 255), 2, 
							cv::LineTypes::LINE_AA); //空心圆
	}

C++OpenCV(2):图像处理基础概念与操作_第18张图片


绘制矩形

使用rectangle函数来绘制矩形。

void rectangle(InputOutputArray img, Rect rec,const Scalar& color, int thickness = 1,int lineType = LINE_8, int shift = 0);
/*******************************************************************
*			img: 			绘制在那个图像上
*			rec:			矩形大小  Rect(x,y,w,h);  
*					x,y:	起始坐标
*					w,h:	宽度和高度
*			color:			颜色
*			thickness:		厚度(宽度)
*								-1: 	填充矩形
*								其他值:  空心矩形
*			lineType:		线的样式
*					FILLED: 线填充的
*					LINE_4:	4邻接连接线
*					LINE_8: 8邻接连接线
*					LINE_AA:反锯齿连接线(高斯滤波)
*			shift: 			坐标点小数点位数(可忽略不写)
*********************************************************************/

效果如下:

void testDrawRectangle() {
		cv::rectangle(m, cv::Rect(0, 0, 50, 50), cv::Scalar(100, 45, 20),-1);
	}

C++OpenCV(2):图像处理基础概念与操作_第19张图片


绘制椭圆

使用ellipse来绘制椭圆:

void ellipse(InputOutputArray img, Point center, Size axes,double angle, double startAngle, double endAngle,
const Scalar& color, int thickness = 1,int lineType = LINE_8, int shift = 0);
/*******************************************************************
*			img: 			绘制在那个图像上
*			center:			椭圆圆心
*			axes:			矩形内置椭圆
*			angle:			倾斜角
*			startAngle:		扩展的弧度 0
*			endAngle:		 扩展的弧度  360
*			color:			颜色
*			thickness:		线宽度
*								-1: 	填充矩形
*								其他值:  空心矩形
*			lineType:		线的样式
*					FILLED: 线填充的
*					LINE_4:	4邻接连接线
*					LINE_8: 8邻接连接线
*					LINE_AA:反锯齿连接线(高斯滤波)
*			shift: 			坐标点小数点位数(可忽略不写)
*********************************************************************/

效果如下:

void testDrawEllipse() {
		cv::ellipse(m, cv::Point(100, 100),cv::Size(20,80),
						180,0,360, cv::Scalar(54, 54, 43));
		cv::ellipse(m, cv::Point(100, 100), cv::Size(20, 80), 
						90, 0, 360, cv::Scalar(54, 54, 43),-1);
	}

C++OpenCV(2):图像处理基础概念与操作_第20张图片


绘制文字

使用**putText来绘制文字,注意不支持中文!!!!!!!!!!!!!**

void putText( InputOutputArray img, const String& text, Point org,int fontFace, double fontScale, Scalar color,int thickness = 1, int lineType = LINE_8,bool bottomLeftOrigin = false );
/*******************************************************************
*			img: 			绘制在那个图像上
*			text:			绘制文字
*			org:			文本框左下角
*			fontFace:		字体
*			fontScale:		缩放
*			color:			颜色
*			thickness		线宽度
*			lineType:		线的样式
*					FILLED: 线填充的
*					LINE_4:	4邻接连接线
*					LINE_8: 8邻接连接线
*					LINE_AA:反锯齿连接线(高斯滤波)
*			bottomLeftOrigin: 		起点位置
*								true:  左上角  反转倒立显示
*								false: 左下角  正常显示
*********************************************************************/
//opencv 不识别汉字
//fontFace: 字体
enum HersheyFonts {
    FONT_HERSHEY_SIMPLEX        = 0, //!< normal size sans-serif font   //灯芯体
    FONT_HERSHEY_PLAIN          = 1, //!< small size sans-serif font
    FONT_HERSHEY_DUPLEX         = 2, //!< normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX)
    FONT_HERSHEY_COMPLEX        = 3, //!< normal size serif font
    FONT_HERSHEY_TRIPLEX        = 4, //!< normal size serif font (more complex than FONT_HERSHEY_COMPLEX)
    FONT_HERSHEY_COMPLEX_SMALL  = 5, //!< smaller version of FONT_HERSHEY_COMPLEX
    FONT_HERSHEY_SCRIPT_SIMPLEX = 6, //!< hand-writing style font
    FONT_HERSHEY_SCRIPT_COMPLEX = 7, //!< more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX
    FONT_ITALIC                 = 16 //!< flag for italic font
};

测试如下:

void testDrawText(const std::string& name) {
		cv::putText(m,
			name,
			cv::Point(10, 200),
			cv::HersheyFonts::FONT_HERSHEY_COMPLEX,
			1.0,
			cv::Scalar(50,50,255),
			2,
			cv::LineTypes::LINE_AA,
			false); //翻转
	}

C++OpenCV(2):图像处理基础概念与操作_第21张图片


其他绘制函数

绘制多边形线:

  • polylines

绘制填充多边形:

  • fillPoly

文本参考

百度百科_全球领先的中文百科全书

你可能感兴趣的:(OpenCV,c++,opencv,图像处理)