opencv实现三重点_2018-10-25【机器视觉笔录】OpenCV中的API及用法

最新推荐文章于 2022-09-24 19:45:46 发布

君羽鹅绒

最新推荐文章于 2022-09-24 19:45:46 发布

阅读量169

点赞数

文章标签： opencv实现三重点

本文链接：https://blog.csdn.net/weixin_30979383/article/details/112871542

版权

--------------------------------

Author ： ShawnDong

updateDate ：2018.11.25

Blog ： ShawnDong98.github.io

--------------------------------

C++部分

图像的加载显示与保存

加载图像(cv::imread)

imread加载图像文件成为一个Mat对象，第一个参数表示图像名称

第二个参数表示加载的图像是什么类型，支持常见的三个参数值

IMREAD_UNCHANGED(<0)表示加载原图，不做任何改变

IMREAD_GARYSACLE(0)表示把原图作为灰度图像加载进来

IMREAD_COLOR(>0)表示把原图作为RGB图像加载进来

ps：OpenCV支持JPG，PNG， TIFF等常见格式图像文件加载

显示图像(cv::nameWindows与cv::imshow)

nameWindows功能是创建一个OpenCV窗口，它是由OpenCV自动创建与释放，你无需去销毁它

常见用法nameWindow("Window Title", WINDOW_AUTOSIZE)

WINDOW_AUTOSIZE会自动根据图像大小，显示窗口大小，不能人为改变窗口大小

WiINDOW_NORMAL, 跟QT集成的时候会使用，允许修改窗口大小

imshow根据窗口名称显示图像到指定的窗口上去，第一个参数是窗口名称，第二参数是Mat对象

保存图像(cv::imwrite)

保存图像文件到指定目录路径

只有8位，16位的PNG、JPG、Tiff文件格式而且是单通道或者三通道的BGR的图像才可以通过这种方式保存

保存PNG格式的时候可以保存透明通道的图片

可以指定压缩参数

矩阵的掩膜操作

获取图像指针

CV_Assert(myImage.depth()==CV_8U);

Mat.ptr(int i=0)获取像素矩阵的指针，索引i表示第几行，从0开始计行数

获得当前行指针const uchar* current = myImage.ptr(row);

获取当前像素点P(row, col)的像素值p(row, col) = current[col]

像素范围处理

saturate_cast(-100), 返回0.

saturate_cast(288), 返回255.

saturate_cast(100), 返回100.

这个函数的功能是确保RGB值的范围在0~255之间

掩膜操作实现图像对比度调整

红色是中心像素，从上到下，从左到右对每个像素做同样的处理操作，得到最终结果就是对比度提高之后的输出图像Mat对象

根据掩膜来重新计算每个像素的像素值，掩膜(mask, 也被称为Kernel)

ps: 感觉和卷积很相似

代码实现：

int cols = (src.cols - 1) * src.channels();

int offsetx = src.channels();

int rows = src.rows;

dst = Mat::zeros(src.size(), src.type());

for (int row = 1; row < (rows - 1); row++)

{

const uchar* previous = src.ptr(row - 1);

const uchar* current = src.ptr(row);

const uchar* next = src.ptr(row + 1);

uchar* output = dst.ptr(row);

for (int col = offsetx; col < cols; col++)

{

output[col] = saturate_cast(5 * current[col] - (current[col - offsetx]

+ current[col + offsetx] + previous[col] + next[col]));

}

函数调用filer2D功能

定义掩膜：Mat kernel = (Mat_(3, 3)<<0, -1, 0, -1, 5, -1, 0, -1, 0);

filter2D(src, dst, src.depth(), kernel);其中src与dst是Mat类型变量，src.depth表示位图深度，有32， 24， 8等。

代码实现：可以实现和上面代码同样的功能

double t;

t = (double)getTickCount();

filter2D(src, dst, src.depth(), kernel);

t = ((double)getTickCount() - t) / getTickFrequency();

cout << "Built in Filter2D time passed in seconds" << t << endl;

Mat对象

Mat对象与IplImage对象

Mat对象OpenCV2.0后引进的图像数据结构、自动分配内存，不存在内存泄漏的问题，是面向对象的数据结构。分了两个部分，头部与数据部分

IplImage是从2001年OpenCV发布之后就一直存在，是C语言风格的数据结构，需要开发者自己分类和管理内存，对大的程序使用它容易导致内存泄漏问题

Mat对象构造函数与常用方法

构造函数：

Mat()

Mat(int rows, int cols, int type)

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(int ndims, const int *szie, int type, const Scalar &s)

常用方法：

void copyTo(Mat mat)

void convertTo(Mat dst, int type)

Mat clone()

int channels()

int depth()

bool empty()

uchar* ptr(i=0)

Mat对象使用

部分复制：一般情况下只会复制Mat对象的头和指针部分，不会复制数据部分

Mat A = imread(imgFilePath);

Mat B(A) //只复制

完全复制：如果想把Mat对象的头部和数据部分一起复制，可以通过以下两个API实现

Mat F = A.clone();

Mat G;

A.copyTo(G)

Mat对象使用的四个要点

输出图像的内存是自动分配的

使用OpenCV的C++接口，不需要考虑内存分配问题

赋值操作和拷贝构造函数只会复制头部分

使用clone与copyTo两个函数实现数据完全复制

Mat对象创建

cv::Mat::Mat构造函数

Mat M(2, 2, CV_8UC3, Scalar(0, 0, 255))

其中前两个参数分别表示行(row)跟列(column)、第三个CV_8UC3中的8表示每个通道占8位、 U表示无符号,

C表示char类型，3表示通道数目是3，第四个参数是向量表示初始化每个像素值是多少，向量长度对应通道

数目一致

创建多维数组cv::Mat::create

int sz[3] = [2, 2, 2];

Mat L(3, sz, CV_8UC1, Scalar::all(0));

cv::Mat::create实现

Mat M;

M.create(4, 3, CV_8UC2);

M = Scalar(127, 127);

定义小数组

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

cout << "C = " << endl << C << endl << endl;

图像操作

读写图像

读写像素

修改像素值

灰度图像

cvtColor(src, gray_src, CV_BGR2GRAY);

int height = gray_src.rows;

int width = gray_src.cols;

for(int row = 0; row < height; row++)

{

for (int col = 0; col < width; col++)

{

int gray = gray_src.at(row, col);

gray_src.at(row, col) = 255 - gray;

}

RGB三通道图像

for (int row = 0; row < height; row++)

{

for (int col = 0; col < width; col++)

{

if (nc == 1)

{

int gray = gray_src.at(row, col);

gray_src.at(row, col) = 255 - gray;

}

else if (nc == 3)

{

int b = src.at(row, col)[0];

int g = src.at(row, col)[1];

int r = src.at(row, col)[2];

dst.at(row, col)[0] = 255 - b;

dst.at(row, col)[1] = 255 - g;

dst.at(row, col)[2] = 255 - r;

}

其实以上代码和 bitwise_not(src. dst) 这个api效果是一样的

空白图像赋值

ROI选择

Vec3b与Vec3F

Vec3b对应三通道的顺序是blue、green、 red的uchar类型数据

Vec3f对应三通道的float类型数据

把CV_8UC1转换到CV32F1实现如下：

src.convertTo(dst, CV_32F);

图像混合

理论-线性混合操作

相关API

均值模糊

blur(Mat src, Mat dst, Size(xradius, yradius), Point(-1, -1));

高斯模糊

GaussianBlur(Mat src, Mat dst, Size(11, 11), sigmax, sigmay);

其中Size(x, y), x, y必须为正数而且是奇数

模糊操作二

中值滤波

统计排序滤波器

中值对椒盐噪声有很好的抑制作用(巡线时可以用到)

双边滤波(高斯双边滤波)

均值模糊无法克服边缘像素信息丢失缺陷。原因是均值滤波是基于平均权重。

高斯模糊部分克服了该缺陷，但是无法完全避免，因为没有考虑像素值的不同

高斯双边模糊-是边缘保留的滤波方法，避免了边缘信息丢失，保留了图像轮廓不变

相关API

中值模糊medianBlur(Mat src, Mat dst, ksize)

中值模糊的ksize大小必须是大于1而且必须是奇数

双边模糊bilateraFilter(src, dst, d=15, 150, 3);

15计算的半径，半径之内的像素会被纳入计算，如果提供-1则根据sigma space参数取值

150 - sigma color决定多少之内的像素会被计算

3 - sigma space如果d的值大于0则声明无效，否则根据它来计算d值

膨胀与腐蚀

形态学操作(morphology operators)

图像形态学操作-基于形状的一系列图像处理操作的合集，主要是基于集合论基础上的形态学数学

形态学有四个基本操作：腐蚀、膨胀、开、闭

膨胀与腐蚀是图像处理中最常用的形态学操作手段

形态学操作-膨胀

跟卷积操作类似，假设有图像A和结构元素B，结构元素B在A上面移动，其中B定义其中心为锚点，计算B覆盖下A的最大像素值用来替换锚点的像素，其中B作为结构体可以是任意形状

形态学操作-腐蚀

腐蚀跟膨胀操作的过程类似，唯一不同的是以最小值替换锚点重叠下图像的像素值

相关API

getStucturingElement(int shape, Size ksize, Point anchor)

形状(MORPH_RECT\MORPH_CROSS\MORPH_ELLIPSE)

大小

锚点默认是Point(-1, -1)意思就是中心像素

dilate(src, dst, kernel)

erode(src, dst, kernel)

代码演示：

void CallBack_Demo(int, void*)

{

int s = element_size * 2 + 1;

Mat structureElement = getStructuringElement(MORPH_RECT, Size(s, s), Point(-1, -1));

//dilate(src, dst, structureElement, Point(-1, -1), 1);

erode(src, dst, structureElement, Point(-1, -1));

imshow(OUTPUT_WIN, dst);

}

动态调整结构元素大小

TrackBar-createTrackbar(const String &trackbarname, const String winName, int* value, int count, Trackbarcallback func, void* userdata=0)

其中最重要的是callback函数功能。如果设置为NULL就是说只有值update，但是不会调用callback的函数。

代码演示：

createTrackbar("Element Size:", OUTPUT_WIN, &element_size, max_size, CallBack_Demo);

形态学操作

开操作-open

先腐蚀后膨胀

可以去掉小的对象，假设对象是前景色，背景是黑色

闭操作-close

先膨胀后腐蚀(bin2)

可以填充小的洞(fill hole), 假设对象是前景色，背景是黑色

总结：闭操作用于去掉小黑点，开操作用于去掉小白点

形态学梯度-Morphological Gradient

膨胀减去腐蚀

又称为基本梯度(其他还包括内部梯度(原图减去腐蚀)、方向梯度(在x和y方向进行一个梯度的计算))

顶帽-top hat

顶帽是原图像与开操作(先腐蚀后膨胀)之间的差值图像

黑帽-black hat

黑帽是闭操作(先膨胀后腐蚀)与原图像之间的差值图像

相关API

morphologyEx(src, dst, CV_MOP_BLACKHAT,kernel);

Mat src - 输入图像

Mat dst - 输出结果

int OPT-CV_MOP_OPEN/CV_MOP_CLOSE/CV_MOP_GRADIENT/CV_MOP_TOPHAT/CV_MOP_BLACKHAT形态学操作类型

Mat kernel 结构元素

int Iteration 迭代次数，默认是1

代码示例：

namedWindow(OUTPUT_WIN, CV_WINDOW_AUTOSIZE);

Mat kernel = getStructuringElement(MORPH_RECT, Size(11, 11), Point(-1, -1));

morphologyEx(src, dst,CV_MOP_CLOSE, kernel, Point(-1, -1));

imshow(OUTPUT_WIN, dst);

形态学操作应用-提取水平和垂直直线

原理方法

图像形态学操作时候，可以通过自定义的结构元素实现结构元素对输入图像一些对象敏感、另外一些对象不敏感，这样就会让敏感的对象改变而不敏感的对象保留输出。通过使用两个最基本的形态学操作-膨胀与腐蚀，使用不同的结构元素实现对输入图像的操作，得到想要的结果。

膨胀，输出的像素值是结构元素覆盖下图像的最大像素值

腐蚀，输出的像素值是结构元素覆盖下图像的最小像素值

结构元素

上述膨胀与腐蚀过程可以使用任意的结构元素

常见的形状：矩形、圆、直线、磁盘形状、砖石形状等各种自定义形状

提取步骤

输入图像彩色图像imread

转换为灰度图像-cvtColor

转换为二值图像-adaptiveThreshold

定义结构元素

开操作(腐蚀+膨胀)提取水平与垂直线

转换为二值图像-adaptiveThreshold

adativeThreshold(

Mat src, //输入的灰度图像

Mat dst, //二值图像

double maxValue, //二值图像最大值

int adaptiveMethod, //自适应方法，只能其中之一

//ADAPTIVE_THRESH_MEAN_C, ADAPTIVE_THRESH_GAUSSIAN_C

int thresholdType, //阈值类型

int blocksize, //块大小

double C //常量C 可以是正数， 0，负数

)

注意：自适应阈值二值化的方式通过计算每个像素周围bxb大小像素块的加权均值并减去常量C得到，如果图片像素比较高，像素块又比较小，有可能会出现二值不好的情况，比如这样，黑色的部分被二值成了白色。

代码实现：

void Binarry_Line()

{

Mat gray_src;

cvtColor(src, gray_src, CV_BGR2GRAY);

namedWindow("gray_image", CV_WINDOW_NORMAL);

cvResizeWindow("gray_image", 500, 500);

imshow("gray_image", gray_src);

Mat binImg;

threshold(gray_src, binImg, 80, 255, THRESH_BINARY_INV);

//adaptiveThreshold(gray_src, binImg, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 101, -2);

namedWindow("binarry image", CV_WINDOW_NORMAL);

cvResizeWindow("binarry image", 500, 500);

imshow("binarry image", binImg);

Mat hline = getStructuringElement(MORPH_RECT, Size(src.cols / 16, 1), Point(-1, -1));

Mat vline = getStructuringElement(MORPH_RECT, Size(1, src.rows / 16), Point(-1, -1));

Mat temp;

erode(binImg, temp, hline);

dilate(temp, dst, hline);

namedWindow("final image", CV_WINDOW_NORMAL);

cvResizeWindow("final image", 500, 500);

imshow("final image", dst);

//createTrackbar("Element Size:", OUTPUT_WIN, &element_size, max_size, CallBack_Demo);

//CallBack_Demo(0, 0);

}

图像上采样和降采样

图像金字塔概念

我们在图像处理中常常会调整图像大小，最常见的就是放大(zoom in)和缩小(zoom out)。

一个图像金子塔是一系列的图像组成，最底下一张是图像尺寸最大，最上方的图像尺寸最小，从空间上向下看就像一个古代的金字塔。

高斯金字塔

高斯金字塔是从底向下，逐层采样得到。

降采样之后图像大小是原图像MxN的M/2 x N/2，就是对原图像删除偶数行与列，即得到降采样之后上一层的图片。

高斯金字塔的生成过程分两步

对当前层进行高斯模糊

删除当前层的偶数行与列

即可得到上一层的图像，这样上一层跟下一层相比，就只有它的1/4大小

拉普拉斯金字塔

高斯不同(Difference of Gaussian-DOG)

定义：就是把同一张图像在不同的参数下做高斯模糊之后的结果相减，得到的输出图像，称为高斯不同(DOG)

高斯不同是图像的内在特征，在灰度图像增强、角点检测中经常用到。

采样相关API

上采样(cv::pyrUp) - zoom in 放大

降采样(cv::pyrDown) - zoom out 缩小

pyrUp(Mat src, Mat dst, Size(src.cols2, src.rows2))

生成的图像是原图在宽与高各放大两倍

pyrDown(Mat src, Mat dst, Size(src.col/2, src.rows/2))

生成的图像是原图在宽与高各缩小1/2

代码演示

void Sample()

{

//上采样

Mat s_up;

pyrUp(src, s_up, Size(src.cols * 2, src.rows * 2));

namedWindow("sample up ", CV_WINDOW_AUTOSIZE);

imshow("sample up ", s_up);

//降采样

Mat s_down;

pyrDown(src, s_down, Size(src.cols / 2, src.rows / 2));

namedWindow("sample down ", CV_WINDOW_AUTOSIZE);

imshow("sample down ", s_down);

Mat gray_src, g1, g2, dogImg;

cvtColor(src, gray_src, CV_BGR2GRAY);

GaussianBlur(gray_src, g1, Size(3, 3), 0, 0);

GaussianBlur(g1, g2, Size(3, 3), 0, 0);

subtract(g1, g2, dogImg, Mat());

normalize(dogImg, dogImg, 255, 0, NORM_MINMAX);

imshow("DOG Image", dogImg);

}

基本阈值操作(二值化)

图像阈值(threshold)

阈值类型-阈值二值化(threshold binary)

左下方的图表示图像像素点Src(x, y)值分布情况，蓝色水平线表示阈值

阈值类型-阈值反二值化(threshold binary Inverted)

左下方的图表示图像像素点Src(x, y)值分布情况，蓝色水平线表示阈值

阈值类型-阈值取零(threshold to zero)

左下方的图表示图像像素点Src(x, y)值分布情况，蓝色水平线表示阈值

阈值类型-阈值反取零(threshold to zero inverted)

左下方的图表示图像像素点Src(x, y)值分布情况，蓝色水平线表示阈值

阈值类型

THRESH_OTSU和THRESH_TRIANGLE处理的图像只能是8位的，一般来说是灰度图像

代码演示

void Threshold_Demo(int, void*)

{

cvtColor(src, gray_src, CV_BGR2GRAY);

threshold(gray_src, dst, threshold_value, threshold_max, type_value);

imshow(output_title, dst);

}

自定义线性滤波

卷积概念

卷积是图像处理中的一个操作，是kernel在图像的每个像素上的操作。

kernel本质上一个固定大小的矩阵数组，其中心点称为锚点(anchor point)

卷积如何工作

把kernel放到像素数组之上，求锚点周围覆盖的像素乘积之和(包括锚点), 用来替换锚点覆盖下像素点值称为卷积处理。数学表达式如下：

卷积核又被称为算子

常见算子：

Robert算子：

Robert算子也叫梯度算子，分别提取x方向的梯度和y方向的梯度

void Robert()

{

//Robert_X方向

Mat kernel_x = (Mat_(2, 2) << 1, 0, 0, -1);

filter2D(src, dst, -1, kernel_x, Point(-1, -1), 0.0);

namedWindow("Robert_X", WINDOW_AUTOSIZE);

imshow("Robert_X", dst);

//Robert_Y方向

Mat ying;

Mat kernel_y = (Mat_(2, 2) << 0, 1, -1, 0);

filter2D(src, ying, -1, kernel_y, Point(-1, -1), 0.0);

namedWindow(output_title, WINDOW_AUTOSIZE);

imshow(output_title, ying);

}

Sobel算子：表现方向上的差异

void Sobel()

{

//Sobel_X方向的差异

//Mat kernel_x = (Mat_(3, 3) << -1, 0, 1, -2, 0, 2, -1, 0, 1);

//Sobel_Y方向的差异

Mat kernel_y= (Mat_(3, 3) << -1, -2, -1, 0, 0, 0, 1, 2, 1);

filter2D(src, dst, -1, kernel_y, Point(-1, -1), 0.0);

namedWindow("Sobel", WINDOW_AUTOSIZE);

imshow("Sobel", dst);

}

拉普拉斯算子：提取边缘体征

void Laplasian()

{

Mat kernel = (Mat_(3, 3) << 0, -1, 0, -1, 4, -1, 0, -1, 0);

filter2D(src, dst, -1, kernel, Point(-1, -1), 0.0);

namedWindow("Laplasian", WINDOW_AUTOSIZE);

imshow("Laplasian", dst);

}

自定义卷积模糊

API:

filter2D(Mat src, //输入图像

Mat dst, //输出图像

Mat depth, //图像深度 32/8

Mat kernel, //卷积核/模板

Point anchor, //锚点位置

double delta //计算出来的像素+delta

)

代码演示：

void Customer_Filter()

{

while (true)

{

char c = waitKey(500);

if (c == 27)

{

break;

}

int ksize = 4 + (index % 5) * 2 + 1;

Mat kernel = Mat::ones(Size(ksize, ksize), CV_32F) / (float)(ksize * ksize);

filter2D(src, dst, -1, kernel, Point(-1, -1));

index++;

namedWindow("customer_filter", WINDOW_AUTOSIZE);

imshow("customer_filter", dst);

}

处理卷积边缘

卷积边界问题

图像卷积的时候边界像素，不能被卷积操作，原因在于边界像素没有完全跟kernel重叠，所以当3x3滤波时候有1个像素的边缘没有被处理，5x5滤波的时候有2个像素的边缘没有被处理。

处理边缘

在卷积开始之前增加边缘像素，填充的像素值为0或者RGB黑色，比如3x3在四周各填充1个像素的边缘，这样就确保图像的边缘被处理，在卷积处理之后再去掉这些边缘。opencv中默认的处理方法是：BORDER_DEFAULT, 此外常用的还有如下几种：

BODER_CONSTANT - 填充边缘用指定像素值

BODER_REPLICATE - 填充边缘像素用已知的边缘像素值。

BODER_WRAP - 用另外一边的像素来补偿填充

API说明

copyMakeBorder(

Mat src， //输入图像

Mat dst， //添加边缘图像

int top， //边缘长度，一般上下左右都取相同值

int bottom，

int left，

int right，

int boderType，

Scalar value

)

Sobel算子

卷积应用-图像边缘提取

边缘是什么 - 是像素值发生跃迁的地方，是图像的显著特征之一，在图像特征提取、对象检测、模式识别等方面都有重要的作用

如何捕捉/提取边缘-对图像求它的一阶导数

delta = f(x) - f(x-1), delta越大，说明像素在x方向变化越大，边缘信号越强

Sobel算子

是离散微分算子(discrete differentiation operator)，用来计算图像灰度的近似梯度

Sobel算子功能集合高斯平滑和微分求导

又被称为一阶微分算子，求导算子，在水平和垂直两个方向上求导，得到图像x方法与y方向梯度图像

求取导数的近似值，kennel=3时不是很准确，OpenCV使用改进版本Scharr函数，算子如下：

API说明cv::Sobel

cv::Sobel(

InputArray Src, //输入图像

OutputArray dst, //输出图像，大小与输入图像一致

int depth, //输出图像深度

int dx, //x方向，几阶导数

int dy, //y方向，几阶导数

int ksize, //Sobel算子kernel大小，必须是1、 3、5、 7、(单数)

double scale = 1,

double delta = 0,

int borderType = BORDER_DEFAULT

)

Laplacian算子

理论

在二阶微分的时候，最大变化处的值为零即边缘是零值。通过二阶导数计算，依据此理论我们可以计算图像二阶导数，提取边缘。

image.png

Laplacian算子

拉普拉斯算子(Laplacian operator)

相关API

void cv::findContours ( InputOutputArray image,

OutputArrayOfArrays contours,

OutputArray hierarchy,

int mode,

int method,

Point offset = Point()

)

参数介绍：

image:输入图像，图像必须为8-bit单通道图像，图像中的非零像素将被视为1，0像素保留其像素值，故加载图像后会自动转换为二值图像。我们同样可以使用cv::compare,cv::inRange,cv::threshold,cv::adaptiveThreshold,cv::Canny等函数来创建二值图像，，如果第四个参数为cv::RETR_CCOMP或cv::RETR_FLOODFILL，输入图像可以是32-bit整型图像(CV_32SC1)

contours:检测到的轮廓，每个轮廓都是以点向量的形式进行存储即使用point类型的vector表示

hierarchy:可选的输出向量(std::vector)，包含了图像的拓扑信息，作为轮廓数量的表示hierarchy包含了很多元素，每个轮廓contours[i]对应hierarchy中hierarchy[i][0]~hierarchy[i][3],分别表示后一个轮廓，前一个轮廓，父轮廓，内嵌轮廓的索引，如果没有对应项，则相应的hierarchy[i]设置为负数。

mode：轮廓检索模式，可以通过cv::RetrievalModes()查看详细信息，如下

RETR_EXTERNAL:表示只检测最外层轮廓，对所有轮廓设置hierarchy[i][2]=hierarchy[i][3]=-1

RETR_LIST:提取所有轮廓，并放置在list中，检测的轮廓不建立等级关系

RETR_CCOMP:提取所有轮廓，并将轮廓组织成双层结构(two-level hierarchy),顶层为连通域的外围边界，次层位内层边界

RETR_TREE:提取所有轮廓并重新建立网状轮廓结构

RETR_FLOODFILL：官网没有介绍，应该是洪水填充法

method：轮廓近似方法可以通过cv::ContourApproximationModes()查看详细信息

CHAIN_APPROX_NONE：获取每个轮廓的每个像素，相邻的两个点的像素位置差不超过1

CHAIN_APPROX_SIMPLE：压缩水平方向，垂直方向，对角线方向的元素值，保留该方向的中点坐标，如果一个矩形轮廓只需4个点来保存轮廓信息

CHAIN_APPROX_TC89_L1和CHAIN_APPROX_TC89_KCOS使用Teh-Chinl链逼近算法中的一种

Rect boundingRect(InputArray points)

参数介绍：