贰[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：计算二位矢量幅值

$dst(i)=\sqrt{x(i)^2+y(i)^2}$

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 运算，是一种特殊的形态学运算，通常用于检测满足特定形状的物体
*/