贰[2]，OpenCV函数解析

1，imread：图片读取

CV_EXPORTS_W Mat imread( const String& filename, int flags = IMREAD_COLOR );
 
//参数1(filename)：文件地址
//参数2(flags):读取标志

注:ImreadModes，参数2(flags)枚举定义

enum ImreadModes {
IMREAD_UNCHANGED            = -1, 
       IMREAD_GRAYSCALE            = 0,  
       IMREAD_COLOR                = 1,  
       IMREAD_ANYDEPTH             = 2, 
       IMREAD_ANYCOLOR             = 4, 
       IMREAD_LOAD_GDAL            = 8,  
       IMREAD_REDUCED_GRAYSCALE_2  = 16, 
       IMREAD_REDUCED_COLOR_2      = 17,
       IMREAD_REDUCED_GRAYSCALE_4  = 32, 
       IMREAD_REDUCED_COLOR_4      = 33, 
       IMREAD_REDUCED_GRAYSCALE_8  = 64, 
       IMREAD_REDUCED_COLOR_8      = 65, 
       IMREAD_IGNORE_ORIENTATION   = 128 
     };
 
/*
IMREAD_UNCHANGED: 如果设置，将加载的图像原样返回（如果有alpha通道，否则会被裁剪）。忽略EXIF方向。
IMREAD_GRAYSCALE: 如果设置，总是将图像转换为单通道灰度图像（编解码器内部转换）。
IMREAD_COLOR: 如果设置，总是将图像转换为3通道BGR彩色图像。
IMREAD_ANYDEPTH: 如果设置，当输入具有相应的深度时，返回16位/32位图像，否则将其转换为8位。
IMREAD_ANYCOLOR: 如果设置，图像以任何可能的颜色格式读取。
IMREAD_LOAD_GDAL: 如果设置，使用gdal驱动程序加载图像。
IMREAD_REDUCED_GRAYSCALE_2 到 IMREAD_REDUCED_GRAYSCALE_8: 这些标志将图像转换为单通道灰度图像，并将图像大小减少一半或四分之一或八分之一。
IMREAD_REDUCED_COLOR_2 到 IMREAD_REDUCED_COLOR_8: 这些标志将图像转换为3通道BGR彩色图像，并将图像大小减少一半或四分之一或八分之一。
IMREAD_IGNORE_ORIENTATION: 如果设置，不根据EXIF的方向标志旋转图像。
*/

2，imwrite：图片保存

CV_EXPORTS_W bool imwrite( const String& filename, InputArray img,
              const std::vector<int>& params = std::vector<int>());
              
//参数1(filename)：文件地址
//参数2(img):图片数据
//参数3(params ):为特定格式保存的参数编码

注:**ImwriteFlags** ，参数3(params)枚举定义

enum ImwriteFlags {
       IMWRITE_JPEG_QUALITY        = 1,  
       IMWRITE_JPEG_PROGRESSIVE    = 2,  
       IMWRITE_JPEG_OPTIMIZE       = 3,  
       IMWRITE_JPEG_RST_INTERVAL   = 4, 
       IMWRITE_JPEG_LUMA_QUALITY   = 5,  
       IMWRITE_JPEG_CHROMA_QUALITY = 6,  
       IMWRITE_JPEG_SAMPLING_FACTOR = 7, 
       IMWRITE_PNG_COMPRESSION     = 16, 
       IMWRITE_PNG_STRATEGY        = 17, 
       IMWRITE_PNG_BILEVEL         = 18, 
       IMWRITE_PXM_BINARY          = 32, 
       IMWRITE_EXR_TYPE            = (3 << 4) + 0, 
       IMWRITE_EXR_COMPRESSION     = (3 << 4) + 1, 
       IMWRITE_EXR_DWA_COMPRESSION_LEVEL = (3 << 4) + 2, 
       IMWRITE_WEBP_QUALITY        = 64, /
       IMWRITE_HDR_COMPRESSION     = (5 << 4) + 0, 
       IMWRITE_PAM_TUPLETYPE       = 128,
       IMWRITE_TIFF_RESUNIT        = 256,
       IMWRITE_TIFF_XDPI           = 257,
       IMWRITE_TIFF_YDPI           = 258,
       IMWRITE_TIFF_COMPRESSION    = 259,
       IMWRITE_JPEG2000_COMPRESSION_X1000 = 272,
       IMWRITE_AVIF_QUALITY        = 512,
       IMWRITE_AVIF_DEPTH          = 513,
       IMWRITE_AVIF_SPEED          = 514 
     };
 
/*
IMWRITE_JPEG_QUALITY：用于JPEG图像，表示质量等级，值范围从0到100，其中100表示最高质量。默认值为95。
IMWRITE_JPEG_PROGRESSIVE：启用JPEG渐进式扫描，值为0或1，默认值为False。
IMWRITE_JPEG_OPTIMIZE：优化JPEG图像，值为0或1，默认值为False。
IMWRITE_JPEG_RST_INTERVAL：JPEG图像中重新同步标记的间隔，值范围从0到65535，默认值为0（无重新同步）。
IMWRITE_JPEG_LUMA_QUALITY：单独的亮度质量级别，值范围从0到100，默认值为-1（不使用）。
IMWRITE_JPEG_CHROMA_QUALITY：单独的色度质量级别，值范围从0到100，默认值为-1（不使用）。
IMWRITE_JPEG_SAMPLING_FACTOR：用于JPEG的采样因子，参见cv::ImwriteJPEGSamplingFactorParams。
IMWRITE_PNG_COMPRESSION：用于PNG的压缩级别，值范围从0到9。较高的值表示较小的尺寸和更长的压缩时间。当指定此标志时，策略更改为IMWRITE_PNG_STRATEGY_DEFAULT（Z_DEFAULT_STRATEGY）。默认值为1（最佳速度设置）。
IMWRITE_PNG_STRATEGY：PNG的压缩策略，可以是cv::ImwritePNGFlags中的一个值，默认值为IMWRITE_PNG_STRATEGY_RLE。
IMWRITE_PNG_BILEVEL：二进制级别的PNG，值为0或1，默认值为0。
IMWRITE_PXM_BINARY：对于PPM、PGM或PBM，可以是一个二进制格式标志，值为0或1。默认值为1。
*/

3，imshow：图片显示

CV_EXPORTS_W void imshow(const String& winname, InputArray mat);
 
//参数1(winname)：窗口名称
//参数2(img):图片数据

4，cvtColor：颜色空间转换

实现**RGB**颜色空间转**HSV/HSI/灰度**等颜色空间。

CV_EXPORTS_W void cvtColor( InputArray src, 
                            OutputArray dst, 
                            int code, 
                            int dstCn = 0 );
 
//参数1(src)：原图
//参数2(dst)：处理后的图
//参数3(code)：颜色空间转换标识符
//参数4(dstCn)：处理后图片的通道数，=0，则和原图相同。

注:**ColorConversionCodes** ，参数3(code)对应枚举定义

enum ColorConversionCodes {
    COLOR_BGR2BGRA     = 0, //!< add alpha channel to RGB or BGR image
    COLOR_RGB2RGBA     = COLOR_BGR2BGRA,
    ......
}；

5，ellipse：画椭圆

两个重载函数
函数1：

CV_EXPORTS_W 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);
                        
//参数1(img)：待绘制的图像
//参数2(center)：椭圆中心点
//参数3(axes)：长短轴尺寸
//参数4(angle)：角度
//参数5(startAngle) ：弧度段起始角度
//参数6(endAngle) ：弧度段结束角度
//参数7(color)：椭圆颜色
//参数8(thickness )：画笔线宽
//参数9(lineType )：画笔线类型     
//参数10(shift )：绘制精度，默认为0（单精度） 

注：startAngle=0，endAngle=360，整个椭圆

函数2：

CV_EXPORTS_W void ellipse(InputOutputArray img, const RotatedRect& box, const Scalar& color,
                        int thickness = 1, int lineType = LINE_8);
                        
//参数1(img)：待绘制的图像
//参数2(center)：椭圆的形状，RotatedRect，有三个属性：angle center size
//参数3(color)：椭圆颜色
//参数4(thickness )：线宽
//参数5(lineType )：线类型

注：**LineTypes** 参数5(lineType)枚举定义

enum LineTypes {
    FILLED  = -1,
    LINE_4  = 4, //!< 4-connected line
    LINE_8  = 8, //!< 8-connected line
    LINE_AA = 16 //!< antialiased line
};

6，circle：画圆

CV_EXPORTS_W void circle(InputOutputArray img, Point center, int radius,
                       const Scalar& color, int thickness = 1,
                       int lineType = LINE_8, int shift = 0);
                       
//参数1(img)：待绘制的图像
//参数2(center)：圆心坐标
//参数3(color)：圆的半径
//参数4(color)：椭圆颜色
//参数5(thickness )：画笔线宽
//参数6(lineType )：画笔线类型     
//参数7(shift )：绘制精度，默认为0（单精度）

注：thickness =-1，为实心圆

7，fillPoly：画多边形

两个重载函数
函数1:

CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts,
                           const Scalar& color, int lineType = LINE_8, int shift = 0,
                           Point offset = Point() );
                          
 //参数1(img)：待绘制的图像
//参数2(pts)：顶点集
//参数3(color)：椭圆颜色
//参数4(lineType )：画笔线类型   
//参数5(shift )：绘制精度，默认为0（单精度）
//参数6(offset )：绘制的偏移量，默认为(0,0)

函数2：

CV_EXPORTS void fillPoly(InputOutputArray img, const Point** pts,
                         const int* npts, int ncontours,
                         const Scalar& color, int lineType = LINE_8, int shift = 0,
                         Point offset = Point() );
 
//参数1(img)：待绘制的图像
//参数2(pts)：顶点集
//参数3(npts)：多边形顶点数
//参数4(ncontours)：多边形数量
//参数5(color)：椭圆颜色
//参数6(lineType )：画笔线类型   
//参数7(shift )：绘制精度，默认为0（单精度）
//参数8(offset )：绘制的偏移量，默认为(0,0)

8，line：画线

CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
                     int thickness = 1, int lineType = LINE_8, int shift = 0);
//参数1(img)：待绘制的图像
//参数2(pt1)：线起点
//参数3(pt2)：线终点
//参数4(color)：线颜色
//参数5(thickness )：画笔线宽
//参数6(lineType )：画笔线类型     
//参数7(shift )：绘制精度，默认为0（单精度）

9，LUT:查表

查表变换，用于大数据图像的图元进行批量操作，牺牲空间换取时间

CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst);
//参数1(src)：原图
//参数2(lut)：表
//参数3(dst)：处理后的图

 10，getTickCount：获取电脑当前时钟数

CV_EXPORTS_W int64 getTickCount();

11，getTickFrequency：获取CPU，1秒的走过的时钟周期

CV_EXPORTS_W double getTickFrequency();
 
//double start = cv::getTickCount();
//double interval = cv::getTickCount() - start;
//double second=interval  / cv::getTickFrequency(); // 结果单位：秒

12，addWeighted：图像混合

CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2,
                              double beta, double gamma, OutputArray dst, int dtype = -1);
//参数1(src1)：图像1
//参数2(alpha)：图像1权重
//参数3(src2)：图像2
//参数4(beta)：图像2权重
//参数5(gamma)：加到权重总和上的值
//参数6(dst)：处理后图像
//参数7(dtype )：图像深度，-1和图像1的深度相同
//输出图像图元i，dst[i] = src1[i] * alpha + src2[i ] * beta + gamma;

注：图像1(src1)和图像2(src2)类型和尺寸需要相同

13，split：通道分离

CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv);
 
//参数1(m)：多通道图像
//参数2(mv)：单通道图像数组

14，merge：通道合并

CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst)
 
//参数1(mv)：单通道图像数组
//参数2(m)：多通道图像

15，dft：离散傅里叶变换

CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0);
 
//参数1(src)：原图
//参数2：处理图像
//参数3：转换标志
//参数4：非零行

注：**DftFlags** 参数3(flags)枚举定义

enum DftFlags {
    DFT_INVERSE        = 1,
    DFT_SCALE          = 2,
    DFT_ROWS           = 4,
    DFT_COMPLEX_OUTPUT = 16,
    DFT_REAL_OUTPUT    = 32,
    DFT_COMPLEX_INPUT  = 64,
    DCT_INVERSE        = DFT_INVERSE,
    DCT_ROWS           = DFT_ROWS
};
 
/*
DFT_INVERSE: 这个值用于指示需要进行逆DFT变换，逆DFT变换是将频域表示转换回时域表示的过程。
DFT_SCALE: 这个值用于指示在进行DFT变换后需要对输出进行缩放。在某些情况下，为了保持数据的精度，需要在变换后对输出进行缩放，输出的结果都会以l/N进行缩放，通常会结合DFT_INVERSE一起使用。
DFT_ROWS: 这个值用于指示在进行DFT变换时，按行进行运算。对输入矩阵的每行进行正向或反向的变换，此标识符可以在处理多种矢量的时候用于减小资源开销，这些处理常常是三维或高维变换等复杂操作
DFT_COMPLEX_OUTPUT: 这个值用于指示DFT变换的输出结果是复数形式的。在频域变换中，输出通常可以是实数或复数形式。
DFT_REAL_OUTPUT: 这个值用于指示DFT变换的输出结果是实数形式的。在某些情况下，我们可能只关心频域表示的实部，而不需要虚部，这时可以使用这个选项。
DFT_COMPLEX_INPUT: 这个值用于指示输入给DFT变换的数据是复数形式的。在频域变换中，输入数据可以是实数或复数形式。
DCT_INVERSE: 这个值与DFT_INVERSE相同，用于指示需要进行逆DCT变换。逆DCT变换是将频域表示转换回时域表示的过程。
DCT_ROWS: 这个值与DFT_ROWS相同，用于指示在进行DCT变换时，按行进行运算。
*/

16，getOptimalDFTSize：获取傅里叶最佳尺寸

CV_EXPORTS_W int getOptimalDFTSize(int vecsize);
 
//参数1(vecsize)：尺寸，即图片的rows，cols
//离散傅里叶变换的运行速度与图片的尺寸有很大关系。当图像的尺寸是 2、 3、 5的整数倍时，计算速度最快。

17，copyMakeBorder：扩展图像边界

CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst,
                                 int top, int bottom, int left, int right,
                                 int borderType, const Scalar& value = Scalar() );
 
//参数1(src)：原图
//参数2(dst)：处理后图
//参数3(top)：原图像上方扩充的像素
//参数4(bottom)：原图像下方扩充的像素
//参数5(left)：原图像左方扩充的像素
//参数6(right)：原图像右方扩充的像素
//参数7(borderType)：边界类型
//参数8(value)：当 borderType取值为 BORDER CONSTANT时，这个参数表示边界值

18，magnitude：计算二位矢量幅值

CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude);
 
//参数1(x)：矢量浮点型X坐标值，实部
//参数1(y)：矢量浮点型Y坐标值，虚部
//参数1(magnitude)：输出的幅值

19，normalize：矩阵归一化

normalize函数的作用是将数据归一化到指定的范围，将数据的分布变得更加集中，减少数据的波动性，同时也可以提高模型的训练速度和准确性

CV_EXPORTS_W void normalize( InputArray src, InputOutputArray dst, double alpha = 1, double beta = 0,
                             int norm_type = NORM_L2, int dtype = -1, InputArray mask = noArray());
 
//参数1(src)：原矩阵
//参数2(dst)：处理后的矩阵
//参数3(alpha)：归一化的参数
//参数4(beta)：归一化的参数
//参数5(norm_type)：归一化类型
//参数6(dtype)：矩阵类型
//参数7(mask)：掩膜

enum NormTypes {
                NORM_INF       = 1,
                 NORM_L1        = 2,
                 NORM_L2        = 4,
                 NORM_L2SQR     = 5,
                 NORM_HAMMING   = 6,
                 NORM_HAMMING2  = 7,
                 NORM_TYPE_MASK = 7, 
                 NORM_RELATIVE  = 8, 
                 NORM_MINMAX    = 32 
               };
 
NORM_INF： 这可能是无穷范数（L-inf norm），在数学中常用于量化向量或矩阵的“大小”。对于向量，它计算的是向量元素绝对值的最大值；对于矩阵，它计算的是矩阵中所有子矩阵元素绝对值的最大值。
NORM_L1： 这可能是L1范数（L-1 norm），它计算的是向量元素绝对值的总和。
NORM_L2： 这是L2范数（L-2 norm），也称为欧几里得范数，它计算的是向量元素平方和的平方根。
NORM_L2SQR：这可能是L2平方范数（L-2 squared norm），它计算的是向量元素平方和。
NORM_HAMMING 和 NORM_HAMMING2：可能是某种类型的哈明范数（Hamming norm），它通常用于量化矢量或矩阵中非零元素的数量。
NORM_TYPE_MASK：这可能是一个位掩码，用于选择上述范数类型的一部分。
NORM_RELATIVE：这可能是一个标志，表示使用相对范数（relative norm），即根据向量的大小来计算范数。
NORM_MINMAX：这可能是最小最大范数（min-max norm），它把向量映射到0和1之间。

20，blur：均值滤波

CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
                        Size ksize, Point anchor = Point(-1,-1),
                        int borderType = BORDER_DEFAULT );
 
//参数1(src)：原图
//参数2(dst)：处理后的图像
//参数3(ksize)：核的尺寸，正奇数
//参数4(anchor)：锚点，默认值 Point(-l-l)表示这个锚点在核的中心
//参数5(borderType)：边框类型

21，boxFilter：方框滤波

CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth,
                             Size ksize, Point anchor = Point(-1,-1),
                             bool normalize = true,
                             int borderType = BORDER_DEFAULT );
 
//参数1(src)：原图
//参数2(dst)：处理后的图像
//参数3(ddepth)：处理后图像深度，-1代表使用原图深度
//参数4(ksize)：核的尺寸，正奇数
//参数5(anchor)：锚点，默认值 Point(-l-l)表示这个锚点在核的中心
//参数6(normalize)：归一化处理
//参数7(borderType)：边框类型

22，GaussianBlur：高斯滤波

CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,
                                double sigmaX, double sigmaY = 0,
                                int borderType = BORDER_DEFAULT );
 
//参数1(src)：原图
//参数2(dst)：处理后图像
//参数3(ksize)：内核大小，正奇数
//参数4(sigmaX)：X方向上的高斯核标准偏差
//参数5(sigmaY)：Y方向上的高斯核标准偏差
//参数6(borderType )：边框类型

 23，medianBlur：中值滤波

CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );
 
//参数1(src)：原图
//参数2(dst)：处理后图像
//参数3(ksize)：内核大小，正奇数

24，bilateralFilter：双边滤波

CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,
                                   double sigmaColor, double sigmaSpace,
                                   int borderType = BORDER_DEFAULT );
 
//参数1(src)：原图
//参数2(dst)：处理后图像
//参数3(d)：表示在过滤过程中每个像素邻域的直径
//参数4(sigmaColor)：颜色空间滤波器的sigma值。这个参数的值越大，就表明该像素邻域内有越宽广的颜色会被混合到一起，产生较大的半相等颜色区域
//参数5(sigmaSpace)：坐标空间中滤波器的sigma值，坐标空间的标注方差。它的数值越大，意味着越远的像素会相互影响，从而使更大的区域中足够相似的颜色获取相同的颜色。当 d>0时， d指定了邻域大小且与sigmaSpace无关。否则， d正比于sigmaSpace
//参数6(borderType)：边框类型
 

25，dilate：膨胀(形态学滤波)

CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel,
                          Point anchor = Point(-1,-1), int iterations = 1,
                          int borderType = BORDER_CONSTANT,
                          const Scalar& borderValue = morphologyDefaultBorderValue() );
 
 
//参数1(src)：原图
//参数2(dst)：处理后图像
//参数3(kernel)：内核,可以是正方向或者矩形，可以通过cv2.getStructuringElement()函数创建
//参数4(anchor )：锚点
//参数5(iterations)：迭代次数，如连续膨胀几次
//参数6(borderType )：边框类型
//参数7(borderValue )：边界值

26，getStructuringElement：获取内核

CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1));
 
//参数1(shape)：设定卷积核的形状，有三个可选值：MORPH_RECT（返回矩形卷积核）、MORPH_CROSS（返回十字形卷积核）和MORPH_ELLIPSE（返回椭圆形卷积核）
//参数2(ksize)：表示卷积核有x行，y列
//参数3(anchor )：设定锚点的位置，一般设为(-1,-1)，表示锚点位于核中心。

注：参数1(shape)枚举定义

enum MorphShapes {
    MORPH_RECT    = 0, 
    MORPH_CROSS   = 1, 
    MORPH_ELLIPSE = 2 
};

27，erode：腐蚀(形态学滤波)

CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel,
                         Point anchor = Point(-1,-1), int iterations = 1,
                         int borderType = BORDER_CONSTANT,
                         const Scalar& borderValue = morphologyDefaultBorderValue() );
 
//参数1(src)：原图
//参数2(dst)：处理后图像
//参数3(kernel)：内核,可以是正方向或者矩形，可以通过cv2.getStructuringElement()函数创建
//参数4(anchor )：锚点
//参数5(iterations)：迭代次数，如连续腐蚀几次
//参数6(borderType )：边框类型
//参数7(borderValue )：边界值

28，morphologyEx：形态学滤波

CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst,
                                int op, InputArray kernel,
                                Point anchor = Point(-1,-1), int iterations = 1,
                                int borderType = BORDER_CONSTANT,
                                const Scalar& borderValue = morphologyDefaultBorderValue() );
 
 
//参数1(src)：原图
//参数2(dst)：处理后图像
//参数3(op)：形态学操作的类型，可以是腐蚀、膨胀、开运算、闭运算、顶帽、黑帽等
//参数4(kernel)：内核,可以是正方向或者矩形，可以通过cv2.getStructuringElement()函数创建
//参数5(anchor )：锚点
//参数6(iterations)：迭代次数
//参数7(borderType )：边框类型
//参数8(borderValue )：边界值

注：参数3(op)枚举定义

enum MorphTypes{
    MORPH_ERODE    = 0, 
    MORPH_DILATE   = 1, 
    MORPH_OPEN     = 2, 
    MORPH_CLOSE    = 3, 
    MORPH_GRADIENT = 4, 
    MORPH_TOPHAT   = 5, 
    MORPH_BLACKHAT = 6, 
    MORPH_HITMISS  = 7  
};
 
/*
    MORPH_ERODE    //腐蚀
    MORPH_DILATE   //膨胀
    MORPH_OPEN     //开运算
    MORPH_CLOSE    //闭运算
    MORPH_GRADIENT //梯度
    MORPH_TOPHAT   //顶帽
    MORPH_BLACKHAT //白帽
    MORPH_HITMISS  //Hit-or-Miss 运算，是一种特殊的形态学运算，通常用于检测满足特定形状的物体
*/

29，floodFill函数：水漫填充

两个重载

函数1

CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask,
                            Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
                            Scalar loDiff = Scalar(), Scalar upDiff = Scalar(),
                            int flags = 4 );
 
//参数1(image)：原图
//参数2(mask)：掩膜
//参数3(seedPoint)：漫水填充算法的起始点
//参数4(newVal)：像素点被染色的值 即在重绘区域像素的新值
//参数5(rect)：有默认值0，用于设函数将要重绘区域的最小边界矩形区域
//参数6(loDiff)：有默认值Scalar()，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间亮度或颜色之负差(lower brightness/color difference)的最大值
//参数7(upDiff)：有默认值Scalar()，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间亮度或颜色之正差(lower brightness/color difference)的最大值
//参数8(flags)：操作标志符
//低八位 (第0-7位〉用于控制算法的连通性 可取4(4为默认值)或者8。如果设为 4，表示填充算法只考虑当前像素水平方向和垂直方向的相邻点;如果设为8，除上述相邻点外，还会包含对角线方向的相邻点。
//高八位，可通过枚举设置，FLOODFILL_FIXED_RANGE，如果设置为这个标识 ，就会考虑当前像素与种子像素之间的差, 否则就考虑当前像素与其相邻像素的差，这个范围是浮动的。FLOODFILL_MASK_ONLY，如果设置为这个标识 ，函数不会去填充改变原始图像(也就是忽略第 newVal) ，而是去填充掩模图像mask。

函数2

CV_EXPORTS int floodFill( InputOutputArray image,
                          Point seedPoint, Scalar newVal, CV_OUT Rect* rect = 0,
                          Scalar loDiff = Scalar(), Scalar upDiff = Scalar(),
                          int flags = 4 );
 
//参数1(iamge)：原图
//参数2(seedPoint)：漫水填充算法的起始点
//参数3(newVal)：像素点被染色的值 即在重绘区域像素的新值
//参数4(rect)：有默认值0，用于设函数将要重绘区域的最小边界矩形区域
//参数5(loDiff)：有默认值Scalar()，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间亮度或颜色之负差(lower brightness/color difference)的最大值
//参数6(upDiff)：有默认值Scalar()，表示当前观察像素值与其部件邻域像素值或者待加入该部件的种子像素之间亮度或颜色之正差(lower brightness/color difference)的最大值
//参数7(flags)：操作标志符
//低八位 (第0-7位〉用于控制算法的连通性 可取4(4为默认值)或者8。如果设为 4，表示填充算法只考虑当前像素水平方向和垂直方向的相邻点;如果设为8，除上述相邻点外，还会包含对角线方向的相邻点。
//高八位，可通过枚举设置，FLOODFILL_FIXED_RANGE，如果设置为这个标识 ，就会考虑当前像素与种子像素之间的差, 否则就考虑当前像素与其相邻像素的差，这个范围是浮动的。FLOODFILL_MASK_ONLY，如果设置为这个标识 ，函数不会去填充改变原始图像(也就是忽略第 newVal) ，而是去填充掩模图像mask。