包 org.opencv.core

类 Core

  • public class Core
extends java.lang.Object

    • 构造器摘要

      构造器 
      构造器 描述
      Core()  

    • 方法摘要

      所有方法 静态方法 具体方法 已弃用方法 
      修饰符和类型 方法 描述
      静态 void absdiff​(Mat src1, Mat src2, Mat dst)
      计算两个数组或数组和标量之间的逐元素绝对差。
      静态 void absdiff​(Mat src1, Scalar src2, Mat dst)  
      静态 void add​(Mat src1, Mat src2, Mat dst)
      计算两个数组或数组和标量的逐元素和。
      静态 void add​(Mat src1, Mat src2, Mat dst, Mat mask)
      计算两个数组或数组和标量的逐元素和。
      静态 void add​(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
      计算两个数组或数组和标量的逐元素和。
      静态 void add​(Mat src1, Scalar src2, Mat dst)  
      静态 void add​(Mat src1, Scalar src2, Mat dst, Mat mask)  
      静态 void add​(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)  
      静态 void addSamplesDataSearchPath​(java.lang.String path)
      通过添加新的搜索位置来覆盖搜索数据路径。仅当需要覆盖默认行为时才使用此方法。传入的路径按后进先出 (LIFO) 顺序使用。
      静态 void addSamplesDataSearchSubDirectory​(java.lang.String subdir)
      追加样本搜索数据子目录。一般用法是添加 OpenCV 模块名称 (<opencv_contrib>/modules/<name>/samples/data -> <name>/samples/data + modules/<name>/samples/data)。
      静态 void addWeighted​(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)
      计算两个数组的加权和。
      静态 void addWeighted​(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)
      计算两个数组的加权和。
      静态 void batchDistance​(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)
      朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
      静态 void batchDistance​(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType)
      朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
      静态 void batchDistance​(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K)
      朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
      静态 void batchDistance​(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask)
      朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
      静态 void batchDistance​(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update)
      朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
      静态 void batchDistance​(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)
      朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
      静态 void bitwise_and​(Mat src1, Mat src2, Mat dst)
      计算两个数组的按位与运算 (dst = src1 & src2)。计算两个数组或一个数组和一个标量的逐元素按位与运算。
      静态 void bitwise_and​(Mat src1, Mat src2, Mat dst, Mat mask)
      计算两个数组的按位与运算 (dst = src1 & src2)。计算两个数组或一个数组和一个标量的逐元素按位与运算。
      静态 void bitwise_not​(Mat src, Mat dst)
      反转数组的每一位。
      静态 void bitwise_not​(Mat src, Mat dst, Mat mask)
      反转数组的每一位。
      静态 void bitwise_or​(Mat src1, Mat src2, Mat dst)
      计算两个数组或一个数组和一个标量的逐元素按位或运算。
      静态 void bitwise_or​(Mat src1, Mat src2, Mat dst, Mat mask)
      计算两个数组或一个数组和一个标量的逐元素按位或运算。
      静态 void bitwise_xor​(Mat src1, Mat src2, Mat dst)
      计算两个数组或一个数组和一个标量的逐元素按位异或运算。
      静态 void bitwise_xor​(Mat src1, Mat src2, Mat dst, Mat mask)
      计算两个数组或一个数组和一个标量的逐元素按位异或运算。
      静态 int borderInterpolate​(int p, int len, int borderType)
      计算外推像素的源位置。
      静态 void broadcast​(Mat src, Mat shape, Mat dst)
      将给定的 Mat 广播到给定的形状。
      静态 void calcCovarMatrix​(Mat samples, Mat covar, Mat mean, int flags)
      注意：使用 #COVAR_ROWS 或 #COVAR_COLS 标志
      静态 void calcCovarMatrix​(Mat samples, Mat covar, Mat mean, int flags, int ctype)
      注意：使用 #COVAR_ROWS 或 #COVAR_COLS 标志
      静态 void cartToPolar​(Mat x, Mat y, Mat magnitude, Mat angle)
      计算二维向量的幅度和角度。
      静态 void cartToPolar​(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)
      计算二维向量的幅度和角度。
      静态布尔值 checkHardwareSupport​(int feature)
      如果主机硬件支持指定的特性，则返回 true。
      静态布尔值 checkRange​(Mat a)
      检查输入数组的每个元素是否有无效值。
      静态布尔值 checkRange​(Mat a, boolean quiet)
      检查输入数组的每个元素是否有无效值。
      静态布尔值 checkRange​(Mat a, boolean quiet, double minVal)
      检查输入数组的每个元素是否有无效值。
      静态布尔值 checkRange​(Mat a, boolean quiet, double minVal, double maxVal)
      检查输入数组的每个元素是否有无效值。
      静态 void compare​(Mat src1, Mat src2, Mat dst, int cmpop)
      执行两个数组或一个数组和标量值的逐元素比较。
      静态 void compare​(Mat src1, Scalar src2, Mat dst, int cmpop)  
      静态 void completeSymm​(Mat m)
      复制方阵的下半部分或上半部分到其另一半。
      静态 void completeSymm​(Mat m, boolean lowerToUpper)
      复制方阵的下半部分或上半部分到其另一半。
      静态 void convertFp16​(Mat src, Mat dst)
      已弃用。
      请使用 Mat::convertTo 并设置 CV_16F。
      静态 void convertScaleAbs​(Mat src, Mat dst)
      缩放、计算绝对值，并将结果转换为 8 位。
      静态 void convertScaleAbs​(Mat src, Mat dst, double alpha)
      缩放、计算绝对值，并将结果转换为 8 位。
      静态 void convertScaleAbs​(Mat src, Mat dst, double alpha, double beta)
      缩放、计算绝对值，并将结果转换为 8 位。
      静态 void copyMakeBorder​(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)
      在图像周围形成一个边界。
      静态 void copyMakeBorder​(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)
      在图像周围形成一个边界。
      静态 void copyTo​(Mat src, Mat dst, Mat mask)
      这是一个重载的成员函数，为方便起见提供（python）。将矩阵复制到另一个矩阵。
      静态 int countNonZero​(Mat src)
      统计非零数组元素的数量。
      static float cubeRoot​(float val)
      计算参数的立方根。
      静态 void dct​(Mat src, Mat dst)
      执行一维或二维数组的正向或反向离散余弦变换。
      静态 void dct​(Mat src, Mat dst, int flags)
      执行一维或二维数组的正向或反向离散余弦变换。
      static double determinant​(Mat mtx)
      返回一个方形浮点矩阵的行列式。
      静态 void dft​(Mat src, Mat dst)
      执行一维或二维浮点数组的正向或反向离散傅里叶变换。
      静态 void dft​(Mat src, Mat dst, int flags)
      执行一维或二维浮点数组的正向或反向离散傅里叶变换。
      静态 void dft​(Mat src, Mat dst, int flags, int nonzeroRows)
      执行一维或二维浮点数组的正向或反向离散傅里叶变换。
      静态 void divide​(double scale, Mat src2, Mat dst)  
      静态 void divide​(double scale, Mat src2, Mat dst, int dtype)  
      静态 void divide​(Mat src1, Mat src2, Mat dst)
      执行两个数组或一个标量与数组的逐元素除法。
      静态 void divide​(Mat src1, Mat src2, Mat dst, double scale)
      执行两个数组或一个标量与数组的逐元素除法。
      静态 void divide​(Mat src1, Mat src2, Mat dst, double scale, int dtype)
      执行两个数组或一个标量与数组的逐元素除法。
      静态 void divide​(Mat src1, Scalar src2, Mat dst)  
      静态 void divide​(Mat src1, Scalar src2, Mat dst, double scale)  
      静态 void divide​(Mat src1, Scalar src2, Mat dst, double scale, int dtype)  
      静态布尔值 eigen​(Mat src, Mat eigenvalues)
      计算对称矩阵的特征值和特征向量。
      静态布尔值 eigen​(Mat src, Mat eigenvalues, Mat eigenvectors)
      计算对称矩阵的特征值和特征向量。
      静态 void eigenNonSymmetric​(Mat src, Mat eigenvalues, Mat eigenvectors)
      计算非对称矩阵的特征值和特征向量（仅限实数特征值）。
      静态 void exp​(Mat src, Mat dst)
      计算每个数组元素的指数。
      静态 void extractChannel​(Mat src, Mat dst, int coi)
      从 src 中提取单个通道（coi 是基于 0 的索引）
      static float fastAtan2​(float y, float x)
      计算二维向量的角度（以度为单位）。
      静态 java.lang.String findFile​(java.lang.String relative_path)
      尝试查找请求的数据文件。搜索目录：1。
      静态 java.lang.String findFile​(java.lang.String relative_path, boolean required)
      尝试查找请求的数据文件。搜索目录：1。
      静态 java.lang.String findFile​(java.lang.String relative_path, boolean required, boolean silentMode)
      尝试查找请求的数据文件。搜索目录：1。
      静态 java.lang.String findFileOrKeep​(java.lang.String relative_path)  
      静态 java.lang.String findFileOrKeep​(java.lang.String relative_path, boolean silentMode)  
      静态 void findNonZero​(Mat src, Mat idx)
      返回非零像素的位置列表。给定一个二值矩阵（可能由阈值化、比较（>、== 等）操作返回），返回所有非零索引作为 cv::Mat 或 std::vector<cv::Point> (x,y)。例如： cv::Mat binaryImage; // 输入，二值图像 cv::Mat locations; // 输出，非零像素的位置 cv::findNonZero(binaryImage, locations); // 访问像素坐标 Point pnt = locations.at<Point>(i); 或 cv::Mat binaryImage; // 输入，二值图像 vector<Point> locations; // 输出，非零像素的位置 cv::findNonZero(binaryImage, locations); // 访问像素坐标 Point pnt = locations[i]; 此函数不适用于多通道数组。
      静态 void flip​(Mat src, Mat dst, int flipCode)
      围绕垂直轴、水平轴或两个轴翻转二维数组。
      静态 void flipND​(Mat src, Mat dst, int axis)
      沿给定轴翻转 n 维数组。
      静态 void gemm​(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)
      执行广义矩阵乘法。
      静态 void gemm​(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)
      执行广义矩阵乘法。
      静态 java.lang.String getBuildInformation()
      返回完整的配置时间 CMake 输出。
      静态 java.lang.String getCPUFeaturesLine()
      返回编译期间启用的 CPU 特性列表。
      静态 long getCPUTickCount()
      返回 CPU 滴答数。
      静态 int getDefaultAlgorithmHint()  
      静态 java.lang.String getHardwareFeatureName​(int feature)
      根据 ID 返回特性名称。如果未定义特性，则返回空字符串。
      静态 java.lang.String getIppVersion()  
      静态 int getNumberOfCPUs()
      返回进程可用的逻辑 CPU 数量。
      静态 int getNumThreads()
      返回 OpenCV 用于并行区域的线程数。
      静态 int getOptimalDFTSize​(int vecsize)
      返回给定向量大小的最佳 DFT 大小。
      静态 int getThreadNum()
      已弃用。
      当前实现与该文档不对应。
      静态 long getTickCount()
      返回滴答数。
      static double getTickFrequency()
      返回每秒的滴答数。
      静态 int getVersionMajor()
      返回主库版本。
      静态 int getVersionMinor()
      返回次要库版本。
      静态 int getVersionRevision()
      返回库版本的修订字段。
      静态 java.lang.String getVersionString()
      返回库版本字符串，例如“3.4.1-dev”。
      静态布尔值 hasNonZero​(Mat src)
      检查是否存在至少一个非零数组元素。
      静态 void hconcat​(java.util.List<Mat> src, Mat dst)
      std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)), cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)), cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),}; cv::Mat out; cv::hconcat( matrices, out ); //out: //[1, 2, 3; // 1, 2, 3; // 1, 2, 3; // 1, 2, 3]
      静态 void idct​(Mat src, Mat dst)
      计算一维或二维数组的逆离散余弦变换。
      静态 void idct​(Mat src, Mat dst, int flags)
      计算一维或二维数组的逆离散余弦变换。
      静态 void idft​(Mat src, Mat dst)
      计算一维或二维数组的逆离散傅里叶变换。
      静态 void idft​(Mat src, Mat dst, int flags)
      计算一维或二维数组的逆离散傅里叶变换。
      静态 void idft​(Mat src, Mat dst, int flags, int nonzeroRows)
      计算一维或二维数组的逆离散傅里叶变换。
      静态 void inRange​(Mat src, Scalar lowerb, Scalar upperb, Mat dst)
      检查数组元素是否位于其他两个数组的元素之间。
      静态 void insertChannel​(Mat src, Mat dst, int coi)
      将单个通道插入到 dst（coi 是基于 0 的索引）。
      static double invert​(Mat src, Mat dst)
      查找矩阵的逆矩阵或伪逆矩阵。
      static double invert​(Mat src, Mat dst, int flags)
      查找矩阵的逆矩阵或伪逆矩阵。
      static double kmeans​(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)
      查找聚类的中心并将输入样本分组到聚类周围。
      static double kmeans​(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)
      查找聚类的中心并将输入样本分组到聚类周围。
      静态 void log​(Mat src, Mat dst)
      计算每个数组元素的自然对数。
      静态 void LUT​(Mat src, Mat lut, Mat dst)
      执行数组的查找表转换。
      静态 void magnitude​(Mat x, Mat y, Mat magnitude)
      计算二维向量的幅度。
      static double Mahalanobis​(Mat v1, Mat v2, Mat icovar)
      计算两个向量之间的马氏距离。
      静态 void max​(Mat src1, Mat src2, Mat dst)
      计算两个数组或一个数组和一个标量的逐元素最大值。
      静态 void max​(Mat src1, Scalar src2, Mat dst)  
      static Scalar mean​(Mat src)
      计算数组元素的平均值。
      static Scalar mean​(Mat src, Mat mask)
      计算数组元素的平均值。
      静态 void meanStdDev​(Mat src, MatOfDouble mean, MatOfDouble stddev)
      计算数组元素的均值和标准差。
      静态 void meanStdDev​(Mat src, MatOfDouble mean, MatOfDouble stddev, Mat mask)
      计算数组元素的均值和标准差。
      静态 void merge​(java.util.List<Mat> mv, Mat dst)  
      静态 void min​(Mat src1, Mat src2, Mat dst)
      计算两个数组或一个数组和一个标量的逐元素最小值。
      静态 void min​(Mat src1, Scalar src2, Mat dst)  
      static Core.MinMaxLocResult minMaxLoc​(Mat src)  
      static Core.MinMaxLocResult minMaxLoc​(Mat src, Mat mask)  
      静态 void mixChannels​(java.util.List<Mat> src, java.util.List<Mat> dst, MatOfInt fromTo)  
      静态 void mulSpectrums​(Mat a, Mat b, Mat c, int flags)
      执行两个傅里叶频谱的逐元素乘法。
      静态 void mulSpectrums​(Mat a, Mat b, Mat c, int flags, boolean conjB)
      执行两个傅里叶频谱的逐元素乘法。
      静态 void multiply​(Mat src1, Mat src2, Mat dst)
      计算两个数组的逐元素缩放乘积。
      静态 void multiply​(Mat src1, Mat src2, Mat dst, double scale)
      计算两个数组的逐元素缩放乘积。
      静态 void multiply​(Mat src1, Mat src2, Mat dst, double scale, int dtype)
      计算两个数组的逐元素缩放乘积。
      静态 void multiply​(Mat src1, Scalar src2, Mat dst)  
      静态 void multiply​(Mat src1, Scalar src2, Mat dst, double scale)  
      静态 void multiply​(Mat src1, Scalar src2, Mat dst, double scale, int dtype)  
      静态 void mulTransposed​(Mat src, Mat dst, boolean aTa)
      计算矩阵与其转置的乘积。
      静态 void mulTransposed​(Mat src, Mat dst, boolean aTa, Mat delta)
      计算矩阵与其转置的乘积。
      静态 void mulTransposed​(Mat src, Mat dst, boolean aTa, Mat delta, double scale)
      计算矩阵与其转置的乘积。
      静态 void mulTransposed​(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)
      计算矩阵与其转置的乘积。
      static double norm​(Mat src1)
      计算数组的绝对范数。
      static double norm​(Mat src1, int normType)
      计算数组的绝对范数。
      static double norm​(Mat src1, int normType, Mat mask)
      计算数组的绝对范数。
      static double norm​(Mat src1, Mat src2)
      计算绝对差范数或相对差范数。
      static double norm​(Mat src1, Mat src2, int normType)
      计算绝对差范数或相对差范数。
      static double norm​(Mat src1, Mat src2, int normType, Mat mask)
      计算绝对差范数或相对差范数。
      静态 void normalize​(Mat src, Mat dst)
      归一化数组的范数或值范围。
      静态 void normalize​(Mat src, Mat dst, double alpha)
      归一化数组的范数或值范围。
      静态 void normalize​(Mat src, Mat dst, double alpha, double beta)
      归一化数组的范数或值范围。
      静态 void normalize​(Mat src, Mat dst, double alpha, double beta, int norm_type)
      归一化数组的范数或值范围。
      静态 void normalize​(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)
      归一化数组的范数或值范围。
      静态 void normalize​(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)
      归一化数组的范数或值范围。
      静态 void patchNaNs​(Mat a)
      用给定数字替换NaN。
      静态 void patchNaNs​(Mat a, double val)
      用给定数字替换NaN。
      静态 void PCABackProject​(Mat data, Mat mean, Mat eigenvectors, Mat result)
      包装PCA::backProject。
      静态 void PCACompute​(Mat data, Mat mean, Mat eigenvectors)
      包装PCA::operator()。
      静态 void PCACompute​(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)
      包装PCA::operator()。
      静态 void PCACompute​(Mat data, Mat mean, Mat eigenvectors, int maxComponents)
      包装PCA::operator()。
      静态 void PCACompute2​(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues)
      包装PCA::operator()并添加特征值输出参数。
      静态 void PCACompute2​(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)
      包装PCA::operator()并添加特征值输出参数。
      静态 void PCACompute2​(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)
      包装PCA::operator()并添加特征值输出参数。
      静态 void PCAProject​(Mat data, Mat mean, Mat eigenvectors, Mat result)
      包装PCA::project。
      静态 void perspectiveTransform​(Mat src, Mat dst, Mat m)
      执行向量的透视矩阵变换。
      静态 void phase​(Mat x, Mat y, Mat angle)
      计算二维向量的旋转角度。
      静态 void phase​(Mat x, Mat y, Mat angle, boolean angleInDegrees)
      计算二维向量的旋转角度。
      静态 void polarToCart​(Mat magnitude, Mat angle, Mat x, Mat y)
      根据向量的幅度和角度计算其x和y坐标。
      静态 void polarToCart​(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)
      根据向量的幅度和角度计算其x和y坐标。
      静态 void pow​(Mat src, double power, Mat dst)
      将每个数组元素提升到一个幂。
      static double PSNR​(Mat src1, Mat src2)
      计算峰值信噪比(PSNR)图像质量指标。
      static double PSNR​(Mat src1, Mat src2, double R)
      计算峰值信噪比(PSNR)图像质量指标。
      静态 void randn​(Mat dst, double mean, double stddev)
      用正态分布的随机数填充数组。
      静态 void randShuffle​(Mat dst)
      随机打乱数组元素。
      静态 void randShuffle​(Mat dst, double iterFactor)
      随机打乱数组元素。
      静态 void randu​(Mat dst, double low, double high)
      生成单个均匀分布的随机数或随机数数组。
      静态 void reduce​(Mat src, Mat dst, int dim, int rtype)
      将矩阵简化为向量。
      静态 void reduce​(Mat src, Mat dst, int dim, int rtype, int dtype)
      将矩阵简化为向量。
      静态 void reduceArgMax​(Mat src, Mat dst, int axis)
      沿提供的轴查找最大元素的索引 注意： - 如果输入或输出数组不连续，此函数将创建内部副本。
      静态 void reduceArgMax​(Mat src, Mat dst, int axis, boolean lastIndex)
      沿提供的轴查找最大元素的索引 注意： - 如果输入或输出数组不连续，此函数将创建内部副本。
      静态 void reduceArgMin​(Mat src, Mat dst, int axis)
      沿提供的轴查找最小元素的索引 注意： - 如果输入或输出数组不连续，此函数将创建内部副本。
      静态 void reduceArgMin​(Mat src, Mat dst, int axis, boolean lastIndex)
      沿提供的轴查找最小元素的索引 注意： - 如果输入或输出数组不连续，此函数将创建内部副本。
      静态 void repeat​(Mat src, int ny, int nx, Mat dst)
      用输入数组的重复副本填充输出数组。
      静态 void rotate​(Mat src, Mat dst, int rotateCode)
      将二维数组旋转 90 度的倍数。
      静态 void scaleAdd​(Mat src1, double alpha, Mat src2, Mat dst)
      计算缩放后的数组和另一个数组的和。
      静态 void setErrorVerbosity​(boolean verbose)  
      静态 void setIdentity​(Mat mtx)
      初始化缩放后的单位矩阵。
      静态 void setIdentity​(Mat mtx, Scalar s)
      初始化缩放后的单位矩阵。
      静态 void setNumThreads​(int nthreads)
      OpenCV 将尝试为后续的并行区域设置线程数。
      静态 void setRNGSeed​(int seed)
      设置默认随机数生成器的状态。
      静态 void setUseIPP​(boolean flag)  
      静态 void setUseIPP_NotExact​(boolean flag)  
      静态 void setUseOptimized​(boolean onoff)
      启用或禁用优化代码。
      静态布尔值 solve​(Mat src1, Mat src2, Mat dst)
      求解一个或多个线性系统或最小二乘问题。
      静态布尔值 solve​(Mat src1, Mat src2, Mat dst, int flags)
      求解一个或多个线性系统或最小二乘问题。
      静态 int solveCubic​(Mat coeffs, Mat roots)
      查找三次方程的实根。
      static double solvePoly​(Mat coeffs, Mat roots)
      查找多项式方程的实数或复数根。
      static double solvePoly​(Mat coeffs, Mat roots, int maxIters)
      查找多项式方程的实数或复数根。
      静态 void sort​(Mat src, Mat dst, int flags)
      对矩阵的每一行或每一列进行排序。
      静态 void sortIdx​(Mat src, Mat dst, int flags)
      对矩阵的每一行或每一列进行排序。
      静态 void split​(Mat m, java.util.List<Mat> mv)  
      静态 void sqrt​(Mat src, Mat dst)
      计算数组元素的平方根。
      静态 void subtract​(Mat src1, Mat src2, Mat dst)
      计算两个数组或数组和标量之间的逐元素差。
      静态 void subtract​(Mat src1, Mat src2, Mat dst, Mat mask)
      计算两个数组或数组和标量之间的逐元素差。
      静态 void subtract​(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
      计算两个数组或数组和标量之间的逐元素差。
      静态 void subtract​(Mat src1, Scalar src2, Mat dst)  
      静态 void subtract​(Mat src1, Scalar src2, Mat dst, Mat mask)  
      静态 void subtract​(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)  
      static Scalar sumElems​(Mat src)
      计算数组元素的和。
      静态 void SVBackSubst​(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)
      包装 SVD::backSubst
      静态 void SVDecomp​(Mat src, Mat w, Mat u, Mat vt)
      封装 SVD::compute
      静态 void SVDecomp​(Mat src, Mat w, Mat u, Mat vt, int flags)
      封装 SVD::compute
      static Scalar trace​(Mat mtx)
      返回矩阵的迹。
      静态 void transform​(Mat src, Mat dst, Mat m)
      执行每个数组元素的矩阵变换。
      静态 void transpose​(Mat src, Mat dst)
      转置矩阵。
      静态 void transposeND​(Mat src, MatOfInt order, Mat dst)
      N维矩阵的转置。
      静态布尔值 使用IPP()
      hal::Cholesky 的代理
      静态布尔值 使用IPP_NotExact()  
      静态布尔值 useOptimized()
      返回优化代码使用的状态。
      静态 void vconcat​(java.util.List<Mat> src, Mat dst)
      std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)), cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)), cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),}; cv::Mat out; cv::vconcat( matrices, out ); //out: //[1, 1, 1, 1; // 2, 2, 2, 2; // 3, 3, 3, 3]

      • 继承自类 java.lang.Object 的方法

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • 字段详情

      • VERSION

        public static final java.lang.String VERSION

      • NATIVE_LIBRARY_NAME

        public static final java.lang.String NATIVE_LIBRARY_NAME

      • VERSION_MAJOR

        public static final int VERSION_MAJOR

      • VERSION_MINOR

        public static final int VERSION_MINOR

      • VERSION_REVISION

        public static final int VERSION_REVISION

      • VERSION_STATUS

        public static final java.lang.String VERSION_STATUS

      • SVD_MODIFY_A

        public static final int SVD_MODIFY_A
        另请参阅
        常量字段值

      • SVD_NO_UV

        public static final int SVD_NO_UV
        另请参阅
        常量字段值

      • SVD_FULL_UV

        public static final int SVD_FULL_UV
        另请参阅
        常量字段值

      • REDUCE_SUM

        public static final int REDUCE_SUM
        另请参阅
        常量字段值

      • REDUCE_AVG

        public static final int REDUCE_AVG
        另请参阅
        常量字段值

      • REDUCE_MAX

        public static final int REDUCE_MAX
        另请参阅
        常量字段值

      • REDUCE_MIN

        public static final int REDUCE_MIN
        另请参阅
        常量字段值

      • RNG_UNIFORM

        public static final int RNG_UNIFORM
        另请参阅
        常量字段值

      • RNG_NORMAL

        public static final int RNG_NORMAL
        另请参阅
        常量字段值

      • ALGO_HINT_DEFAULT

        public static final int ALGO_HINT_DEFAULT
        另请参阅
        常量字段值

      • ALGO_HINT_ACCURATE

        public static final int ALGO_HINT_ACCURATE
        另请参阅
        常量字段值

      • ALGO_HINT_APPROX

        public static final int ALGO_HINT_APPROX
        另请参阅
        常量字段值

      • BORDER_CONSTANT

        public static final int BORDER_CONSTANT
        另请参阅
        常量字段值

      • BORDER_REPLICATE

        public static final int BORDER_REPLICATE
        另请参阅
        常量字段值

      • BORDER_REFLECT

        public static final int BORDER_REFLECT
        另请参阅
        常量字段值

      • BORDER_WRAP

        public static final int BORDER_WRAP
        另请参阅
        常量字段值

      • BORDER_REFLECT_101

        public static final int BORDER_REFLECT_101
        另请参阅
        常量字段值

      • BORDER_TRANSPARENT

        public static final int BORDER_TRANSPARENT
        另请参阅
        常量字段值

      • BORDER_REFLECT101

        public static final int BORDER_REFLECT101
        另请参阅
        常量字段值

      • BORDER_DEFAULT

        public static final int BORDER_DEFAULT
        另请参阅
        常量字段值

      • BORDER_ISOLATED

        public static final int BORDER_ISOLATED
        另请参阅
        常量字段值

      • COVAR_SCRAMBLED

        public static final int COVAR_SCRAMBLED
        另请参阅
        常量字段值

      • COVAR_NORMAL

        public static final int COVAR_NORMAL
        另请参阅
        常量字段值

      • COVAR_USE_AVG

        public static final int COVAR_USE_AVG
        另请参阅
        常量字段值

      • COVAR_SCALE

        public static final int COVAR_SCALE
        另请参阅
        常量字段值

      • COVAR_ROWS

        public static final int COVAR_ROWS
        另请参阅
        常量字段值

      • COVAR_COLS

        public static final int COVAR_COLS
        另请参阅
        常量字段值

      • DECOMP_LU

        public static final int DECOMP_LU
        另请参阅
        常量字段值

      • DECOMP_SVD

        public static final int DECOMP_SVD
        另请参阅
        常量字段值

      • DECOMP_EIG

        public static final int DECOMP_EIG
        另请参阅
        常量字段值

      • DECOMP_CHOLESKY

        public static final int DECOMP_CHOLESKY
        另请参阅
        常量字段值

      • DECOMP_QR

        public static final int DECOMP_QR
        另请参阅
        常量字段值

      • DECOMP_NORMAL

        public static final int DECOMP_NORMAL
        另请参阅
        常量字段值

      • DFT_INVERSE

        public static final int DFT_INVERSE
        另请参阅
        常量字段值

      • DFT_SCALE

        public static final int DFT_SCALE
        另请参阅
        常量字段值

      • DFT_COMPLEX_OUTPUT

        public static final int DFT_COMPLEX_OUTPUT
        另请参阅
        常量字段值

      • DFT_REAL_OUTPUT

        public static final int DFT_REAL_OUTPUT
        另请参阅
        常量字段值

      • DFT_COMPLEX_INPUT

        public static final int DFT_COMPLEX_INPUT
        另请参阅
        常量字段值

      • DCT_INVERSE

        public static final int DCT_INVERSE
        另请参阅
        常量字段值

      • StsBackTrace

        public static final int StsBackTrace
        另请参阅
        常量字段值

      • StsInternal

        public static final int StsInternal
        另请参阅
        常量字段值

      • StsBadArg

        public static final int StsBadArg
        另请参阅
        常量字段值

      • StsBadFunc

        public static final int StsBadFunc
        另请参阅
        常量字段值

      • StsNoConv

        public static final int StsNoConv
        另请参阅
        常量字段值

      • StsAutoTrace

        public static final int StsAutoTrace
        另请参阅
        常量字段值

      • HeaderIsNull

        public static final int HeaderIsNull
        另请参阅
        常量字段值

      • BadImageSize

        public static final int BadImageSize
        另请参阅
        常量字段值

      • BadOffset

        public static final int BadOffset
        另请参阅
        常量字段值

      • BadDataPtr

        public static final int BadDataPtr
        另请参阅
        常量字段值

      • BadModelOrChSeq

        public static final int BadModelOrChSeq
        另请参阅
        常量字段值

      • BadNumChannels

        public static final int BadNumChannels
        另请参阅
        常量字段值

      • BadNumChannel1U

        public static final int BadNumChannel1U
        另请参阅
        常量字段值

      • BadAlphaChannel

        public static final int BadAlphaChannel
        另请参阅
        常量字段值

      • BadOrigin

        public static final int BadOrigin
        另请参阅
        常量字段值

      • BadCallBack

        public static final int BadCallBack
        另请参阅
        常量字段值

      • BadTileSize

        public static final int BadTileSize
        另请参阅
        常量字段值

      • BadROISize

        public static final int BadROISize
        另请参阅
        常量字段值

      • MaskIsTiled

        public static final int MaskIsTiled
        另请参阅
        常量字段值

      • StsNullPtr

        public static final int StsNullPtr
        另请参阅
        常量字段值

      • StsVecLengthErr

        public static final int StsVecLengthErr
        另请参阅
        常量字段值

      • StsFilterStructContentErr

        public static final int StsFilterStructContentErr
        另请参阅
        常量字段值

      • StsKernelStructContentErr

        public static final int StsKernelStructContentErr
        另请参阅
        常量字段值

      • StsFilterOffsetErr

        public static final int StsFilterOffsetErr
        另请参阅
        常量字段值

      • StsBadSize

        public static final int StsBadSize
        另请参阅
        常量字段值

      • StsDivByZero

        public static final int StsDivByZero
        另请参阅
        常量字段值

      • StsInplaceNotSupported

        public static final int StsInplaceNotSupported
        另请参阅
        常量字段值

      • StsObjectNotFound

        public static final int StsObjectNotFound
        另请参阅
        常量字段值

      • StsUnmatchedFormats

        public static final int StsUnmatchedFormats
        另请参阅
        常量字段值

      • StsBadFlag

        public static final int StsBadFlag
        另请参阅
        常量字段值

      • StsBadPoint

        public static final int StsBadPoint
        另请参阅
        常量字段值

      • StsBadMask

        public static final int StsBadMask
        另请参阅
        常量字段值

      • StsUnmatchedSizes

        public static final int StsUnmatchedSizes
        另请参阅
        常量字段值

      • StsUnsupportedFormat

        public static final int StsUnsupportedFormat
        另请参阅
        常量字段值

      • StsOutOfRange

        public static final int StsOutOfRange
        另请参阅
        常量字段值

      • StsParseError

        public static final int StsParseError
        另请参阅
        常量字段值

      • StsNotImplemented

        public static final int StsNotImplemented
        另请参阅
        常量字段值

      • StsBadMemBlock

        public static final int StsBadMemBlock
        另请参阅
        常量字段值

      • StsAssert

        public static final int StsAssert
        另请参阅
        常量字段值

      • GpuNotSupported

        public static final int GpuNotSupported
        另请参阅
        常量字段值

      • GpuApiCallError

        public static final int GpuApiCallError
        另请参阅
        常量字段值

      • OpenGlNotSupported

        public static final int OpenGlNotSupported
        另请参阅
        常量字段值

      • OpenGlApiCallError

        public static final int OpenGlApiCallError
        另请参阅
        常量字段值

      • OpenCLApiCallError

        public static final int OpenCLApiCallError
        另请参阅
        常量字段值

      • OpenCLDoubleNotSupported

        public static final int OpenCLDoubleNotSupported
        另请参阅
        常量字段值

      • OpenCLInitError

        public static final int OpenCLInitError
        另请参阅
        常量字段值

      • OpenCLNoAMDBlasFft

        public static final int OpenCLNoAMDBlasFft
        另请参阅
        常量字段值

      • Formatter_FMT_DEFAULT

        public static final int Formatter_FMT_DEFAULT
        另请参阅
        常量字段值

      • Formatter_FMT_MATLAB

        public static final int Formatter_FMT_MATLAB
        另请参阅
        常量字段值

      • Formatter_FMT_CSV

        public static final int Formatter_FMT_CSV
        另请参阅
        常量字段值

      • Formatter_FMT_PYTHON

        public static final int Formatter_FMT_PYTHON
        另请参阅
        常量字段值

      • Formatter_FMT_NUMPY

        public static final int Formatter_FMT_NUMPY
        另请参阅
        常量字段值

      • Formatter_FMT_C

        public static final int Formatter_FMT_C
        另请参阅
        常量字段值

      • KMEANS_RANDOM_CENTERS

        public static final int KMEANS_RANDOM_CENTERS
        另请参阅
        常量字段值

      • KMEANS_PP_CENTERS

        public static final int KMEANS_PP_CENTERS
        另请参阅
        常量字段值

      • KMEANS_USE_INITIAL_LABELS

        public static final int KMEANS_USE_INITIAL_LABELS
        另请参阅
        常量字段值

      • NORM_L2SQR

        public static final int NORM_L2SQR
        另请参阅
        常量字段值

      • NORM_HAMMING

        public static final int NORM_HAMMING
        另请参阅
        常量字段值

      • NORM_HAMMING2

        public static final int NORM_HAMMING2
        另请参阅
        常量字段值

      • NORM_TYPE_MASK

        public static final int NORM_TYPE_MASK
        另请参阅
        常量字段值

      • NORM_RELATIVE

        public static final int NORM_RELATIVE
        另请参阅
        常量字段值

      • NORM_MINMAX

        public static final int NORM_MINMAX
        另请参阅
        常量字段值

      • PCA_DATA_AS_ROW

        public static final int PCA_DATA_AS_ROW
        另请参阅
        常量字段值

      • PCA_DATA_AS_COL

        public static final int PCA_DATA_AS_COL
        另请参阅
        常量字段值

      • PCA_USE_AVG

        public static final int PCA_USE_AVG
        另请参阅
        常量字段值

      • Param_INT

        public static final int Param_INT
        另请参阅
        常量字段值

      • Param_BOOLEAN

        public static final int Param_BOOLEAN
        另请参阅
        常量字段值

      • Param_REAL

        public static final int Param_REAL
        另请参阅
        常量字段值

      • Param_STRING

        public static final int Param_STRING
        另请参阅
        常量字段值

      • Param_MAT

        public static final int Param_MAT
        另请参阅
        常量字段值

      • Param_MAT_VECTOR

        public static final int Param_MAT_VECTOR
        另请参阅
        常量字段值

      • Param_ALGORITHM

        public static final int Param_ALGORITHM
        另请参阅
        常量字段值

      • Param_FLOAT

        public static final int Param_FLOAT
        另请参阅
        常量字段值

      • Param_UNSIGNED_INT

        public static final int Param_UNSIGNED_INT
        另请参阅
        常量字段值

      • Param_UINT64

        public static final int Param_UINT64
        另请参阅
        常量字段值

      • Param_UCHAR

        public static final int Param_UCHAR
        另请参阅
        常量字段值

      • Param_SCALAR

        public static final int Param_SCALAR
        另请参阅
        常量字段值

      • REDUCE_SUM2

        public static final int REDUCE_SUM2
        另请参阅
        常量字段值

      • ROTATE_90_CLOCKWISE

        public static final int ROTATE_90_CLOCKWISE
        另请参阅
        常量字段值

      • ROTATE_180

        public static final int ROTATE_180
        另请参阅
        常量字段值

      • ROTATE_90_COUNTERCLOCKWISE

        public static final int ROTATE_90_COUNTERCLOCKWISE
        另请参阅
        常量字段值

      • SORT_EVERY_ROW

        public static final int SORT_EVERY_ROW
        另请参阅
        常量字段值

      • SORT_EVERY_COLUMN

        public static final int SORT_EVERY_COLUMN
        另请参阅
        常量字段值

      • SORT_ASCENDING

        public static final int SORT_ASCENDING
        另请参阅
        常量字段值

      • SORT_DESCENDING

        public static final int SORT_DESCENDING
        另请参阅
        常量字段值

    • 构造函数详情

      • Core

        public Core()

    • 方法详情

      • cubeRoot

        public static float cubeRoot​(float val)
        计算参数的立方根。函数 cubeRoot 计算 \(\sqrt[3]{\texttt{val}}\)。负参数处理正确。不处理 NaN 和 Inf。精度接近单精度数据的最大可能精度。
        参数
        val - 函数参数。
        返回
        自动生成

      • fastAtan2

        public static float fastAtan2​(float y,
                              float x)
        以度为单位计算二维向量的角度。函数 fastAtan2 计算输入二维向量的全范围角度。角度以度为单位测量，范围从 0 到 360 度。精度约为 0.3 度。
        参数
        x - 向量的 x 坐标。
        y - 向量的 y 坐标。
        返回
        自动生成

      • 使用IPP

        public static boolean useIPP()
        hal::Cholesky 的代理
        返回
        自动生成

      • setUseIPP

        public static void setUseIPP​(boolean flag)

      • getIppVersion

        public static java.lang.String getIppVersion()

      • 使用IPP_NotExact

        public static boolean useIPP_NotExact()

      • setUseIPP_NotExact

        public static void setUseIPP_NotExact​(boolean flag)

      • borderInterpolate

        public static int borderInterpolate​(int p,
                                    int len,
                                    int borderType)
        计算外推像素的源位置。当使用指定的外推边界模式时，该函数计算并返回对应于指定外推像素的供体像素的坐标。例如，如果您在水平方向上使用 cv::BORDER_WRAP 模式，在垂直方向上使用 cv::BORDER_REFLECT_101 模式，并且想要计算浮点图像 img 中“虚拟”像素 Point(-5, 100) 的值，则看起来像： float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101), borderInterpolate(-5, img.cols, cv::BORDER_WRAP)); 通常，函数不会直接调用。它用于过滤函数内部以及 copyMakeBorder 中。
        参数
        p - 沿其中一个轴的外推像素的基于 0 的坐标，可能 <0 或 >= len
        len - 沿相应轴的数组长度。
        borderType - 边界类型，#BorderTypes 之一，除了 #BORDER_TRANSPARENT 和 #BORDER_ISOLATED。当 borderType==#BORDER_CONSTANT 时，函数始终返回 -1，而不管 p 和 len 如何。参见：copyMakeBorder
        返回
        自动生成

      • copyMakeBorder

        public static void copyMakeBorder​(Mat src,
                                  Mat dst,
                                  int top,
                                  int bottom,
                                  int left,
                                  int right,
                                  int borderType,
                                  Scalar value)
        在图像周围形成边界。该函数将源图像复制到目标图像的中间。复制的源图像左侧、右侧、上方和下方的区域将填充外推像素。这与基于它的过滤函数所做的不同（它们动态外推像素），而是其他更复杂的函数（包括你自己的函数）可能为了简化图像边界处理而做的事情。该函数支持 src 已经在 dst 中间的情况。在这种情况下，函数本身不复制 src，而只是构建边界，例如： // 让边界在所有方向上都相同 int border=2; // 构造一个更大的图像以适应图像和边界 Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth()); // 选择它的中间部分，无需复制数据 Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows)); // 将图像从 RGB 转换为灰度 cvtColor(rgb, gray, COLOR_RGB2GRAY); // 就地形成边界 copyMakeBorder(gray, gray_buf, border, border, border, border, BORDER_REPLICATE); // 现在进行一些自定义过滤 ... ... 注意：当源图像是较大图像的一部分 (ROI) 时，该函数将尝试使用 ROI 外部的像素来形成边界。要禁用此功能并始终执行外推，就像 src 不是 ROI 一样，请使用 borderType | #BORDER_ISOLATED。
        参数
        src - 源图像。
        dst - 与 src 类型相同且大小为 Size(src.cols+left+right, src.rows+top+bottom) 的目标图像。
        top - 上方的像素
        bottom - 下方的像素
        left - 左侧的像素
        right - 指定从源图像矩形沿各个方向外推多少像素的参数。例如，top=1，bottom=1，left=1，right=1 表示需要构建 1 像素宽的边界。
        borderType - 边界类型。有关详细信息，请参阅 borderInterpolate。
        value - 如果 borderType==BORDER_CONSTANT，则为边界值。参见：borderInterpolate

      • copyMakeBorder

        public static void copyMakeBorder​(Mat src,
                                  Mat dst,
                                  int top,
                                  int bottom,
                                  int left,
                                  int right,
                                  int borderType)
        在图像周围形成边界。该函数将源图像复制到目标图像的中间。复制的源图像左侧、右侧、上方和下方的区域将填充外推像素。这与基于它的过滤函数所做的不同（它们动态外推像素），而是其他更复杂的函数（包括你自己的函数）可能为了简化图像边界处理而做的事情。该函数支持 src 已经在 dst 中间的情况。在这种情况下，函数本身不复制 src，而只是构建边界，例如： // 让边界在所有方向上都相同 int border=2; // 构造一个更大的图像以适应图像和边界 Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth()); // 选择它的中间部分，无需复制数据 Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows)); // 将图像从 RGB 转换为灰度 cvtColor(rgb, gray, COLOR_RGB2GRAY); // 就地形成边界 copyMakeBorder(gray, gray_buf, border, border, border, border, BORDER_REPLICATE); // 现在进行一些自定义过滤 ... ... 注意：当源图像是较大图像的一部分 (ROI) 时，该函数将尝试使用 ROI 外部的像素来形成边界。要禁用此功能并始终执行外推，就像 src 不是 ROI 一样，请使用 borderType | #BORDER_ISOLATED。
        参数
        src - 源图像。
        dst - 与 src 类型相同且大小为 Size(src.cols+left+right, src.rows+top+bottom) 的目标图像。
        top - 上方的像素
        bottom - 下方的像素
        left - 左侧的像素
        right - 指定从源图像矩形沿各个方向外推多少像素的参数。例如，top=1，bottom=1，left=1，right=1 表示需要构建 1 像素宽的边界。
        borderType - 边界类型。有关详细信息，请参阅 borderInterpolate。参见：borderInterpolate

      • add

        public static void add​(Mat src1,
                       Mat src2,
                       Mat dst,
                       Mat mask,
                       int dtype)
        计算两个数组或一个数组和一个标量的逐元素和。函数 add 计算
        • 当两个输入数组具有相同的大小和相同数量的通道时，两个数组的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • 当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时，数组和标量的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • 当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时，标量和数组的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。
        上述列表中的第一个函数可以用矩阵表达式替换： dst = src1 + src2; dst += src1; // 等效于 add(dst, src1, dst); 输入数组和输出数组都可以具有相同或不同的深度。例如，您可以将一个 16 位无符号数组添加到一个 8 位有符号数组中，并将和存储为一个 32 位浮点数组。输出数组的深度由 dtype 参数决定。在上述第二和第三种情况下，以及在第一种情况下，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。在溢出的情况下，您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。add(src,X) 表示 add(src,(X,X,X,X))。add(src,(X,)) 表示 add(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，其大小和通道数与输入数组相同；深度由 dtype 或 src1/src2 定义。
        mask - 可选的操作掩码 - 8 位单通道数组，指定要更改的输出数组元素。
        dtype - 可选的输出数组深度（参见下面的讨论）。参见：subtract、addWeighted、scaleAdd、Mat::convertTo

      • add

        public static void add​(Mat src1,
                       Mat src2,
                       Mat dst,
                       Mat mask)
        计算两个数组或一个数组和一个标量的逐元素和。函数 add 计算
        • 当两个输入数组具有相同的大小和相同数量的通道时，两个数组的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • 当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时，数组和标量的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • 当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时，标量和数组的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。
        上述列表中的第一个函数可以用矩阵表达式替换： dst = src1 + src2; dst += src1; // 等效于 add(dst, src1, dst); 输入数组和输出数组都可以具有相同或不同的深度。例如，您可以将一个 16 位无符号数组添加到一个 8 位有符号数组中，并将和存储为一个 32 位浮点数组。输出数组的深度由 dtype 参数决定。在上述第二和第三种情况下，以及在第一种情况下，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。在溢出的情况下，您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。add(src,X) 表示 add(src,(X,X,X,X))。add(src,(X,)) 表示 add(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，其大小和通道数与输入数组相同；深度由 dtype 或 src1/src2 定义。
        mask - 可选的操作掩码 - 8 位单通道数组，指定要更改的输出数组元素。参见：subtract、addWeighted、scaleAdd、Mat::convertTo

      • add

        public static void add​(Mat src1,
                       Mat src2,
                       Mat dst)
        计算两个数组或一个数组和一个标量的逐元素和。函数 add 计算
        • 当两个输入数组具有相同的大小和相同数量的通道时，两个数组的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • 当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时，数组和标量的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • 当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时，标量和数组的和：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。
        上述列表中的第一个函数可以用矩阵表达式替换： dst = src1 + src2; dst += src1; // 等效于 add(dst, src1, dst); 输入数组和输出数组都可以具有相同或不同的深度。例如，您可以将一个 16 位无符号数组添加到一个 8 位有符号数组中，并将和存储为一个 32 位浮点数组。输出数组的深度由 dtype 参数决定。在上述第二和第三种情况下，以及在第一种情况下，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。在溢出的情况下，您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。add(src,X) 表示 add(src,(X,X,X,X))。add(src,(X,)) 表示 add(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，其大小和通道数与输入数组相同；深度由 dtype 或 src1/src2 定义。要更改的输出数组。参见：subtract、addWeighted、scaleAdd、Mat::convertTo

      • subtract

        public static void subtract​(Mat src1,
                            Mat src2,
                            Mat dst,
                            Mat mask,
                            int dtype)
        计算两个数组或数组和标量之间的逐元素差。subtract 函数计算
        • 两个数组之间的差值，当两个输入数组具有相同的大小和相同数量的通道时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • 数组和标量之间的差值，当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • 标量和数组之间的差值，当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
        • 在 SubRS 的情况下，标量和数组之间的反向差值：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。
        上述列表中的第一个函数可以用矩阵表达式替换： dst = src1 - src2; dst -= src1; // 等效于 subtract(dst, src1, dst); 输入数组和输出数组都可以具有相同或不同的深度。例如，您可以将两个 8 位无符号数组相减，并将差值存储在一个 16 位有符号数组中。输出数组的深度由 dtype 参数决定。在上述第二和第三种情况下，以及在第一种情况下，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。在溢出的情况下，您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。subtract(src,X) 表示 subtract(src,(X,X,X,X))。subtract(src,(X,)) 表示 subtract(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 与输入数组大小和通道数相同的输出数组。
        mask - 可选的操作掩码；这是一个 8 位单通道数组，指定要更改的输出数组元素。
        dtype - 可选的输出数组深度 参见：add、addWeighted、scaleAdd、Mat::convertTo

      • subtract

        public static void subtract​(Mat src1,
                            Mat src2,
                            Mat dst,
                            Mat mask)
        计算两个数组或数组和标量之间的逐元素差。subtract 函数计算
        • 两个数组之间的差值，当两个输入数组具有相同的大小和相同数量的通道时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • 数组和标量之间的差值，当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • 标量和数组之间的差值，当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
        • 在 SubRS 的情况下，标量和数组之间的反向差值：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。
        上述列表中的第一个函数可以用矩阵表达式替换： dst = src1 - src2; dst -= src1; // 等效于 subtract(dst, src1, dst); 输入数组和输出数组都可以具有相同或不同的深度。例如，您可以将两个 8 位无符号数组相减，并将差值存储在一个 16 位有符号数组中。输出数组的深度由 dtype 参数决定。在上述第二和第三种情况下，以及在第一种情况下，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。在溢出的情况下，您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。subtract(src,X) 表示 subtract(src,(X,X,X,X))。subtract(src,(X,)) 表示 subtract(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 与输入数组大小和通道数相同的输出数组。
        mask - 可选的操作掩码；这是一个 8 位单通道数组，指定要更改的输出数组元素。参见：add、addWeighted、scaleAdd、Mat::convertTo

      • subtract

        public static void subtract​(Mat src1,
                            Mat src2,
                            Mat dst)
        计算两个数组或数组和标量之间的逐元素差。subtract 函数计算
        • 两个数组之间的差值，当两个输入数组具有相同的大小和相同数量的通道时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • 数组和标量之间的差值，当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • 标量和数组之间的差值，当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
        • 在 SubRS 的情况下，标量和数组之间的反向差值：\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。
        上述列表中的第一个函数可以用矩阵表达式替换： dst = src1 - src2; dst -= src1; // 等效于 subtract(dst, src1, dst); 输入数组和输出数组都可以具有相同或不同的深度。例如，您可以将两个 8 位无符号数组相减，并将差值存储在一个 16 位有符号数组中。输出数组的深度由 dtype 参数决定。在上述第二和第三种情况下，以及在第一种情况下，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。在溢出的情况下，您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。subtract(src,X) 表示 subtract(src,(X,X,X,X))。subtract(src,(X,)) 表示 subtract(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 与输入数组大小和通道数相同的输出数组。要更改的输出数组。参见：add、addWeighted、scaleAdd、Mat::convertTo

      • multiply

        public static void multiply​(Mat src1,
                            Mat src2,
                            Mat dst,
                            double scale,
                            int dtype)
        计算两个数组的逐元素缩放乘积。multiply 函数计算两个数组的逐元素乘积：\(\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\) 第一个函数还有一个 REF: MatrixExpressions 友好的变体。参见 Mat::mul 。对于非逐元素矩阵乘积，参见 gemm 。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。multiply(src,X) 表示 multiply(src,(X,X,X,X))。multiply(src,(X,)) 表示 multiply(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src1 大小和类型相同的输出数组。
        scale - 可选的比例因子。
        dtype - 可选的输出数组深度 参见：add、subtract、divide、scaleAdd、addWeighted、accumulate、accumulateProduct、accumulateSquare、Mat::convertTo

      • multiply

        public static void multiply​(Mat src1,
                            Mat src2,
                            Mat dst,
                            double scale)
        计算两个数组的逐元素缩放乘积。multiply 函数计算两个数组的逐元素乘积：\(\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\) 第一个函数还有一个 REF: MatrixExpressions 友好的变体。参见 Mat::mul 。对于非逐元素矩阵乘积，参见 gemm 。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。multiply(src,X) 表示 multiply(src,(X,X,X,X))。multiply(src,(X,)) 表示 multiply(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src1 大小和类型相同的输出数组。
        scale - 可选的比例因子。参见：add、subtract、divide、scaleAdd、addWeighted、accumulate、accumulateProduct、accumulateSquare、Mat::convertTo

      • multiply

        public static void multiply​(Mat src1,
                            Mat src2,
                            Mat dst)
        计算两个数组的逐元素缩放乘积。multiply 函数计算两个数组的逐元素乘积：\(\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\) 第一个函数还有一个 REF: MatrixExpressions 友好的变体。参见 Mat::mul 。对于非逐元素矩阵乘积，参见 gemm 。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。multiply(src,X) 表示 multiply(src,(X,X,X,X))。multiply(src,(X,)) 表示 multiply(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src1 大小和类型相同的输出数组。参见：add、subtract、divide、scaleAdd、addWeighted、accumulate、accumulateProduct、accumulateSquare、Mat::convertTo

      • divide

        public static void divide​(Mat src1,
                          Mat src2,
                          Mat dst,
                          double scale,
                          int dtype)
        执行两个数组或标量除以数组的逐元素除法。cv::divide 函数将一个数组除以另一个数组：\(\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\) 或当没有 src1 时，标量除以数组：\(\texttt{dst(I) = saturate(scale/src2(I))}\) 多通道数组的不同通道独立处理。对于整数类型，当 src2(I) 为零时，dst(I) 也将为零。注意：对于浮点数据，没有为零 src2(I) 值定义特殊行为。使用常规浮点除法。预期浮点数据的正确 IEEE-754 行为（具有 NaN、Inf 结果值）。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。divide(src,X) 表示 divide(src,(X,X,X,X))。divide(src,(X,)) 表示 divide(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        scale - 标量因子。
        dst - 与 src2 大小和类型相同的输出数组。
        dtype - 可选的输出数组深度；如果为 -1，则 dst 将具有深度 src2.depth()，但在数组除以数组的情况下，只有当 src1.depth()==src2.depth() 时才能传递 -1。参见：multiply、add、subtract

      • divide

        public static void divide​(Mat src1,
                          Mat src2,
                          Mat dst,
                          double scale)
        执行两个数组或标量除以数组的逐元素除法。cv::divide 函数将一个数组除以另一个数组：\(\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\) 或当没有 src1 时，标量除以数组：\(\texttt{dst(I) = saturate(scale/src2(I))}\) 多通道数组的不同通道独立处理。对于整数类型，当 src2(I) 为零时，dst(I) 也将为零。注意：对于浮点数据，没有为零 src2(I) 值定义特殊行为。使用常规浮点除法。预期浮点数据的正确 IEEE-754 行为（具有 NaN、Inf 结果值）。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。divide(src,X) 表示 divide(src,(X,X,X,X))。divide(src,(X,)) 表示 divide(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        scale - 标量因子。
        dst - 与 src2 大小和类型相同的输出数组。在数组除以数组的情况下，只有当 src1.depth()==src2.depth() 时才能传递 -1。参见：multiply、add、subtract

      • divide

        public static void divide​(Mat src1,
                          Mat src2,
                          Mat dst)
        执行两个数组或标量除以数组的逐元素除法。cv::divide 函数将一个数组除以另一个数组：\(\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\) 或当没有 src1 时，标量除以数组：\(\texttt{dst(I) = saturate(scale/src2(I))}\) 多通道数组的不同通道独立处理。对于整数类型，当 src2(I) 为零时，dst(I) 也将为零。注意：对于浮点数据，没有为零 src2(I) 值定义特殊行为。使用常规浮点除法。预期浮点数据的正确 IEEE-754 行为（具有 NaN、Inf 结果值）。注意：当输出数组的深度为 CV_32S 时，不会应用饱和度。您甚至可能得到错误符号的结果。注意：（Python）请注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。divide(src,X) 表示 divide(src,(X,X,X,X))。divide(src,(X,)) 表示 divide(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src2 大小和类型相同的输出数组。在数组除以数组的情况下，只有当 src1.depth()==src2.depth() 时才能传递 -1。参见：multiply、add、subtract

      • divide

        public static void divide​(double scale,
                          Mat src2,
                          Mat dst,
                          int dtype)

      • divide

        public static void divide​(double scale,
                          Mat src2,
                          Mat dst)

      • scaleAdd

        public static void scaleAdd​(Mat src1,
                            double alpha,
                            Mat src2,
                            Mat dst)
        计算缩放数组与另一个数组的和。scaleAdd 函数是经典的原始线性代数运算之一，在 [BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) 中被称为 DAXPY 或 SAXPY。它计算缩放数组与另一个数组的和：\(\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)\) 该函数也可以用矩阵表达式模拟，例如： Mat A(3, 3, CV_64F); ... A.row(0) = A.row(1)*2 + A.row(2);
        参数
        src1 - 第一个输入数组。
        alpha - 第一个数组的缩放因子。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src1 大小和类型相同的输出数组。参见：add、addWeighted、subtract、Mat::dot、Mat::convertTo

      • addWeighted

        public static void addWeighted​(Mat src1,
                               double alpha,
                               Mat src2,
                               double beta,
                               double gamma,
                               Mat dst,
                               int dtype)
        计算两个数组的加权和。addWeighted 函数按如下方式计算两个数组的加权和：\(\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。该函数可以用矩阵表达式替换： dst = src1*alpha + src2*beta + gamma; **注意：**当输出数组的深度为 CV_32S 时，不应用饱和度。在溢出的情况下，甚至可能得到错误符号的结果。
        参数
        src1 - 第一个输入数组。
        alpha - 第一个数组元素的权重。
        src2 - 第二个输入数组，大小和通道数与 src1 相同。
        beta - 第二个数组元素的权重。
        gamma - 加到每个和中的标量。
        dst - 输出数组，大小和通道数与输入数组相同。
        dtype - 输出数组的可选深度；当两个输入数组具有相同的深度时，dtype 可以设置为 -1，这将等效于 src1.depth()。参见：add、subtract、scaleAdd、Mat::convertTo

      • addWeighted

        public static void addWeighted​(Mat src1,
                               double alpha,
                               Mat src2,
                               double beta,
                               double gamma,
                               Mat dst)
        计算两个数组的加权和。addWeighted 函数按如下方式计算两个数组的加权和：\(\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。该函数可以用矩阵表达式替换： dst = src1*alpha + src2*beta + gamma; **注意：**当输出数组的深度为 CV_32S 时，不应用饱和度。在溢出的情况下，甚至可能得到错误符号的结果。
        参数
        src1 - 第一个输入数组。
        alpha - 第一个数组元素的权重。
        src2 - 第二个输入数组，大小和通道数与 src1 相同。
        beta - 第二个数组元素的权重。
        gamma - 加到每个和中的标量。
        dst - 输出数组，大小和通道数与输入数组相同。可以设置为 -1，这将等效于 src1.depth()。参见：add、subtract、scaleAdd、Mat::convertTo

      • convertScaleAbs

        public static void convertScaleAbs​(Mat src,
                                   Mat dst,
                                   double alpha,
                                   double beta)
        缩放、计算绝对值并将结果转换为 8 位。对于输入数组的每个元素，convertScaleAbs 函数按顺序执行三个操作：缩放、取绝对值、转换为无符号 8 位类型：\(\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\) 对于多通道数组，该函数独立处理每个通道。当输出不是 8 位时，可以通过调用 Mat::convertTo 方法（或使用矩阵表达式）然后计算结果的绝对值来模拟该操作。例如： Mat_<float> A(30,30); randu(A, Scalar(-100), Scalar(100)); Mat_<float> B = A*5 + 3; B = abs(B); // Mat_<float> B = abs(A*5+3) will also do the job, // but it will allocate a temporary matrix
        参数
        src - 输入数组。
        dst - 输出数组。
        alpha - 可选缩放因子。
        beta - 可选地添加到缩放值中的增量。参见：Mat::convertTo、cv::abs(const Mat&)

      • convertScaleAbs

        public static void convertScaleAbs​(Mat src,
                                   Mat dst,
                                   double alpha)
        缩放、计算绝对值并将结果转换为 8 位。对于输入数组的每个元素，convertScaleAbs 函数按顺序执行三个操作：缩放、取绝对值、转换为无符号 8 位类型：\(\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\) 对于多通道数组，该函数独立处理每个通道。当输出不是 8 位时，可以通过调用 Mat::convertTo 方法（或使用矩阵表达式）然后计算结果的绝对值来模拟该操作。例如： Mat_<float> A(30,30); randu(A, Scalar(-100), Scalar(100)); Mat_<float> B = A*5 + 3; B = abs(B); // Mat_<float> B = abs(A*5+3) will also do the job, // but it will allocate a temporary matrix
        参数
        src - 输入数组。
        dst - 输出数组。
        alpha - 可选缩放因子。参见：Mat::convertTo、cv::abs(const Mat&)

      • convertScaleAbs

        public static void convertScaleAbs​(Mat src,
                                   Mat dst)
        缩放、计算绝对值并将结果转换为 8 位。对于输入数组的每个元素，convertScaleAbs 函数按顺序执行三个操作：缩放、取绝对值、转换为无符号 8 位类型：\(\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\) 对于多通道数组，该函数独立处理每个通道。当输出不是 8 位时，可以通过调用 Mat::convertTo 方法（或使用矩阵表达式）然后计算结果的绝对值来模拟该操作。例如： Mat_<float> A(30,30); randu(A, Scalar(-100), Scalar(100)); Mat_<float> B = A*5 + 3; B = abs(B); // Mat_<float> B = abs(A*5+3) will also do the job, // but it will allocate a temporary matrix
        参数
        src - 输入数组。
        dst - 输出数组。参见：Mat::convertTo、cv::abs(const Mat&)

      • convertFp16

        @Deprecated
public static void convertFp16​(Mat src,
                               Mat dst)
        已弃用。
        请使用 Mat::convertTo 并设置 CV_16F。
        将数组转换为半精度浮点数。此函数在 FP32（单精度浮点数）和 FP16（半精度浮点数）之间进行转换。CV_16S 格式用于表示 FP16 数据。有两种使用模式 (src -> dst)：CV_32F -> CV_16S 和 CV_16S -> CV_32F。输入数组必须具有 CV_32F 或 CV_16S 类型才能表示位深度。如果输入数组既不是 CV_32F 也不是 CV_16S，则该函数将引发错误。半精度浮点数的格式在 IEEE 754-2008 中定义。
        参数
        src - 输入数组。
        dst - 输出数组。

      • LUT

        public static void LUT​(Mat src,
                       Mat lut,
                       Mat dst)
        执行数组的查找表转换。LUT 函数用查找表中的值填充输出数组。条目的索引取自输入数组。也就是说，该函数按如下方式处理 src 的每个元素：\(\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\) 其中 \(d = \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\)
        参数
        src - 8 位元素的输入数组。
        lut - 256 个元素的查找表；对于多通道输入数组，该表应该只有一个通道（在这种情况下，所有通道都使用相同的表）或与输入数组相同的通道数。
        dst - 与 src 大小和通道数相同，并且与 lut 深度相同的输出数组。参见：convertScaleAbs、Mat::convertTo

      • sumElems

        public static Scalar sumElems​(Mat src)
        计算数组元素的总和。cv::sum 函数独立计算并返回每个通道的数组元素总和。
        参数
        src - 输入数组，必须有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。参见：countNonZero、mean、meanStdDev、norm、minMaxLoc、reduce
        返回
        自动生成

      • hasNonZero

        public static boolean hasNonZero​(Mat src)
        检查是否存在至少一个非零数组元素。该函数返回 src 中是否存在非零元素。该函数不适用于多通道数组。如果您需要检查所有通道的非零数组元素，请首先使用 Mat::reshape 将数组重新解释为单通道数组。或者，您可以使用 extractImageCOI、mixChannels 或 split 来提取特定通道。**注意：**
        • 如果非零数组元素的位置很重要，请参考：findNonZero。
        • 如果非零数组元素的计数很重要，请参考：countNonZero。
        参数
        src - 单通道数组。参见：mean、meanStdDev、norm、minMaxLoc、calcCovarMatrix 参见：findNonZero、countNonZero
        返回
        自动生成

      • countNonZero

        public static int countNonZero​(Mat src)
        计算非零数组元素的数量。该函数返回 src 中非零元素的数量：\(\sum _{I: \; \texttt{src} (I) \ne0 } 1\) 该函数不适用于多通道数组。如果您需要计算所有通道的非零数组元素，请首先使用 Mat::reshape 将数组重新解释为单通道数组。或者，您可以使用 extractImageCOI、mixChannels 或 split 来提取特定通道。**注意：**
        • 如果只需要知道是否存在非零元素，请参考：hasNonZero。
        • 如果非零数组元素的位置很重要，请参考：findNonZero。
        参数
        src - 单通道数组。参见：mean、meanStdDev、norm、minMaxLoc、calcCovarMatrix 参见：findNonZero、hasNonZero
        返回
        自动生成

      • findNonZero

        public static void findNonZero​(Mat src,
                               Mat idx)
        返回非零像素位置的列表。给定一个二元矩阵（可能来自阈值化、比较、>、== 等操作的返回值），将所有非零索引作为 cv::Mat 或 std::vector<cv::Point> (x,y) 返回。例如： cv::Mat binaryImage; // 输入，二元图像 cv::Mat locations; // 输出，非零像素的位置 cv::findNonZero(binaryImage, locations); // 访问像素坐标 Point pnt = locations.at<Point>(i); 或 cv::Mat binaryImage; // 输入，二元图像 vector<Point> locations; // 输出，非零像素的位置 cv::findNonZero(binaryImage, locations); // 访问像素坐标 Point pnt = locations[i]; 该函数不适用于多通道数组。如果您需要查找所有通道的非零元素，请首先使用 Mat::reshape 将数组重新解释为单通道数组。或者，您可以使用 extractImageCOI、mixChannels 或 split 来提取特定通道。**注意：**
        • 如果只需要非零数组元素的数量，请参考：countNonZero。
        • 如果只需要知道是否存在非零元素，请参考：hasNonZero。
        参数
        src - 单通道数组
        idx - 输出数组，cv::Mat 或 std::vector<Point> 类型，对应于输入中的非零索引。参见：countNonZero、hasNonZero

      • mean

        public static Scalar mean​(Mat src,
                          Mat mask)
        计算数组元素的平均值（均值）。cv::mean 函数独立计算每个通道的数组元素的平均值 M 并返回它：\(\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\) 当所有掩码元素都为 0 时，该函数返回 Scalar::all(0)
        参数
        src - 输入数组，应该有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。
        mask - 可选操作掩码。参见：countNonZero、meanStdDev、norm、minMaxLoc
        返回
        自动生成

      • mean

        public static Scalar mean​(Mat src)
        计算数组元素的平均值（均值）。cv::mean 函数独立计算每个通道的数组元素的平均值 M 并返回它：\(\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\) 当所有掩码元素都为 0 时，该函数返回 Scalar::all(0)
        参数
        src - 输入数组，应具有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。参见：countNonZero、meanStdDev、norm、minMaxLoc
        返回
        自动生成

      • meanStdDev

        public static void meanStdDev​(Mat src,
                              MatOfDouble mean,
                              MatOfDouble stddev,
                              Mat mask)
        计算数组元素的均值和标准差。函数 cv::meanStdDev 独立地为每个通道计算数组元素的均值和标准差 M，并通过输出参数返回：
        参数
        src - 输入数组，应具有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。
        mean - 输出参数：计算出的均值。
        stddev - 输出参数：计算出的标准差。
        mask - 可选的操作掩码。参见：countNonZero、mean、norm、minMaxLoc、calcCovarMatrix

      • meanStdDev

        public static void meanStdDev​(Mat src,
                              MatOfDouble mean,
                              MatOfDouble stddev)
        计算数组元素的均值和标准差。函数 cv::meanStdDev 独立地为每个通道计算数组元素的均值和标准差 M，并通过输出参数返回：
        参数
        src - 输入数组，应具有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。
        mean - 输出参数：计算出的均值。
        stddev - 输出参数：计算出的标准差。参见：countNonZero、mean、norm、minMaxLoc、calcCovarMatrix

      • norm

        public static double norm​(Mat src1,
                          int normType,
                          Mat mask)
        计算数组的绝对范数。此版本的 #norm 计算 src1 的绝对范数。要计算的范数类型使用 #NormTypes 指定。例如，对于一个数组，考虑函数 \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\)。对于样本值 \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\)，\( L_{1}, L_{2} \) 和 \( L_{\infty} \) 范数计算如下：
        参数
        src1 - 第一个输入数组。
        normType - 范数类型（参见 #NormTypes）。
        mask - 可选的操作掩码；它必须与 src1 大小相同且类型为 CV_8UC1。
        返回
        自动生成

      • norm

        public static double norm​(Mat src1,
                          int normType)
        计算数组的绝对范数。此版本的 #norm 计算 src1 的绝对范数。要计算的范数类型使用 #NormTypes 指定。例如，对于一个数组，考虑函数 \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\)。对于样本值 \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\)，\( L_{1}, L_{2} \) 和 \( L_{\infty} \) 范数计算如下：
        参数
        src1 - 第一个输入数组。
        normType - 范数类型（参见 #NormTypes）。
        返回
        自动生成

      • norm

        public static double norm​(Mat src1)
        计算数组的绝对范数。此版本的 #norm 计算 src1 的绝对范数。要计算的范数类型使用 #NormTypes 指定。例如，对于一个数组，考虑函数 \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\)。对于样本值 \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\)，\( L_{1}, L_{2} \) 和 \( L_{\infty} \) 范数计算如下：
        参数
        src1 - 第一个输入数组。
        返回
        自动生成

      • norm

        public static double norm​(Mat src1,
                          Mat src2,
                          int normType,
                          Mat mask)
        计算绝对差范数或相对差范数。此版本的 cv::norm 计算数组 src1 和 src2 的绝对差范数或相对差范数。要计算的范数类型使用 #NormTypes 指定。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        normType - 范数类型（参见 #NormTypes）。
        mask - 可选的操作掩码；它必须与 src1 大小相同且类型为 CV_8UC1。
        返回
        自动生成

      • norm

        public static double norm​(Mat src1,
                          Mat src2,
                          int normType)
        计算绝对差范数或相对差范数。此版本的 cv::norm 计算数组 src1 和 src2 的绝对差范数或相对差范数。要计算的范数类型使用 #NormTypes 指定。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        normType - 范数类型（参见 #NormTypes）。
        返回
        自动生成

      • norm

        public static double norm​(Mat src1,
                          Mat src2)
        计算绝对差范数或相对差范数。此版本的 cv::norm 计算数组 src1 和 src2 的绝对差范数或相对差范数。要计算的范数类型使用 #NormTypes 指定。
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        返回
        自动生成

      • PSNR

        public static double PSNR​(Mat src1,
                          Mat src2,
                          double R)
        计算峰值信噪比 (PSNR) 图像质量指标。此函数计算两个输入数组 src1 和 src2 之间的峰值信噪比 (PSNR) 图像质量指标（以分贝 (dB) 为单位）。数组必须具有相同的类型。PSNR 计算如下：
        参数
        src1 - 第一个输入数组。
        src2 - 与 src1 大小相同的第二个输入数组。
        R - 最大像素值（默认为 255）
        返回
        自动生成

      • PSNR

        public static double PSNR​(Mat src1,
                          Mat src2)
        计算峰值信噪比 (PSNR) 图像质量指标。此函数计算两个输入数组 src1 和 src2 之间的峰值信噪比 (PSNR) 图像质量指标（以分贝 (dB) 为单位）。数组必须具有相同的类型。PSNR 计算如下：
        参数
        src1 - 第一个输入数组。
        src2 - 与 src1 大小相同的第二个输入数组。
        返回
        自动生成

      • batchDistance

        public static void batchDistance​(Mat src1,
                                 Mat src2,
                                 Mat dist,
                                 int dtype,
                                 Mat nidx,
                                 int normType,
                                 int K,
                                 Mat mask,
                                 int update,
                                 boolean crosscheck)
        朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
        参数
        src1 - 自动生成
        src2 - 自动生成
        dist - 自动生成
        dtype - 自动生成
        nidx - 自动生成
        normType - 自动生成
        K - 自动生成
        mask - 自动生成
        update - 自动生成
        crosscheck - 自动生成

      • batchDistance

        public static void batchDistance​(Mat src1,
                                 Mat src2,
                                 Mat dist,
                                 int dtype,
                                 Mat nidx,
                                 int normType,
                                 int K,
                                 Mat mask,
                                 int update)
        朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
        参数
        src1 - 自动生成
        src2 - 自动生成
        dist - 自动生成
        dtype - 自动生成
        nidx - 自动生成
        normType - 自动生成
        K - 自动生成
        mask - 自动生成
        update - 自动生成

      • batchDistance

        public static void batchDistance​(Mat src1,
                                 Mat src2,
                                 Mat dist,
                                 int dtype,
                                 Mat nidx,
                                 int normType,
                                 int K,
                                 Mat mask)
        朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
        参数
        src1 - 自动生成
        src2 - 自动生成
        dist - 自动生成
        dtype - 自动生成
        nidx - 自动生成
        normType - 自动生成
        K - 自动生成
        mask - 自动生成

      • batchDistance

        public static void batchDistance​(Mat src1,
                                 Mat src2,
                                 Mat dist,
                                 int dtype,
                                 Mat nidx,
                                 int normType,
                                 int K)
        朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
        参数
        src1 - 自动生成
        src2 - 自动生成
        dist - 自动生成
        dtype - 自动生成
        nidx - 自动生成
        normType - 自动生成
        K - 自动生成

      • batchDistance

        public static void batchDistance​(Mat src1,
                                 Mat src2,
                                 Mat dist,
                                 int dtype,
                                 Mat nidx,
                                 int normType)
        朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
        参数
        src1 - 自动生成
        src2 - 自动生成
        dist - 自动生成
        dtype - 自动生成
        nidx - 自动生成
        normType - 自动生成

      • batchDistance

        public static void batchDistance​(Mat src1,
                                 Mat src2,
                                 Mat dist,
                                 int dtype,
                                 Mat nidx)
        朴素最近邻查找器，参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: 文档说明
        参数
        src1 - 自动生成
        src2 - 自动生成
        dist - 自动生成
        dtype - 自动生成
        nidx - 自动生成

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha,
                             double beta,
                             int norm_type,
                             int dtype,
                             Mat mask)
        归一化数组的范数或值范围。函数 cv::normalize 缩放和移动输入数组元素，以便当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，分别有 \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\)（其中 p=Inf、1 或 2）；或者当 normType=NORM_MINMAX 时（仅限于密集数组），使 \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\)。可选掩码指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后修改该子数组使其归一化。如果只想使用掩码来计算范数或最小-最大值，但修改整个数组，则可以使用 norm 和 Mat::convertTo。对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它可能会移动零级别。一些正数示例数据的可能用法：
        参数
        src - 输入数组。
        dst - 与 src 大小相同的输出数组。
        alpha - 要归一化的范数值，或者在范围归一化的情况下为较低的范围边界。
        beta - 在范围归一化的情况下为较高的范围边界；它不用于范数归一化。
        norm_type - 归一化类型（参见 cv::NormTypes）。
        dtype - 当为负数时，输出数组与 src 具有相同的类型；否则，它与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。
        mask - 可选的操作掩码。参见：norm、Mat::convertTo、SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha,
                             double beta,
                             int norm_type,
                             int dtype)
        归一化数组的范数或值范围。函数 cv::normalize 缩放和移动输入数组元素，以便当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，分别有 \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\)（其中 p=Inf、1 或 2）；或者当 normType=NORM_MINMAX 时（仅限于密集数组），使 \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\)。可选掩码指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后修改该子数组使其归一化。如果只想使用掩码来计算范数或最小-最大值，但修改整个数组，则可以使用 norm 和 Mat::convertTo。对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它可能会移动零级别。一些正数示例数据的可能用法：
        参数
        src - 输入数组。
        dst - 与 src 大小相同的输出数组。
        alpha - 要归一化的范数值，或者在范围归一化的情况下为较低的范围边界。
        beta - 在范围归一化的情况下为较高的范围边界；它不用于范数归一化。
        norm_type - 归一化类型（参见 cv::NormTypes）。
        dtype - 当为负数时，输出数组与 src 具有相同的类型；否则，它与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。参见：norm、Mat::convertTo、SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha,
                             double beta,
                             int norm_type)
        归一化数组的范数或值范围。函数 cv::normalize 缩放和移动输入数组元素，以便当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，分别有 \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\)（其中 p=Inf、1 或 2）；或者当 normType=NORM_MINMAX 时（仅限于密集数组），使 \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\)。可选掩码指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后修改该子数组使其归一化。如果只想使用掩码来计算范数或最小-最大值，但修改整个数组，则可以使用 norm 和 Mat::convertTo。对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它可能会移动零级别。一些正数示例数据的可能用法：
        参数
        src - 输入数组。
        dst - 与 src 大小相同的输出数组。
        alpha - 要归一化的范数值，或者在范围归一化的情况下为较低的范围边界。
        beta - 在范围归一化的情况下为较高的范围边界；它不用于范数归一化。
        norm_type - 归一化类型（参见 cv::NormTypes）。与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。参见：norm、Mat::convertTo、SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha,
                             double beta)
        归一化数组的范数或值范围。函数 cv::normalize 缩放和移动输入数组元素，以便当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，分别有 \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\)（其中 p=Inf、1 或 2）；或者当 normType=NORM_MINMAX 时（仅限于密集数组），使 \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\)。可选掩码指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后修改该子数组使其归一化。如果只想使用掩码来计算范数或最小-最大值，但修改整个数组，则可以使用 norm 和 Mat::convertTo。对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它可能会移动零级别。一些正数示例数据的可能用法：
        参数
        src - 输入数组。
        dst - 与 src 大小相同的输出数组。
        alpha - 要归一化的范数值，或者在范围归一化的情况下为较低的范围边界。
        beta - 在范围归一化的情况下为较高的范围边界；它不用于范数归一化。与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。参见：norm、Mat::convertTo、SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha)
        归一化数组的范数或值范围。函数 cv::normalize 缩放和移动输入数组元素，以便当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，分别有 \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\)（其中 p=Inf、1 或 2）；或者当 normType=NORM_MINMAX 时（仅限于密集数组），使 \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\)。可选掩码指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后修改该子数组使其归一化。如果只想使用掩码来计算范数或最小-最大值，但修改整个数组，则可以使用 norm 和 Mat::convertTo。对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它可能会移动零级别。一些正数示例数据的可能用法：
        参数
        src - 输入数组。
        dst - 与 src 大小相同的输出数组。
        alpha - 要归一化的范数值，或者在范围归一化的情况下为较低的范围边界。归一化。与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。参见：norm、Mat::convertTo、SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst)
        归一化数组的范数或值范围。函数 cv::normalize 缩放和移动输入数组元素，以便当 normType=NORM_INF、NORM_L1 或 NORM_L2 时，分别有 \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\)（其中 p=Inf、1 或 2）；或者当 normType=NORM_MINMAX 时（仅限于密集数组），使 \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\)。可选掩码指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后修改该子数组使其归一化。如果只想使用掩码来计算范数或最小-最大值，但修改整个数组，则可以使用 norm 和 Mat::convertTo。对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它可能会移动零级别。一些正数示例数据的可能用法：
        参数
        src - 输入数组。
        dst - 与 src 大小相同的输出数组。归一化。归一化。与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。参见：norm、Mat::convertTo、SparseMat::convertTo

      • reduceArgMin

        public static void reduceArgMin​(Mat src,
                                Mat dst,
                                int axis,
                                boolean lastIndex)
        查找沿指定轴的最小元素的索引 注意： - 如果输入或输出数组不是连续的，此函数将创建一个内部副本。 - NaN 处理未指定，请参见 patchNaNs()。 - 返回的索引始终在输入矩阵的范围内。
        参数
        src - 输入单通道数组。
        dst - 输出数组，类型为 CV_32SC1，与 src 的维度相同，除了要约简的轴 - 它应设置为 1。
        lastIndex - 是否获取最小值的第一次或最后一次出现的索引。
        axis - 要沿其约简的轴。参见：reduceArgMax, minMaxLoc, min, max, compare, reduce

      • reduceArgMin

        public static void reduceArgMin​(Mat src,
                                Mat dst,
                                int axis)
        查找沿指定轴的最小元素的索引 注意： - 如果输入或输出数组不是连续的，此函数将创建一个内部副本。 - NaN 处理未指定，请参见 patchNaNs()。 - 返回的索引始终在输入矩阵的范围内。
        参数
        src - 输入单通道数组。
        dst - 输出数组，类型为 CV_32SC1，与 src 的维度相同，除了要约简的轴 - 它应设置为 1。
        axis - 要沿其约简的轴。参见：reduceArgMax, minMaxLoc, min, max, compare, reduce

      • reduceArgMax

        public static void reduceArgMax​(Mat src,
                                Mat dst,
                                int axis,
                                boolean lastIndex)
        查找沿指定轴的最大元素的索引 注意： - 如果输入或输出数组不是连续的，此函数将创建一个内部副本。 - NaN 处理未指定，请参见 patchNaNs()。 - 返回的索引始终在输入矩阵的范围内。
        参数
        src - 输入单通道数组。
        dst - 输出数组，类型为 CV_32SC1，与 src 的维度相同，除了要约简的轴 - 它应设置为 1。
        lastIndex - 是否获取最大值的第一次或最后一次出现的索引。
        axis - 要沿其约简的轴。参见：reduceArgMin, minMaxLoc, min, max, compare, reduce

      • reduceArgMax

        public static void reduceArgMax​(Mat src,
                                Mat dst,
                                int axis)
        查找沿指定轴的最大元素的索引 注意： - 如果输入或输出数组不是连续的，此函数将创建一个内部副本。 - NaN 处理未指定，请参见 patchNaNs()。 - 返回的索引始终在输入矩阵的范围内。
        参数
        src - 输入单通道数组。
        dst - 输出数组，类型为 CV_32SC1，与 src 的维度相同，除了要约简的轴 - 它应设置为 1。
        axis - 要沿其约简的轴。参见：reduceArgMin, minMaxLoc, min, max, compare, reduce

      • reduce

        public static void reduce​(Mat src,
                          Mat dst,
                          int dim,
                          int rtype,
                          int dtype)
        将矩阵约简为向量。函数 #reduce 通过将矩阵行/列视为一组一维向量并在向量上执行指定的运算直到获得单行/列来将矩阵约简为向量。例如，该函数可用于计算光栅图像的水平和垂直投影。对于 #REDUCE_MAX 和 #REDUCE_MIN，输出图像应与源图像具有相同的类型。对于 #REDUCE_SUM、#REDUCE_SUM2 和 #REDUCE_AVG，输出可能具有更大的元素位深度以保持精度。在这两种约简模式下也支持多通道数组。以下代码演示了其在单通道矩阵中的用法。代码片段：snippets/core_reduce.cpp example 以下代码演示了其在双通道矩阵中的用法。代码片段：snippets/core_reduce.cpp example2
        参数
        src - 输入二维矩阵。
        dst - 输出向量。其大小和类型由 dim 和 dtype 参数定义。
        dim - 沿其约简矩阵的维度索引。0 表示矩阵约简为单行。1 表示矩阵约简为单列。
        rtype - 约简操作，可以是 #ReduceTypes 之一
        dtype - 为负数时，输出向量将与输入矩阵具有相同的类型，否则，其类型将为 CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())。参见：repeat, reduceArgMin, reduceArgMax

      • reduce

        public static void reduce​(Mat src,
                          Mat dst,
                          int dim,
                          int rtype)
        将矩阵约简为向量。函数 #reduce 通过将矩阵行/列视为一组一维向量并在向量上执行指定的运算直到获得单行/列来将矩阵约简为向量。例如，该函数可用于计算光栅图像的水平和垂直投影。对于 #REDUCE_MAX 和 #REDUCE_MIN，输出图像应与源图像具有相同的类型。对于 #REDUCE_SUM、#REDUCE_SUM2 和 #REDUCE_AVG，输出可能具有更大的元素位深度以保持精度。在这两种约简模式下也支持多通道数组。以下代码演示了其在单通道矩阵中的用法。代码片段：snippets/core_reduce.cpp example 以下代码演示了其在双通道矩阵中的用法。代码片段：snippets/core_reduce.cpp example2
        参数
        src - 输入二维矩阵。
        dst - 输出向量。其大小和类型由 dim 和 dtype 参数定义。
        dim - 沿其约简矩阵的维度索引。0 表示矩阵约简为单行。1 表示矩阵约简为单列。
        rtype - 约简操作，可以是 #ReduceTypes 之一，否则，其类型将为 CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())。参见：repeat, reduceArgMin, reduceArgMax

      • merge

        public static void merge​(java.util.List<Mat> mv,
                         Mat dst)
        参数
        mv - 要合并的矩阵的输入向量；mv 中的所有矩阵必须具有相同的大小和相同的深度。
        dst - 与 mv[0] 大小和深度相同的输出数组；通道数将是矩阵数组中通道的总数。

      • split

        public static void split​(Mat m,
                         java.util.List<Mat> mv)
        参数
        m - 输入多通道数组。
        mv - 输出数组向量；如有需要，数组本身将重新分配。

      • mixChannels

        public static void mixChannels​(java.util.List<Mat> src,
                               java.util.List<Mat> dst,
                               MatOfInt fromTo)
        参数
        src - 输入数组或矩阵向量；所有矩阵必须具有相同的大小和相同的深度。
        dst - 输出数组或矩阵向量；所有矩阵必须已分配；它们的大小和深度必须与 src[0] 中的相同。
        fromTo - 指定复制哪些通道以及复制到何处的索引对数组；fromTo[k\*2] 是 src 中输入通道的基于 0 的索引，fromTo[k\*2+1] 是 dst 中输出通道的索引；使用连续通道编号：第一个输入图像通道的索引从 0 到 src[0].channels()-1，第二个输入图像通道的索引从 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此类推，输出图像通道也使用相同的方案；作为特例，当 fromTo[k\*2] 为负数时，相应的输出通道将填充零。

      • extractChannel

        public static void extractChannel​(Mat src,
                                  Mat dst,
                                  int coi)
        从 src 中提取单个通道（coi 是基于 0 的索引）
        参数
        src - 输入数组
        dst - 输出数组
        coi - 要提取的通道索引 参见：mixChannels, split

      • insertChannel

        public static void insertChannel​(Mat src,
                                 Mat dst,
                                 int coi)
        将单个通道插入到 dst（coi 是基于 0 的索引）。
        参数
        src - 输入数组
        dst - 输出数组
        coi - 要插入的通道索引 参见：mixChannels, merge

      • flip

        public static void flip​(Mat src,
                        Mat dst,
                        int flipCode)
        围绕垂直轴、水平轴或两个轴翻转二维数组。函数 cv::flip 以三种不同的方式之一翻转数组（行和列索引为基于 0 的）：\(\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.\) 使用该函数的示例场景如下：图像的垂直翻转 (flipCode == 0) 用于在左上角和左下角图像原点之间切换。这是 Microsoft Windows\* 操作系统上视频处理中的典型操作。图像的水平翻转，随后进行水平位移和绝对差计算，以检查垂直轴对称性 (flipCode > 0)。图像的同时水平和垂直翻转，随后进行位移和绝对差计算，以检查中心对称性 (flipCode < 0)。反转点数组的顺序 (flipCode > 0 或 flipCode == 0)。
        参数
        src - 输入数组。
        dst - 与 src 大小和类型相同的输出数组。
        flipCode - 用于指定如何翻转数组的标志；0 表示围绕 x 轴翻转，正值（例如，1）表示围绕 y 轴翻转。负值（例如，-1）表示围绕两个轴翻转。参见：transpose, repeat, completeSymm

      • flipND

        public static void flipND​(Mat src,
                          Mat dst,
                          int axis)
        沿给定轴翻转 n 维数组。
        参数
        src - 输入数组
        dst - 与 src 形状相同的输出数组
        axis - 执行翻转操作的轴。0 <= axis < src.dims。

      • broadcast

        public static void broadcast​(Mat src,
                             Mat shape,
                             Mat dst)
        将给定的 Mat 广播到给定的形状。
        参数
        src - 输入数组
        shape - 目标形状。应为 CV_32S 数字列表。请注意，不支持负值。
        dst - 具有给定形状的输出数组

      • rotate

        public static void rotate​(Mat src,
                          Mat dst,
                          int rotateCode)
        将二维数组旋转 90 度的倍数。函数 cv::rotate 以三种不同的方式之一旋转数组：顺时针旋转 90 度 (rotateCode = ROTATE_90_CLOCKWISE)。顺时针旋转 180 度 (rotateCode = ROTATE_180)。逆时针旋转 90 度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。
        参数
        src - 输入数组。
        dst - 与 src 类型相同的输出数组。对于 ROTATE_180，大小相同，对于 ROTATE_90_CLOCKWISE 和 ROTATE_90_COUNTERCLOCKWISE，行和列交换。
        rotateCode - 用于指定如何旋转数组的枚举；参见枚举 #RotateFlags 参见：transpose, repeat, completeSymm, flip, RotateFlags

      • repeat

        public static void repeat​(Mat src,
                          int ny,
                          int nx,
                          Mat dst)
        用输入数组的重复副本填充输出数组。函数 cv::repeat 沿两个轴中的每一个重复输入数组一次或多次：\(\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\) 函数的第二个变体更方便与 REF: MatrixExpressions 一起使用。
        参数
        src - 要复制的输入数组。
        ny - 用于指定沿垂直轴重复 src 次数的标志。
        nx - 用于指定沿水平轴重复 src 次数的标志。
        dst - 与 src 类型相同的输出数组。参见：cv::reduce

      • hconcat

        public static void hconcat​(java.util.List<Mat> src,
                           Mat dst)
        std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)), cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)), cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),}; cv::Mat out; cv::hconcat( matrices, out ); //out: //[1, 2, 3; // 1, 2, 3; // 1, 2, 3; // 1, 2, 3]
        参数
        src - 输入数组或矩阵向量。所有矩阵必须具有相同数量的行和相同的深度。
        dst - 输出数组。它与 src 具有相同数量的行和深度，以及 src 的列之和。相同的深度。

      • vconcat

        public static void vconcat​(java.util.List<Mat> src,
                           Mat dst)
        std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)), cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)), cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),}; cv::Mat out; cv::vconcat( matrices, out ); //out: //[1, 1, 1, 1; // 2, 2, 2, 2; // 3, 3, 3, 3]
        参数
        src - 输入数组或矩阵向量。所有矩阵必须具有相同数量的列和相同的深度
        dst - 输出数组。它与 src 具有相同数量的列和深度，以及 src 的行之和。相同的深度。

      • bitwise_and

        public static void bitwise_and​(Mat src1,
                               Mat src2,
                               Mat dst,
                               Mat mask)
        计算两个数组的按位与运算 (dst = src1 & src2) 计算两个数组或一个数组和一个标量的按元素按位与运算。函数 cv::bitwise_and 计算按元素按位逻辑与运算，适用于：当 src1 和 src2 大小相同时的两个数组：\(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 当 src2 由 Scalar 构造或其元素数量与 src1.channels() 相同时的数组和标量：\(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\) 当 src1 由 Scalar 构造或其元素数量与 src2.channels() 相同时的标量和数组：\(\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 对于浮点型数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。在上述第二和第三种情况下，标量首先被转换为数组类型。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。
        mask - 可选的操作掩码，8 位单通道数组，指定要更改的输出数组元素。

      • bitwise_and

        public static void bitwise_and​(Mat src1,
                               Mat src2,
                               Mat dst)
        计算两个数组的按位与运算 (dst = src1 & src2) 计算两个数组或一个数组和一个标量的按元素按位与运算。函数 cv::bitwise_and 计算按元素按位逻辑与运算，适用于：当 src1 和 src2 大小相同时的两个数组：\(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 当 src2 由 Scalar 构造或其元素数量与 src1.channels() 相同时的数组和标量：\(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\) 当 src1 由 Scalar 构造或其元素数量与 src2.channels() 相同时的标量和数组：\(\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 对于浮点型数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。在上述第二和第三种情况下，标量首先被转换为数组类型。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。指定要更改的输出数组元素。

      • bitwise_or

        public static void bitwise_or​(Mat src1,
                              Mat src2,
                              Mat dst,
                              Mat mask)
        计算两个数组或一个数组和一个标量的按元素按位或运算。函数 cv::bitwise_or 计算按元素按位逻辑或运算，适用于：当 src1 和 src2 大小相同时的两个数组：\(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 当 src2 由 Scalar 构造或其元素数量与 src1.channels() 相同时的数组和标量：\(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\) 当 src1 由 Scalar 构造或其元素数量与 src2.channels() 相同时的标量和数组：\(\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 对于浮点型数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。在上述第二和第三种情况下，标量首先被转换为数组类型。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。
        mask - 可选的操作掩码，8 位单通道数组，指定要更改的输出数组元素。

      • bitwise_or

        public static void bitwise_or​(Mat src1,
                              Mat src2,
                              Mat dst)
        计算两个数组或一个数组和一个标量的按元素按位或运算。函数 cv::bitwise_or 计算按元素按位逻辑或运算，适用于：当 src1 和 src2 大小相同时的两个数组：\(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 当 src2 由 Scalar 构造或其元素数量与 src1.channels() 相同时的数组和标量：\(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\) 当 src1 由 Scalar 构造或其元素数量与 src2.channels() 相同时的标量和数组：\(\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 对于浮点型数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。在上述第二和第三种情况下，标量首先被转换为数组类型。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。指定要更改的输出数组元素。

      • bitwise_xor

        public static void bitwise_xor​(Mat src1,
                               Mat src2,
                               Mat dst,
                               Mat mask)
        计算两个数组或一个数组和一个标量的按元素按位异或运算。函数 cv::bitwise_xor 计算按元素按位逻辑异或运算，适用于：当 src1 和 src2 大小相同时的两个数组：\(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 当 src2 由 Scalar 构造或其元素数量与 src1.channels() 相同时的数组和标量：\(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\) 当 src1 由 Scalar 构造或其元素数量与 src2.channels() 相同时的标量和数组：\(\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 对于浮点型数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。在上述第二和第三种情况下，标量首先被转换为数组类型。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。
        mask - 可选的操作掩码，8 位单通道数组，指定要更改的输出数组元素。

      • bitwise_xor

        public static void bitwise_xor​(Mat src1,
                               Mat src2,
                               Mat dst)
        计算两个数组或一个数组和一个标量的按元素按位异或运算。函数 cv::bitwise_xor 计算按元素按位逻辑异或运算，适用于：当 src1 和 src2 大小相同时的两个数组：\(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 当 src2 由 Scalar 构造或其元素数量与 src1.channels() 相同时的数组和标量：\(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\) 当 src1 由 Scalar 构造或其元素数量与 src2.channels() 相同时的标量和数组：\(\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) 对于浮点型数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。在上述第二和第三种情况下，标量首先被转换为数组类型。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。指定要更改的输出数组元素。

      • bitwise_not

        public static void bitwise_not​(Mat src,
                               Mat dst,
                               Mat mask)
        反转数组的每一位。函数 cv::bitwise_not 计算输入数组的按元素按位反转：\(\texttt{dst} (I) = \neg \texttt{src} (I)\) 对于浮点型输入数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。
        参数
        src - 输入数组。
        dst - 输出数组，大小和类型与输入数组相同。
        mask - 可选的操作掩码，8 位单通道数组，指定要更改的输出数组元素。

      • bitwise_not

        public static void bitwise_not​(Mat src,
                               Mat dst)
        反转数组的每一位。函数 cv::bitwise_not 计算输入数组的按元素按位反转：\(\texttt{dst} (I) = \neg \texttt{src} (I)\) 对于浮点型输入数组，使用其机器相关的位表示（通常符合 IEEE754 标准）进行运算。对于多通道数组，每个通道独立处理。
        参数
        src - 输入数组。
        dst - 输出数组，大小和类型与输入数组相同。指定要更改的输出数组元素。

      • absdiff

        public static void absdiff​(Mat src1,
                           Mat src2,
                           Mat dst)
        计算两个数组或一个数组和一个标量之间的按元素绝对差。函数 cv::absdiff 计算：当大小和类型相同时的两个数组之间的绝对差：\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\) 当第二个数组由 Scalar 构造或其元素数量与 src1 的通道数相同时的数组和标量之间的绝对差：\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\) 当第一个数组由 Scalar 构造或其元素数量与 src2 的通道数相同时的标量和数组之间的绝对差：\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\) 其中 I 是数组元素的多维索引。对于多通道数组，每个通道独立处理。**注意：**当数组深度为 CV_32S 时，不应用饱和度。溢出时甚至可能得到负值。**注意：**(Python) 注意 src1/src2 是单个数字和它们是元组/数组之间的行为差异。absdiff(src,X) 表示 absdiff(src,(X,X,X,X))。absdiff(src,(X,)) 表示 absdiff(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，大小和类型与输入数组相同。参见：cv::abs(const Mat&)

      • copyTo

        public static void copyTo​(Mat src,
                          Mat dst,
                          Mat mask)
        这是一个重载的成员函数，为了方便（python）提供。将矩阵复制到另一个矩阵。当指定操作掩码时，如果上面的 Mat::create 调用重新分配矩阵，则在复制数据之前，新分配的矩阵将用全零初始化。
        参数
        src - 源矩阵。
        dst - 目标矩阵。如果在操作之前没有正确的大小或类型，则会重新分配。
        mask - 与 *this 大小相同的操作掩码。其非零元素指示需要复制哪些矩阵元素。掩码必须是 CV_8U 类型，可以有 1 个或多个通道。

      • inRange

        public static void inRange​(Mat src,
                           Scalar lowerb,
                           Scalar upperb,
                           Mat dst)
        检查数组元素是否位于另外两个数组的元素之间。该函数按如下方式检查范围
        • 对于单通道输入数组的每个元素：\(\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\)
        • 对于双通道数组：\(\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1\)
        • 以此类推。
        也就是说，如果 src (I) 在指定的 1D、2D、3D……框内，则 dst (I) 设置为 255（所有 1 位），否则为 0。当上下边界参数为标量时，上述公式中 lowerb 和 upperb 的索引 (I) 应省略。
        参数
        src - 第一个输入数组。
        lowerb - 包含下边界数组或标量。
        upperb - 包含上边界数组或标量。
        dst - 与 src 大小相同且类型为 CV_8U 的输出数组。

      • compare

        public static void compare​(Mat src1,
                           Mat src2,
                           Mat dst,
                           int cmpop)
        执行两个数组或一个数组和标量值的按元素比较。该函数比较：当 src1 和 src2 大小相同时的两个数组的元素：\(\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\) 当 src2 由 Scalar 构造或只有一个元素时，src1 的元素与标量 src2：\(\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\) 当 src1 由 Scalar 构造或只有一个元素时，src1 与 src2 的元素：\(\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\) 当比较结果为真时，输出数组的对应元素设置为 255。比较操作可以用等效的矩阵表达式替换： Mat dst1 = src1 >= src2; Mat dst2 = src1 < 8; ...
        参数
        src1 - 第一个输入数组或标量；当它是数组时，它必须只有一个通道。
        src2 - 第二个输入数组或标量；当它是数组时，它必须只有一个通道。
        dst - 类型为 ref CV_8U 的输出数组，其大小和通道数与输入数组相同。
        cmpop - 一个标志位，指定数组之间的对应关系 (cv::CmpTypes) 参见：checkRange, min, max, threshold

      • min

        public static void min​(Mat src1,
                       Mat src2,
                       Mat dst)
        计算两个数组或一个数组和一个标量的逐元素最小值。函数 cv::min 计算两个数组的逐元素最小值：\(\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\) 或数组和标量：\(\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\)
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src1 大小和类型相同的输出数组。参见：max, compare, inRange, minMaxLoc

      • max

        public static void max​(Mat src1,
                       Mat src2,
                       Mat dst)
        计算两个数组或一个数组和一个标量的逐元素最大值。函数 cv::max 计算两个数组的逐元素最大值：\(\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\) 或数组和标量：\(\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\)
        参数
        src1 - 第一个输入数组。
        src2 - 第二个输入数组，大小和类型与 src1 相同。
        dst - 与 src1 大小和类型相同的输出数组。参见：min, compare, inRange, minMaxLoc, 参考：MatrixExpressions

      • sqrt

        public static void sqrt​(Mat src,
                        Mat dst)
        计算数组元素的平方根。函数 cv::sqrt 计算每个输入数组元素的平方根。对于多通道数组，每个通道独立处理。精度与内置的 std::sqrt تقریباً相同。
        参数
        src - 输入浮点型数组。
        dst - 与 src 大小和类型相同的输出数组。

      • pow

        public static void pow​(Mat src,
                       double power,
                       Mat dst)
        将每个数组元素提升到一个幂。函数 cv::pow 将输入数组的每个元素提升到 power 次幂：\(\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is integer}{|\texttt{src}(I)|^{power}}{otherwise}\) 因此，对于非整数幂指数，使用输入数组元素的绝对值。但是，可以使用一些额外的运算来获得负值的真实值。在下面的示例中，计算数组 src 的 5 次方根显示： Mat mask = src < 0; pow(src, 1./5, dst); subtract(Scalar::all(0), dst, dst, mask); 对于某些 power 值，例如整数、0.5 和 -0.5，使用专门的更快算法。不处理特殊值 (NaN、Inf)。
        参数
        src - 输入数组。
        power - 幂的指数。
        dst - 与 src 大小和类型相同的输出数组。参见：sqrt, exp, log, cartToPolar, polarToCart

      • exp

        public static void exp​(Mat src,
                       Mat dst)
        计算每个数组元素的指数。函数 cv::exp 计算输入数组每个元素的指数：\(\texttt{dst} [I] = e^{ src(I) }\) 单精度输入的最大相对误差约为 7e-6，双精度输入小于 1e-10。目前，该函数将输出中的非规格化值转换为零。不处理特殊值 (NaN、Inf)。
        参数
        src - 输入数组。
        dst - 与 src 大小和类型相同的输出数组。参见：log, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

      • log

        public static void log​(Mat src,
                       Mat dst)
        计算每个数组元素的自然对数。函数 cv::log 计算输入数组每个元素的自然对数：\(\texttt{dst} (I) = \log (\texttt{src}(I)) \) 零、负数和特殊值 (NaN、Inf) 的输出是未定义的。
        参数
        src - 输入数组。
        dst - 与 src 大小和类型相同的输出数组。参见：exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

      • polarToCart

        public static void polarToCart​(Mat magnitude,
                               Mat angle,
                               Mat x,
                               Mat y,
                               boolean angleInDegrees)
        根据向量的幅度和角度计算二维向量的 x 和 y 坐标。函数 cv::polarToCart 计算由幅度和角度的对应元素表示的每个二维向量的笛卡尔坐标：\(\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\) 估计坐标的相对精度约为 1e-6。
        参数
        magnitude - 输入浮点型数组，表示二维向量的幅度；它可以是一个空矩阵 (=Mat())，在这种情况下，函数假设所有幅度都 =1；如果它不是空的，它必须与 angle 具有相同的大小和类型。
        angle - 输入浮点型数组，表示二维向量的角度。
        x - 二维向量的 x 坐标输出数组；它与 angle 具有相同的大小和类型。
        y - 二维向量的 y 坐标输出数组；它与 angle 具有相同的大小和类型。
        angleInDegrees - 当为真时，输入角度以度为单位测量，否则以弧度为单位测量。参见：cartToPolar, magnitude, phase, exp, log, pow, sqrt

      • polarToCart

        public static void polarToCart​(Mat magnitude,
                               Mat angle,
                               Mat x,
                               Mat y)
        根据向量的幅度和角度计算二维向量的 x 和 y 坐标。函数 cv::polarToCart 计算由幅度和角度的对应元素表示的每个二维向量的笛卡尔坐标：\(\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\) 估计坐标的相对精度约为 1e-6。
        参数
        magnitude - 输入浮点型数组，表示二维向量的幅度；它可以是一个空矩阵 (=Mat())，在这种情况下，函数假设所有幅度都 =1；如果它不是空的，它必须与 angle 具有相同的大小和类型。
        angle - 输入浮点型数组，表示二维向量的角度。
        x - 二维向量的 x 坐标输出数组；它与 angle 具有相同的大小和类型。
        y - 二维向量的 y 坐标输出数组；它与 angle 具有相同的大小和类型。度，否则以弧度为单位测量。参见：cartToPolar, magnitude, phase, exp, log, pow, sqrt

      • cartToPolar

        public static void cartToPolar​(Mat x,
                               Mat y,
                               Mat magnitude,
                               Mat angle,
                               boolean angleInDegrees)
        计算二维向量的幅度和角度。函数 cv::cartToPolar 计算每个二维向量 (x(I),y(I)) 的幅度、角度或两者：\(\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\) 角度的计算精度约为 0.3 度。对于点 (0,0)，角度设置为 0。
        参数
        x - x 坐标数组；这必须是单精度或双精度浮点型数组。
        y - y 坐标数组，必须与 x 具有相同的大小和类型。
        magnitude - 与 x 大小和类型相同的幅度输出数组。
        angle - 与 x 大小和类型相同的角度输出数组；角度以弧度（从 0 到 2\*Pi）或度（从 0 到 360 度）测量。
        angleInDegrees - 一个标志位，指示角度是以弧度（默认）还是以度为单位测量。参见：Sobel, Scharr

      • cartToPolar

        public static void cartToPolar​(Mat x,
                               Mat y,
                               Mat magnitude,
                               Mat angle)
        计算二维向量的幅度和角度。函数 cv::cartToPolar 计算每个二维向量 (x(I),y(I)) 的幅度、角度或两者：\(\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\) 角度的计算精度约为 0.3 度。对于点 (0,0)，角度设置为 0。
        参数
        x - x 坐标数组；这必须是单精度或双精度浮点型数组。
        y - y 坐标数组，必须与 x 具有相同的大小和类型。
        magnitude - 与 x 大小和类型相同的幅度输出数组。
        angle - 与 x 大小和类型相同的角度输出数组；角度以弧度（从 0 到 2\*Pi）或度（从 0 到 360 度）测量。弧度（默认）还是以度为单位测量。参见：Sobel, Scharr

      • phase

        public static void phase​(Mat x,
                         Mat y,
                         Mat angle,
                         boolean angleInDegrees)
        计算二维向量的旋转角度。函数 cv::phase 计算由 x 和 y 的对应元素组成的每个二维向量的旋转角度：\(\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\) 角度估计精度约为 0.3 度。当 x(I)=y(I)=0 时，对应的 angle(I) 设置为 0。
        参数
        x - 输入浮点型数组，表示二维向量的 x 坐标。
        y - 输入数组，表示二维向量的 y 坐标；它必须与 x 具有相同的大小和类型。
        angle - 向量角度输出数组；它与 x 具有相同的大小和类型。
        angleInDegrees - 当为真时，函数计算角度的度数，否则以弧度为单位测量。

      • phase

        public static void phase​(Mat x,
                         Mat y,
                         Mat angle)
        计算二维向量的旋转角度。函数 cv::phase 计算由 x 和 y 的对应元素组成的每个二维向量的旋转角度：\(\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\) 角度估计精度约为 0.3 度。当 x(I)=y(I)=0 时，对应的 angle(I) 设置为 0。
        参数
        x - 输入浮点型数组，表示二维向量的 x 坐标。
        y - 输入数组，表示二维向量的 y 坐标；它必须与 x 具有相同的大小和类型。
        angle - 向量角度输出数组；它与 x 具有相同的大小和类型。度，否则以弧度为单位测量。

      • magnitude

        public static void magnitude​(Mat x,
                             Mat y,
                             Mat magnitude)
        计算二维向量的幅度。函数 cv::magnitude 计算由 x 和 y 数组的对应元素形成的二维向量的幅度：\(\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\)
        参数
        x - 向量的 x 坐标浮点型数组。
        y - 向量的 y 坐标浮点型数组；它必须与 x 大小相同。
        magnitude - 与 x 大小和类型相同的输出数组。参见：cartToPolar, polarToCart, phase, sqrt

      • checkRange

        public static boolean checkRange​(Mat a,
                                 boolean quiet,
                                 double minVal,
                                 double maxVal)
        检查输入数组的每个元素是否有无效值。函数 cv::checkRange 检查每个数组元素既不是 NaN 也不是无限大。当 minVal >
        • 如果 DBL_MAX 和 maxVal < DBL_MAX，则函数还会检查每个值是否在 minVal 和 maxVal 之间。对于多通道数组，每个通道都会独立处理。如果某些值超出范围，则第一个异常值的索引将存储在 pos 中（当 pos != NULL 时）。然后，函数要么返回 false（当 quiet=true 时），要么抛出异常。
        参数
        a - 输入数组。
        quiet - 一个标志，指示当数组元素超出范围时函数是否静默返回 false 或抛出异常。
        minVal - 有效值范围的包含下界。
        maxVal - 有效值范围的非包含上界。
        返回
        自动生成

      • checkRange

        public static boolean checkRange​(Mat a,
                                 boolean quiet,
                                 double minVal)
        检查输入数组的每个元素是否有无效值。函数 cv::checkRange 检查每个数组元素既不是 NaN 也不是无限大。当 minVal >
        • 如果 DBL_MAX 和 maxVal < DBL_MAX，则函数还会检查每个值是否在 minVal 和 maxVal 之间。对于多通道数组，每个通道都会独立处理。如果某些值超出范围，则第一个异常值的索引将存储在 pos 中（当 pos != NULL 时）。然后，函数要么返回 false（当 quiet=true 时），要么抛出异常。
        参数
        a - 输入数组。
        quiet - 一个标志，指示当数组元素超出范围时函数是否静默返回 false 或抛出异常。
        minVal - 有效值范围的包含下界。
        返回
        自动生成

      • checkRange

        public static boolean checkRange​(Mat a,
                                 boolean quiet)
        检查输入数组的每个元素是否有无效值。函数 cv::checkRange 检查每个数组元素既不是 NaN 也不是无限大。当 minVal >
        • 如果 DBL_MAX 和 maxVal < DBL_MAX，则函数还会检查每个值是否在 minVal 和 maxVal 之间。对于多通道数组，每个通道都会独立处理。如果某些值超出范围，则第一个异常值的索引将存储在 pos 中（当 pos != NULL 时）。然后，函数要么返回 false（当 quiet=true 时），要么抛出异常。
        参数
        a - 输入数组。
        quiet - 一个标志，指示当数组元素超出范围时函数是否静默返回 false 或抛出异常。
        返回
        自动生成

      • checkRange

        public static boolean checkRange​(Mat a)
        检查输入数组的每个元素是否有无效值。函数 cv::checkRange 检查每个数组元素既不是 NaN 也不是无限大。当 minVal >
        • 如果 DBL_MAX 和 maxVal < DBL_MAX，则函数还会检查每个值是否在 minVal 和 maxVal 之间。对于多通道数组，每个通道都会独立处理。如果某些值超出范围，则第一个异常值的索引将存储在 pos 中（当 pos != NULL 时）。然后，函数要么返回 false（当 quiet=true 时），要么抛出异常。
        参数
        a - 输入数组。当数组元素超出范围时函数是否静默返回 false 或抛出异常。
        返回
        自动生成

      • patchNaNs

        public static void patchNaNs​(Mat a,
                             double val)
        用给定数字替换NaN。
        参数
        a - 输入/输出矩阵（CV_32F 类型）。
        val - 用于转换 NaN 的值。

      • patchNaNs

        public static void patchNaNs​(Mat a)
        用给定数字替换NaN。
        参数
        a - 输入/输出矩阵（CV_32F 类型）。

      • gemm

        public static void gemm​(Mat src1,
                        Mat src2,
                        double alpha,
                        Mat src3,
                        double beta,
                        Mat dst,
                        int flags)
        执行广义矩阵乘法。函数 cv::gemm 执行类似于 BLAS 3 级 gemm 函数的广义矩阵乘法。例如，gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) 对应于 \(\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\) 对于复数（双通道）数据，执行复数矩阵乘法。该函数可以用矩阵表达式替换。例如，上述调用可以用以下表达式替换： dst = alpha*src1.t()*src2 + beta*src3.t();
        参数
        src1 - 第一个相乘的输入矩阵，可以是实数 (CV_32FC1, CV_64FC1) 或复数 (CV_32FC2, CV_64FC2)。
        src2 - 第二个相乘的输入矩阵，与 src1 类型相同。
        alpha - 矩阵乘积的权重。
        src3 - 第三可选的增量矩阵，添加到矩阵乘积中；它应该与 src1 和 src2 类型相同。
        beta - src3 的权重。
        dst - 输出矩阵；它具有适当的大小和与输入矩阵相同的类型。
        flags - 操作标志 (cv::GemmFlags) 参见：mulTransposed, transform

      • gemm

        public static void gemm​(Mat src1,
                        Mat src2,
                        double alpha,
                        Mat src3,
                        double beta,
                        Mat dst)
        执行广义矩阵乘法。函数 cv::gemm 执行类似于 BLAS 3 级 gemm 函数的广义矩阵乘法。例如，gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) 对应于 \(\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\) 对于复数（双通道）数据，执行复数矩阵乘法。该函数可以用矩阵表达式替换。例如，上述调用可以用以下表达式替换： dst = alpha*src1.t()*src2 + beta*src3.t();
        参数
        src1 - 第一个相乘的输入矩阵，可以是实数 (CV_32FC1, CV_64FC1) 或复数 (CV_32FC2, CV_64FC2)。
        src2 - 第二个相乘的输入矩阵，与 src1 类型相同。
        alpha - 矩阵乘积的权重。
        src3 - 第三可选的增量矩阵，添加到矩阵乘积中；它应该与 src1 和 src2 类型相同。
        beta - src3 的权重。
        dst - 输出矩阵；它具有适当的大小和与输入矩阵相同的类型。参见：mulTransposed, transform

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta,
                                 double scale,
                                 int dtype)
        计算矩阵与其转置的乘积。函数 cv::mulTransposed 计算 src 及其转置的乘积：如果 aTa=true，则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\)；否则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) 。该函数用于计算协方差矩阵。当 delta 为零时，当 B=A' 时，它可以用作通用矩阵乘积 A\*B 的更快替代品。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。见下文描述。
        delta - 可选的增量矩阵，在乘法之前从 src 中减去。当矩阵为空 (delta=noArray()) 时，假定为零，即不减去任何值。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（参见 repeat）以覆盖完整的 src，然后减去。当增量矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。参见下文 dtype 参数说明。
        scale - 矩阵乘积的可选比例因子。
        dtype - 输出矩阵的可选类型。当它为负数时，输出矩阵将与 src 类型相同。否则，它将是 type=CV_MAT_DEPTH(dtype)，它应该是 CV_32F 或 CV_64F 之一。参见：calcCovarMatrix, gemm, repeat, reduce

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta,
                                 double scale)
        计算矩阵与其转置的乘积。函数 cv::mulTransposed 计算 src 及其转置的乘积：如果 aTa=true，则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\)；否则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) 。该函数用于计算协方差矩阵。当 delta 为零时，当 B=A' 时，它可以用作通用矩阵乘积 A\*B 的更快替代品。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。见下文描述。
        delta - 可选的增量矩阵，在乘法之前从 src 中减去。当矩阵为空 (delta=noArray()) 时，假定为零，即不减去任何值。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（参见 repeat）以覆盖完整的 src，然后减去。当增量矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。参见下文 dtype 参数说明。
        scale - 矩阵乘积的可选比例因子。输出矩阵将与 src 类型相同。否则，它将是 type=CV_MAT_DEPTH(dtype)，它应该是 CV_32F 或 CV_64F 之一。参见：calcCovarMatrix, gemm, repeat, reduce

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta)
        计算矩阵与其转置的乘积。函数 cv::mulTransposed 计算 src 及其转置的乘积：如果 aTa=true，则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\)；否则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) 。该函数用于计算协方差矩阵。当 delta 为零时，当 B=A' 时，它可以用作通用矩阵乘积 A\*B 的更快替代品。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。见下文描述。
        delta - 可选的增量矩阵，在乘法之前从 src 中减去。当矩阵为空 (delta=noArray()) 时，假定为零，即不减去任何值。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（参见 repeat）以覆盖完整的 src，然后减去。当增量矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。参见下文 dtype 参数说明。输出矩阵将与 src 类型相同。否则，它将是 type=CV_MAT_DEPTH(dtype)，它应该是 CV_32F 或 CV_64F 之一。参见：calcCovarMatrix, gemm, repeat, reduce

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa)
        计算矩阵与其转置的乘积。函数 cv::mulTransposed 计算 src 及其转置的乘积：如果 aTa=true，则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\)；否则为 \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) 。该函数用于计算协方差矩阵。当 delta 为零时，当 B=A' 时，它可以用作通用矩阵乘积 A\*B 的更快替代品。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。见下文描述。乘法。当矩阵为空 (delta=noArray()) 时，假定为零，即不减去任何值。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（参见 repeat）以覆盖完整的 src，然后减去。当增量矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。参见下文 dtype 参数说明。输出矩阵将与 src 类型相同。否则，它将是 type=CV_MAT_DEPTH(dtype)，它应该是 CV_32F 或 CV_64F 之一。参见：calcCovarMatrix, gemm, repeat, reduce

      • transpose

        public static void transpose​(Mat src,
                             Mat dst)
        转置矩阵。函数 cv::transpose 转置矩阵 src：\(\texttt{dst} (i,j) = \texttt{src} (j,i)\) **注意：**对于复数矩阵，不执行复数共轭运算。如果需要，应该单独进行。
        参数
        src - 输入数组。
        dst - 与 src 类型相同的输出数组。

      • transposeND

        public static void transposeND​(Mat src,
                               MatOfInt order,
                               Mat dst)
        N 维矩阵的转置。**注意：**输入应该是连续的单通道矩阵。
        参数
        src - 输入数组。
        order - [0,1,..,N-1] 的排列，其中 N 是 src 的轴数。dst 的第 i 个轴将对应于输入中编号为 order[i] 的轴。
        dst - 与 src 类型相同的输出数组。

      • transform

        public static void transform​(Mat src,
                             Mat dst,
                             Mat m)
        执行每个数组元素的矩阵变换。函数 cv::transform 执行数组 src 的每个元素的矩阵变换并将结果存储在 dst 中：\(\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\)（当 m.cols=src.channels() 时），或 \(\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\)（当 m.cols=src.channels()+1 时）。N 通道数组 src 的每个元素都被解释为 N 元素向量，使用 M x N 或 M x (N+1) 矩阵 m 变换为 M 元素向量——输出数组 dst 的相应元素。该函数可用于 N 维点的几何变换、任意线性颜色空间变换（例如各种 RGB 到 YUV 变换）、图像通道的混洗等等。
        参数
        src - 输入数组，必须与 m.cols 或 m.cols-1 具有相同数量的通道（1 到 4）。
        dst - 与 src 大小和深度相同的输出数组；它与 m.rows 具有相同数量的通道。
        m - 变换 2x2 或 2x3 浮点矩阵。参见：perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

      • perspectiveTransform

        public static void perspectiveTransform​(Mat src,
                                        Mat dst,
                                        Mat m)
        对向量执行透视矩阵变换。函数cv::perspectiveTransform将src的每个元素视为一个二维或三维向量进行变换，方式如下：（x, y, z) → (x'/w, y'/w, z'/w)，其中(x', y', z', w') = mat ⋅ [x y z 1]，w = {w' if (w' ≠ 0), ∞ otherwise}。此处显示的是三维向量变换。对于二维向量变换，z分量将被忽略。注意：该函数变换的是稀疏的二维或三维向量集。如果要使用透视变换变换图像，请使用warpPerspective。如果存在逆问题，即希望根据几对对应的点计算最可能的透视变换，可以使用getPerspectiveTransform或findHomography。
        参数
        src - 输入的双通道或三通道浮点型数组；每个元素都是要变换的二维/三维向量。
        dst - 与 src 大小和类型相同的输出数组。
        m - 3x3或4x4浮点型变换矩阵。参见：transform, warpPerspective, getPerspectiveTransform, findHomography

      • completeSymm

        public static void completeSymm​(Mat m,
                                boolean lowerToUpper)
        将方阵的下半部分或上半部分复制到其另一半。函数cv::completeSymm将方阵的下半部分或上半部分复制到其另一半。矩阵对角线保持不变。
        • 如果lowerToUpper=false，则mij=mji (i > j)
        • 如果lowerToUpper=true，则mij=mji (i < j)
        参数
        m - 输入/输出浮点型方阵。
        lowerToUpper - 操作标志；如果为true，则将下半部分复制到上半部分。否则，将上半部分复制到下半部分。参见：flip, transpose

      • completeSymm

        public static void completeSymm​(Mat m)
        将方阵的下半部分或上半部分复制到其另一半。函数cv::completeSymm将方阵的下半部分或上半部分复制到其另一半。矩阵对角线保持不变。
        • 如果lowerToUpper=false，则mij=mji (i > j)
        • 如果lowerToUpper=true，则mij=mji (i < j)
        参数
        m - 输入/输出浮点型方阵。上半部分。否则，将上半部分复制到下半部分。参见：flip, transpose

      • setIdentity

        public static void setIdentity​(Mat mtx,
                               Scalar s)
        初始化一个比例恒等矩阵。函数cv::setIdentity初始化一个比例恒等矩阵：mtx(i,j) = {value if (i=j), 0 otherwise}。该函数也可以使用矩阵初始化器和矩阵表达式来模拟： Mat A = Mat::eye(4, 3, CV_32F)*5; // A 将被设置为 [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]
        参数
        mtx - 要初始化的矩阵（不一定为方阵）。
        s - 要赋给对角线元素的值。参见：Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

      • setIdentity

        public static void setIdentity​(Mat mtx)
        初始化一个比例恒等矩阵。函数cv::setIdentity初始化一个比例恒等矩阵：mtx(i,j) = {value if (i=j), 0 otherwise}。该函数也可以使用矩阵初始化器和矩阵表达式来模拟： Mat A = Mat::eye(4, 3, CV_32F)*5; // A 将被设置为 [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]
        参数
        mtx - 要初始化的矩阵（不一定为方阵）。参见：Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

      • determinant

        public static double determinant​(Mat mtx)
        返回方阵的行列式。函数cv::determinant计算并返回指定矩阵的行列式。对于小型矩阵(mtx.cols=mtx.rows<=3)，使用直接方法。对于大型矩阵，该函数使用具有部分主元选择的LU分解。对于对称正定矩阵，也可以使用特征分解来计算行列式。
        参数
        mtx - 输入矩阵，必须是CV_32FC1或CV_64FC1类型且大小为方阵。参见：trace, invert, solve, eigen, 参考：MatrixExpressions
        返回
        自动生成

      • trace

        public static Scalar trace​(Mat mtx)
        返回矩阵的迹。函数cv::trace返回矩阵mtx的对角元素之和。tr(mtx) = Σi mtx(i,i)
        参数
        mtx - 输入矩阵。
        返回
        自动生成

      • invert

        public static double invert​(Mat src,
                            Mat dst,
                            int flags)
        查找矩阵的逆矩阵或伪逆矩阵。函数cv::invert反转矩阵src并将结果存储在dst中。当矩阵src是奇异矩阵或非方阵时，该函数计算伪逆矩阵（dst矩阵），使得norm(src*dst - I)最小，其中I是单位矩阵。对于#DECOMP_LU方法，如果成功计算出逆矩阵，则函数返回非零值；如果src是奇异矩阵，则返回0。对于#DECOMP_SVD方法，函数返回src的逆条件数（最小奇异值与最大奇异值的比率），如果src是奇异矩阵，则返回0。如果src是奇异矩阵，则SVD方法计算伪逆矩阵。与#DECOMP_LU类似，#DECOMP_CHOLESKY方法仅适用于非奇异方阵，这些方阵也应该是对称的和正定的。在这种情况下，函数将反转后的矩阵存储在dst中并返回非零值。否则，它返回0。
        参数
        src - 输入的M x N浮点型矩阵。
        dst - 输出的N x M大小的矩阵，与src类型相同。
        flags - 反转方法 (cv::DecompTypes) 参见：solve, SVD
        返回
        自动生成

      • invert

        public static double invert​(Mat src,
                            Mat dst)
        查找矩阵的逆矩阵或伪逆矩阵。函数cv::invert反转矩阵src并将结果存储在dst中。当矩阵src是奇异矩阵或非方阵时，该函数计算伪逆矩阵（dst矩阵），使得norm(src*dst - I)最小，其中I是单位矩阵。对于#DECOMP_LU方法，如果成功计算出逆矩阵，则函数返回非零值；如果src是奇异矩阵，则返回0。对于#DECOMP_SVD方法，函数返回src的逆条件数（最小奇异值与最大奇异值的比率），如果src是奇异矩阵，则返回0。如果src是奇异矩阵，则SVD方法计算伪逆矩阵。与#DECOMP_LU类似，#DECOMP_CHOLESKY方法仅适用于非奇异方阵，这些方阵也应该是对称的和正定的。在这种情况下，函数将反转后的矩阵存储在dst中并返回非零值。否则，它返回0。
        参数
        src - 输入的M x N浮点型矩阵。
        dst - 输出的N x M大小的矩阵，与src类型相同。参见：solve, SVD
        返回
        自动生成

      • solve

        public static boolean solve​(Mat src1,
                            Mat src2,
                            Mat dst,
                            int flags)
        求解一个或多个线性系统或最小二乘问题。函数cv::solve求解线性系统或最小二乘问题（后者可以使用SVD或QR方法，或者通过指定标志#DECOMP_NORMAL）：dst = arg minX || src1 ⋅ X - src2 || 如果使用#DECOMP_LU或#DECOMP_CHOLESKY方法，如果src1（或src1Tsrc1）是非奇异的，则函数返回1。否则，返回0。在后一种情况下，dst无效。其他方法在左侧部分奇异的情况下找到伪解。注意：如果要找到欠定的奇异系统src1⋅dst=0的单位范数解，则solve函数将无法工作。请改用SVD::solveZ。
        参数
        src1 - 系统左侧的输入矩阵。
        src2 - 系统右侧的输入矩阵。
        dst - 输出解。
        flags - 解法（矩阵求逆）方法 (#DecompTypes) 参见：invert, SVD, eigen
        返回
        自动生成

      • solve

        public static boolean solve​(Mat src1,
                            Mat src2,
                            Mat dst)
        求解一个或多个线性系统或最小二乘问题。函数cv::solve求解线性系统或最小二乘问题（后者可以使用SVD或QR方法，或者通过指定标志#DECOMP_NORMAL）：dst = arg minX || src1 ⋅ X - src2 || 如果使用#DECOMP_LU或#DECOMP_CHOLESKY方法，如果src1（或src1Tsrc1）是非奇异的，则函数返回1。否则，返回0。在后一种情况下，dst无效。其他方法在左侧部分奇异的情况下找到伪解。注意：如果要找到欠定的奇异系统src1⋅dst=0的单位范数解，则solve函数将无法工作。请改用SVD::solveZ。
        参数
        src1 - 系统左侧的输入矩阵。
        src2 - 系统右侧的输入矩阵。
        dst - 输出解。参见：invert, SVD, eigen
        返回
        自动生成

      • sort

        public static void sort​(Mat src,
                        Mat dst,
                        int flags)
        对矩阵的每一行或每一列进行排序。函数cv::sort按升序或降序对每个矩阵行或每个矩阵列进行排序。因此，您应该传递两个操作标志以获得所需的行为。如果要按字典顺序对矩阵行或列进行排序，可以使用具有适当比较谓词的STL std::sort通用函数。
        参数
        src - 输入单通道数组。
        dst - 与 src 大小和类型相同的输出数组。
        flags - 操作标志，是#SortFlags的组合 参见：sortIdx, randShuffle

      • sortIdx

        public static void sortIdx​(Mat src,
                           Mat dst,
                           int flags)
        对矩阵的每一行或每一列进行排序。函数cv::sortIdx按升序或降序对每个矩阵行或每个矩阵列进行排序。因此，您应该传递两个操作标志以获得所需的行为。它不重新排序元素本身，而是将排序元素的索引存储在输出数组中。例如： Mat A = Mat::eye(3,3,CV_32F), B; sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING); // B 可能包含 // （由于A中元素相等，一些排列是可能的）： // [[1, 2, 0], [0, 2, 1], [0, 1, 2]]
        参数
        src - 输入单通道数组。
        dst - 与src大小相同的输出整数数组。
        flags - 操作标志，可以是cv::SortFlags的组合 参见：sort, randShuffle

      • solveCubic

        public static int solveCubic​(Mat coeffs,
                             Mat roots)
        查找三次方程的实根。函数solveCubic查找三次方程的实根。
        • 如果coeffs是一个4元素向量：\(\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\)
        • 如果coeffs是一个3元素向量：\(x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\)
        根存储在roots数组中。
        参数
        coeffs - 方程系数，一个包含3或4个元素的数组。
        roots - 输出的实根数组，包含1或3个元素。
        返回
        实根的数量。可以是0、1或3。

      • solvePoly

        public static double solvePoly​(Mat coeffs,
                               Mat roots,
                               int maxIters)
        查找多项式方程的实数或复数根。函数cv::solvePoly查找多项式方程的实数和复数根：\(\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\)
        参数
        coeffs - 多项式系数数组。
        roots - 输出的（复数）根数组。
        maxIters - 算法执行的最大迭代次数。
        返回
        自动生成

      • solvePoly

        public static double solvePoly​(Mat coeffs,
                               Mat roots)
        查找多项式方程的实数或复数根。函数cv::solvePoly查找多项式方程的实数和复数根：\(\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\)
        参数
        coeffs - 多项式系数数组。
        roots - 输出的（复数）根数组。
        返回
        自动生成

      • eigen

        public static boolean eigen​(Mat src,
                            Mat eigenvalues,
                            Mat eigenvectors)
        计算对称矩阵的特征值和特征向量。函数cv::eigen计算对称矩阵src的特征值，或特征值和特征向量： src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() 注意： 使用cv::eigenNonSymmetric计算非对称矩阵的实特征值和特征向量。
        参数
        src - 输入矩阵，必须是CV_32FC1或CV_64FC1类型，大小为方阵，且是对称的 (src ^T^ == src)。
        eigenvalues - 输出的特征值向量，与src类型相同；特征值按降序存储。
        eigenvectors - 输出的特征向量矩阵；大小和类型与src相同；特征向量作为后续矩阵行存储，顺序与对应的特征值相同。参见：eigenNonSymmetric, completeSymm, PCA
        返回
        自动生成

      • eigen

        public static boolean eigen​(Mat src,
                            Mat eigenvalues)
        计算对称矩阵的特征值和特征向量。函数cv::eigen计算对称矩阵src的特征值，或特征值和特征向量： src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() 注意： 使用cv::eigenNonSymmetric计算非对称矩阵的实特征值和特征向量。
        参数
        src - 输入矩阵，必须是CV_32FC1或CV_64FC1类型，大小为方阵，且是对称的 (src ^T^ == src)。
        eigenvalues - 输出的特征值向量，与src类型相同；特征值按降序存储。特征向量作为后续矩阵行存储，顺序与对应的特征值相同。参见：eigenNonSymmetric, completeSymm, PCA
        返回
        自动生成

      • eigenNonSymmetric

        public static void eigenNonSymmetric​(Mat src,
                                     Mat eigenvalues,
                                     Mat eigenvectors)
        计算非对称矩阵的特征值和特征向量（仅限实特征值）。注意： 假设特征值为实数。该函数计算方阵src的特征值和特征向量（可选）： src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
        参数
        src - 输入矩阵 (CV_32FC1或CV_64FC1类型)。
        eigenvalues - 输出的特征值向量 (类型与src相同)。
        eigenvectors - 输出的特征向量矩阵 (类型与src相同)。特征向量作为后续矩阵行存储，顺序与对应的特征值相同。参见：eigen

      • calcCovarMatrix

        public static void calcCovarMatrix​(Mat samples,
                                   Mat covar,
                                   Mat mean,
                                   int flags,
                                   int ctype)
        注意：使用 #COVAR_ROWS 或 #COVAR_COLS 标志
        参数
        samples - 样本作为单个矩阵的行/列存储。
        covar - 输出的协方差矩阵，类型为ctype，大小为方阵。
        mean - 输入或输出（取决于标志）数组，作为输入向量的平均值。
        flags - 操作标志，作为#CovarFlags的组合。
        ctype - 矩阵类型；默认值为'CV_64F'。

      • calcCovarMatrix

        public static void calcCovarMatrix​(Mat samples,
                                   Mat covar,
                                   Mat mean,
                                   int flags)
        注意：使用 #COVAR_ROWS 或 #COVAR_COLS 标志
        参数
        samples - 样本作为单个矩阵的行/列存储。
        covar - 输出的协方差矩阵，类型为ctype，大小为方阵。
        mean - 输入或输出（取决于标志）数组，作为输入向量的平均值。
        flags - 操作标志，作为#CovarFlags的组合。

      • PCACompute

        public static void PCACompute​(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              int maxComponents)
        包装PCA::operator()。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        maxComponents - 自动生成

      • PCACompute

        public static void PCACompute​(Mat data,
                              Mat mean,
                              Mat eigenvectors)
        包装PCA::operator()。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues,
                               int maxComponents)
        包装PCA::operator()并添加特征值输出参数。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        eigenvalues - 自动生成
        maxComponents - 自动生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues)
        包装PCA::operator()并添加特征值输出参数。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        eigenvalues - 自动生成

      • PCACompute

        public static void PCACompute​(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              double retainedVariance)
        包装PCA::operator()。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        retainedVariance - 自动生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues,
                               double retainedVariance)
        包装PCA::operator()并添加特征值输出参数。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        eigenvalues - 自动生成
        retainedVariance - 自动生成

      • PCAProject

        public static void PCAProject​(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              Mat result)
        包装PCA::project。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        result - 自动生成

      • PCABackProject

        public static void PCABackProject​(Mat data,
                                  Mat mean,
                                  Mat eigenvectors,
                                  Mat result)
        包装PCA::backProject。
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        result - 自动生成

      • SVDecomp

        public static void SVDecomp​(Mat src,
                            Mat w,
                            Mat u,
                            Mat vt,
                            int flags)
        封装 SVD::compute
        参数
        src - 自动生成
        w - 自动生成
        u - 自动生成
        vt - 自动生成
        flags - 自动生成

      • SVDecomp

        public static void SVDecomp​(Mat src,
                            Mat w,
                            Mat u,
                            Mat vt)
        封装 SVD::compute
        参数
        src - 自动生成
        w - 自动生成
        u - 自动生成
        vt - 自动生成

      • SVBackSubst

        public static void SVBackSubst​(Mat w,
                               Mat u,
                               Mat vt,
                               Mat rhs,
                               Mat dst)
        包装 SVD::backSubst
        参数
        w - 自动生成
        u - 自动生成
        vt - 自动生成
        rhs - 自动生成
        dst - 自动生成

      • Mahalanobis

        public static double Mahalanobis​(Mat v1,
                                 Mat v2,
                                 Mat icovar)
        计算两个向量之间的马氏距离。函数cv::Mahalanobis计算并返回两个向量之间的加权距离：\(d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\) 协方差矩阵可以使用#calcCovarMatrix函数计算，然后使用invert函数求逆（最好使用#DECOMP_SVD方法，因为最准确）。
        参数
        v1 - 第一个1D输入向量。
        v2 - 第二个1D输入向量。
        icovar - 逆协方差矩阵。
        返回
        自动生成

      • dft

        public static void dft​(Mat src,
                       Mat dst,
                       int flags,
                       int nonzeroRows)
        执行一维或二维浮点数组的正向或逆向离散傅里叶变换。函数cv::dft执行以下操作之一：
        • 对N个元素的一维向量的正向傅里叶变换：\(Y = F^{(N)} \cdot X,\) 其中\(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) 且\(i=\sqrt{-1}\)
        • 对N个元素的一维向量的逆向傅里叶变换：\(\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\) 其中\(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
        • 对M x N矩阵的二维正向傅里叶变换：\(Y = F^{(M)} \cdot X \cdot F^{(N)}\)
        • 对M x N矩阵的二维逆向傅里叶变换：\(\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\)
        对于实数（单通道）数据，正向傅里叶变换的输出频谱或逆向傅里叶变换的输入频谱可以用称为*CCS*（复共轭对称）的打包格式表示。它借自IPL（英特尔®图像处理库）。以下是二维*CCS*频谱的样子：\(\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\) 对于实数向量的一维变换，输出看起来像上面矩阵的第一行。因此，函数根据标志和输入数组的大小选择操作模式。
        • 如果设置了#DFT_ROWS或输入数组只有一行或一列，则当设置了#DFT_ROWS时，函数对矩阵的每一行执行一维正向或逆向变换。否则，它执行二维变换。
        • 如果输入数组是实数且未设置#DFT_INVERSE，则函数执行一维或二维正向变换。
          • 当设置#DFT_COMPLEX_OUTPUT时，输出是与输入大小相同的复数矩阵。
          • 当未设置#DFT_COMPLEX_OUTPUT时，输出是与输入大小相同的实数矩阵。对于二维变换，它使用上面所示的打包格式。对于单个一维变换，它看起来像上面矩阵的第一行。对于多个一维变换（当使用#DFT_ROWS标志时），输出矩阵的每一行看起来都像上面矩阵的第一行。
        • 如果输入数组是复数数组，并且没有设置 #DFT_INVERSE 或 #DFT_REAL_OUTPUT 标志，则输出是一个与输入大小相同的复数数组。该函数根据标志 DFT_INVERSE 和 DFT_ROWS 执行整个输入数组或输入数组每一行的正向或逆向一维或二维变换。
        • 当设置 #DFT_INVERSE 标志且输入数组为实数数组，或者输入数组为复数数组但设置了 #DFT_REAL_OUTPUT 标志时，输出是一个与输入大小相同的实数数组。该函数根据标志 #DFT_INVERSE 和 #DFT_ROWS 执行整个输入数组或每一行的逆变换。
        如果设置了 #DFT_SCALE 标志，则变换后进行缩放。与 dct 不同，该函数支持任意大小的数组。但只有那些大小可以分解为小素数乘积（当前实现中为 2、3 和 5）的数组才能高效处理。可以使用 getOptimalDFTSize 方法计算这种高效的 DFT 大小。下面的示例说明如何计算两个二维实数数组的基于 DFT 的卷积： void convolveDFT(InputArray A, InputArray B, OutputArray C) { // 根据需要重新分配输出数组 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); Size dftSize; // 计算 DFT 变换的大小 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); // 分配临时缓冲区并用 0 初始化 Mat tempA(dftSize, A.type(), Scalar::all(0)); Mat tempB(dftSize, B.type(), Scalar::all(0)); // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); A.copyTo(roiA); Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); B.copyTo(roiB); // 现在就地变换填充后的 A 和 B； // 使用 "nonzeroRows" 提示以加快处理速度 dft(tempA, tempA, 0, A.rows); dft(tempB, tempB, 0, B.rows); // 将频谱相乘； // 该函数可以很好地处理打包的频谱表示 mulSpectrums(tempA, tempB, tempA); // 将乘积从频域转换回时域。 // 即使所有结果行都非零， // 您只需要前 C.rows 行，因此您 // 将 nonzeroRows == C.rows dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); // 现在将结果复制回 C。 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); // 所有临时缓冲区都将自动释放 } 为了优化此示例，请考虑以下方法
        • 由于将 nonzeroRows != 0 传递给正向变换调用，并且 A 和 B 分别复制到 tempA 和 tempB 的左上角，因此无需清除整个 tempA 和 tempB。只需要清除矩阵的 tempA.cols - A.cols（tempB.cols - B.cols）最右列。
        • 此基于 DFT 的卷积不必应用于整个大型数组，特别是当 B 明显小于 A 或反之亦然时。相反，您可以分部分计算卷积。为此，您需要将输出数组 C 分割成多个块。对于每个块，估计需要 A 和 B 的哪些部分来计算此块中的卷积。如果 C 中的块太小，则由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个块是一个像素时，算法就等效于朴素的卷积算法。如果块太大，则临时数组 tempA 和 tempB 也会变得太大，并且由于缓存局部性差也会导致速度降低。因此，中间存在一个最佳块大小。
        • 如果可以并行计算 C 中的不同块，从而分部分完成卷积，则可以将循环线程化。
        所有上述改进都已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，您可以获得比上述理论上最佳实现更好的性能。但是，这两个函数实际上计算的是互相关，而不是卷积，因此您需要使用 flip 函数垂直和水平“翻转”第二个卷积操作数 B。注意：
        • 可以在 opencv_source_code/samples/cpp/dft.cpp 中找到使用离散傅里叶变换的示例。
        • （Python）可以在 opencv_source/samples/python/deconvolution.py 中找到使用 dft 功能执行维纳反卷积的示例。
        • （Python）可以在 opencv_source/samples/python/dft.py 中找到重新排列傅里叶图像象限的示例。
        参数
        src - 可以是实数或复数的输入数组。
        dst - 输出数组，其大小和类型取决于标志。
        flags - 变换标志，表示 #DftFlags 的组合。
        nonzeroRows - 当参数不为零时，函数假设只有输入数组的前 nonzeroRows 行（未设置 #DFT_INVERSE）或输出数组的前 nonzeroRows 行（已设置 #DFT_INVERSE）包含非零值，因此，函数可以更有效地处理其余行并节省一些时间；此技术对于使用 DFT 计算数组互相关或卷积非常有用。参见：dct、getOptimalDFTSize、mulSpectrums、filter2D、matchTemplate、flip、cartToPolar、magnitude、phase

      • dft

        public static void dft​(Mat src,
                       Mat dst,
                       int flags)
        执行一维或二维浮点数组的正向或逆向离散傅里叶变换。函数cv::dft执行以下操作之一：
        • 对N个元素的一维向量的正向傅里叶变换：\(Y = F^{(N)} \cdot X,\) 其中\(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) 且\(i=\sqrt{-1}\)
        • 对N个元素的一维向量的逆向傅里叶变换：\(\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\) 其中\(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
        • 对M x N矩阵的二维正向傅里叶变换：\(Y = F^{(M)} \cdot X \cdot F^{(N)}\)
        • 对M x N矩阵的二维逆向傅里叶变换：\(\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\)
        对于实数（单通道）数据，正向傅里叶变换的输出频谱或逆向傅里叶变换的输入频谱可以用称为*CCS*（复共轭对称）的打包格式表示。它借自IPL（英特尔®图像处理库）。以下是二维*CCS*频谱的样子：\(\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\) 对于实数向量的一维变换，输出看起来像上面矩阵的第一行。因此，函数根据标志和输入数组的大小选择操作模式。
        • 如果设置了#DFT_ROWS或输入数组只有一行或一列，则当设置了#DFT_ROWS时，函数对矩阵的每一行执行一维正向或逆向变换。否则，它执行二维变换。
        • 如果输入数组是实数且未设置#DFT_INVERSE，则函数执行一维或二维正向变换。
          • 当设置#DFT_COMPLEX_OUTPUT时，输出是与输入大小相同的复数矩阵。
          • 当未设置#DFT_COMPLEX_OUTPUT时，输出是与输入大小相同的实数矩阵。对于二维变换，它使用上面所示的打包格式。对于单个一维变换，它看起来像上面矩阵的第一行。对于多个一维变换（当使用#DFT_ROWS标志时），输出矩阵的每一行看起来都像上面矩阵的第一行。
        • 如果输入数组是复数数组，并且没有设置 #DFT_INVERSE 或 #DFT_REAL_OUTPUT 标志，则输出是一个与输入大小相同的复数数组。该函数根据标志 DFT_INVERSE 和 DFT_ROWS 执行整个输入数组或输入数组每一行的正向或逆向一维或二维变换。
        • 当设置 #DFT_INVERSE 标志且输入数组为实数数组，或者输入数组为复数数组但设置了 #DFT_REAL_OUTPUT 标志时，输出是一个与输入大小相同的实数数组。该函数根据标志 #DFT_INVERSE 和 #DFT_ROWS 执行整个输入数组或每一行的逆变换。
        如果设置了 #DFT_SCALE 标志，则变换后进行缩放。与 dct 不同，该函数支持任意大小的数组。但只有那些大小可以分解为小素数乘积（当前实现中为 2、3 和 5）的数组才能高效处理。可以使用 getOptimalDFTSize 方法计算这种高效的 DFT 大小。下面的示例说明如何计算两个二维实数数组的基于 DFT 的卷积： void convolveDFT(InputArray A, InputArray B, OutputArray C) { // 根据需要重新分配输出数组 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); Size dftSize; // 计算 DFT 变换的大小 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); // 分配临时缓冲区并用 0 初始化 Mat tempA(dftSize, A.type(), Scalar::all(0)); Mat tempB(dftSize, B.type(), Scalar::all(0)); // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); A.copyTo(roiA); Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); B.copyTo(roiB); // 现在就地变换填充后的 A 和 B； // 使用 "nonzeroRows" 提示以加快处理速度 dft(tempA, tempA, 0, A.rows); dft(tempB, tempB, 0, B.rows); // 将频谱相乘； // 该函数可以很好地处理打包的频谱表示 mulSpectrums(tempA, tempB, tempA); // 将乘积从频域转换回时域。 // 即使所有结果行都非零， // 您只需要前 C.rows 行，因此您 // 将 nonzeroRows == C.rows dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); // 现在将结果复制回 C。 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); // 所有临时缓冲区都将自动释放 } 为了优化此示例，请考虑以下方法
        • 由于将 nonzeroRows != 0 传递给正向变换调用，并且 A 和 B 分别复制到 tempA 和 tempB 的左上角，因此无需清除整个 tempA 和 tempB。只需要清除矩阵的 tempA.cols - A.cols（tempB.cols - B.cols）最右列。
        • 此基于 DFT 的卷积不必应用于整个大型数组，特别是当 B 明显小于 A 或反之亦然时。相反，您可以分部分计算卷积。为此，您需要将输出数组 C 分割成多个块。对于每个块，估计需要 A 和 B 的哪些部分来计算此块中的卷积。如果 C 中的块太小，则由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个块是一个像素时，算法就等效于朴素的卷积算法。如果块太大，则临时数组 tempA 和 tempB 也会变得太大，并且由于缓存局部性差也会导致速度降低。因此，中间存在一个最佳块大小。
        • 如果可以并行计算 C 中的不同块，从而分部分完成卷积，则可以将循环线程化。
        所有上述改进都已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，您可以获得比上述理论上最佳实现更好的性能。但是，这两个函数实际上计算的是互相关，而不是卷积，因此您需要使用 flip 函数垂直和水平“翻转”第二个卷积操作数 B。注意：
        • 可以在 opencv_source_code/samples/cpp/dft.cpp 中找到使用离散傅里叶变换的示例。
        • （Python）可以在 opencv_source/samples/python/deconvolution.py 中找到使用 dft 功能执行维纳反卷积的示例。
        • （Python）可以在 opencv_source/samples/python/dft.py 中找到重新排列傅里叶图像象限的示例。
        参数
        src - 可以是实数或复数的输入数组。
        dst - 输出数组，其大小和类型取决于标志。
        flags - 变换标志，表示 #DftFlags 的组合。输入数组的前 nonzeroRows 行（未设置 #DFT_INVERSE）或输出数组的前 nonzeroRows 行（已设置 #DFT_INVERSE）包含非零值，因此，函数可以更有效地处理其余行并节省一些时间；此技术对于使用 DFT 计算数组互相关或卷积非常有用。参见：dct、getOptimalDFTSize、mulSpectrums、filter2D、matchTemplate、flip、cartToPolar、magnitude、phase

      • dft

        public static void dft​(Mat src,
                       Mat dst)
        执行一维或二维浮点数组的正向或逆向离散傅里叶变换。函数cv::dft执行以下操作之一：
        • 对N个元素的一维向量的正向傅里叶变换：\(Y = F^{(N)} \cdot X,\) 其中\(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) 且\(i=\sqrt{-1}\)
        • 对N个元素的一维向量的逆向傅里叶变换：\(\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\) 其中\(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
        • 对M x N矩阵的二维正向傅里叶变换：\(Y = F^{(M)} \cdot X \cdot F^{(N)}\)
        • 对M x N矩阵的二维逆向傅里叶变换：\(\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\)
        对于实数（单通道）数据，正向傅里叶变换的输出频谱或逆向傅里叶变换的输入频谱可以用称为*CCS*（复共轭对称）的打包格式表示。它借自IPL（英特尔®图像处理库）。以下是二维*CCS*频谱的样子：\(\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\) 对于实数向量的一维变换，输出看起来像上面矩阵的第一行。因此，函数根据标志和输入数组的大小选择操作模式。
        • 如果设置了#DFT_ROWS或输入数组只有一行或一列，则当设置了#DFT_ROWS时，函数对矩阵的每一行执行一维正向或逆向变换。否则，它执行二维变换。
        • 如果输入数组是实数且未设置#DFT_INVERSE，则函数执行一维或二维正向变换。
          • 当设置#DFT_COMPLEX_OUTPUT时，输出是与输入大小相同的复数矩阵。
          • 当未设置#DFT_COMPLEX_OUTPUT时，输出是与输入大小相同的实数矩阵。对于二维变换，它使用上面所示的打包格式。对于单个一维变换，它看起来像上面矩阵的第一行。对于多个一维变换（当使用#DFT_ROWS标志时），输出矩阵的每一行看起来都像上面矩阵的第一行。
        • 如果输入数组是复数数组，并且没有设置 #DFT_INVERSE 或 #DFT_REAL_OUTPUT 标志，则输出是一个与输入大小相同的复数数组。该函数根据标志 DFT_INVERSE 和 DFT_ROWS 执行整个输入数组或输入数组每一行的正向或逆向一维或二维变换。
        • 当设置 #DFT_INVERSE 标志且输入数组为实数数组，或者输入数组为复数数组但设置了 #DFT_REAL_OUTPUT 标志时，输出是一个与输入大小相同的实数数组。该函数根据标志 #DFT_INVERSE 和 #DFT_ROWS 执行整个输入数组或每一行的逆变换。
        如果设置了 #DFT_SCALE 标志，则变换后进行缩放。与 dct 不同，该函数支持任意大小的数组。但只有那些大小可以分解为小素数乘积（当前实现中为 2、3 和 5）的数组才能高效处理。可以使用 getOptimalDFTSize 方法计算这种高效的 DFT 大小。下面的示例说明如何计算两个二维实数数组的基于 DFT 的卷积： void convolveDFT(InputArray A, InputArray B, OutputArray C) { // 根据需要重新分配输出数组 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); Size dftSize; // 计算 DFT 变换的大小 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); // 分配临时缓冲区并用 0 初始化 Mat tempA(dftSize, A.type(), Scalar::all(0)); Mat tempB(dftSize, B.type(), Scalar::all(0)); // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); A.copyTo(roiA); Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); B.copyTo(roiB); // 现在就地变换填充后的 A 和 B； // 使用 "nonzeroRows" 提示以加快处理速度 dft(tempA, tempA, 0, A.rows); dft(tempB, tempB, 0, B.rows); // 将频谱相乘； // 该函数可以很好地处理打包的频谱表示 mulSpectrums(tempA, tempB, tempA); // 将乘积从频域转换回时域。 // 即使所有结果行都非零， // 您只需要前 C.rows 行，因此您 // 将 nonzeroRows == C.rows dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); // 现在将结果复制回 C。 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); // 所有临时缓冲区都将自动释放 } 为了优化此示例，请考虑以下方法
        • 由于将 nonzeroRows != 0 传递给正向变换调用，并且 A 和 B 分别复制到 tempA 和 tempB 的左上角，因此无需清除整个 tempA 和 tempB。只需要清除矩阵的 tempA.cols - A.cols（tempB.cols - B.cols）最右列。
        • 此基于 DFT 的卷积不必应用于整个大型数组，特别是当 B 明显小于 A 或反之亦然时。相反，您可以分部分计算卷积。为此，您需要将输出数组 C 分割成多个块。对于每个块，估计需要 A 和 B 的哪些部分来计算此块中的卷积。如果 C 中的块太小，则由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个块是一个像素时，算法就等效于朴素的卷积算法。如果块太大，则临时数组 tempA 和 tempB 也会变得太大，并且由于缓存局部性差也会导致速度降低。因此，中间存在一个最佳块大小。
        • 如果可以并行计算 C 中的不同块，从而分部分完成卷积，则可以将循环线程化。
        所有上述改进都已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，您可以获得比上述理论上最佳实现更好的性能。但是，这两个函数实际上计算的是互相关，而不是卷积，因此您需要使用 flip 函数垂直和水平“翻转”第二个卷积操作数 B。注意：
        • 可以在 opencv_source_code/samples/cpp/dft.cpp 中找到使用离散傅里叶变换的示例。
        • （Python）可以在 opencv_source/samples/python/deconvolution.py 中找到使用 dft 功能执行维纳反卷积的示例。
        • （Python）可以在 opencv_source/samples/python/dft.py 中找到重新排列傅里叶图像象限的示例。
        参数
        src - 可以是实数或复数的输入数组。
        dst - 输出数组，其大小和类型取决于标志。输入数组的前 nonzeroRows 行（未设置 #DFT_INVERSE）或输出数组的前 nonzeroRows 行（已设置 #DFT_INVERSE）包含非零值，因此，函数可以更有效地处理其余行并节省一些时间；此技术对于使用 DFT 计算数组互相关或卷积非常有用。参见：dct、getOptimalDFTSize、mulSpectrums、filter2D、matchTemplate、flip、cartToPolar、magnitude、phase

      • idft

        public static void idft​(Mat src,
                        Mat dst,
                        int flags,
                        int nonzeroRows)
        计算一维或二维数组的逆离散傅里叶变换。idft(src, dst, flags) 等效于 dft(src, dst, flags | #DFT_INVERSE)。注意：dft 和 idft 默认情况下都不缩放结果。因此，您应该显式地将 #DFT_SCALE 传递给 dft 或 idft 之一，以使这些变换互为逆变换。参见：dft、dct、idct、mulSpectrums、getOptimalDFTSize
        参数
        src - 输入浮点实数或复数数组。
        dst - 输出数组，其大小和类型取决于标志。
        flags - 操作标志（参见 dft 和 #DftFlags）。
        nonzeroRows - 要处理的 dst 行数；其余行的内容未定义（参见 dft 说明中的卷积示例）。

      • idft

        public static void idft​(Mat src,
                        Mat dst,
                        int flags)
        计算一维或二维数组的逆离散傅里叶变换。idft(src, dst, flags) 等效于 dft(src, dst, flags | #DFT_INVERSE)。注意：dft 和 idft 默认情况下都不缩放结果。因此，您应该显式地将 #DFT_SCALE 传递给 dft 或 idft 之一，以使这些变换互为逆变换。参见：dft、dct、idct、mulSpectrums、getOptimalDFTSize
        参数
        src - 输入浮点实数或复数数组。
        dst - 输出数组，其大小和类型取决于标志。
        flags - 操作标志（参见 dft 和 #DftFlags）。dft 说明中的卷积示例。

      • idft

        public static void idft​(Mat src,
                        Mat dst)
        计算一维或二维数组的逆离散傅里叶变换。idft(src, dst, flags) 等效于 dft(src, dst, flags | #DFT_INVERSE)。注意：dft 和 idft 默认情况下都不缩放结果。因此，您应该显式地将 #DFT_SCALE 传递给 dft 或 idft 之一，以使这些变换互为逆变换。参见：dft、dct、idct、mulSpectrums、getOptimalDFTSize
        参数
        src - 输入浮点实数或复数数组。
        dst - 输出数组，其大小和类型取决于标志。dft 说明中的卷积示例。

      • dct

        public static void dct​(Mat src,
                       Mat dst,
                       int flags)
        执行一维或二维数组的正向或逆向离散余弦变换。函数 cv::dct 执行一维或二维浮点数组的正向或逆向离散余弦变换 (DCT)
        • N个元素的一维向量的正向余弦变换：\(Y = C^{(N)} \cdot X\)，其中\(C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\)，且\(\alpha_0=1\)，当 *j > 0* 时，\(\alpha_j=2\)。
        • N个元素的一维向量的逆余弦变换：\(X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\)（因为\(C^{(N)}\)是正交矩阵，\(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\)）
        • M x N矩阵的正向二维余弦变换：\(Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\)
        • M x N矩阵的逆向二维余弦变换：\(X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\)
        函数通过查看标志和输入数组的大小来选择操作模式。
        • 如果 (flags & #DCT_INVERSE) == 0，则函数执行正向一维或二维变换。否则，它是一个逆向一维或二维变换。
        • 如果 (flags & #DCT_ROWS) != 0，则函数对每一行执行一维变换。
        • 如果数组是单列或单行，则函数执行一维变换。
        • 如果以上都不成立，则函数执行二维变换。
        注意：当前dct支持偶数大小的数组（2, 4, 6 ...）。对于数据分析和近似，如有必要，可以对数组进行填充。此外，函数性能很大程度上取决于数组大小，并且不是单调的（参见getOptimalDFTSize）。在当前实现中，大小为N的向量的DCT是通过大小为N/2的向量的DFT计算的。因此，最佳DCT大小N1 >= N可以计算如下： size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } N1 = getOptimalDCTSize(N);
        参数
        src - 输入浮点型数组。
        dst - 与src大小和类型相同的输出数组。
        flags - 变换标志，作为cv::DftFlags (DCT_*)的组合 参见：dft, getOptimalDFTSize, idct

      • dct

        public static void dct​(Mat src,
                       Mat dst)
        执行一维或二维数组的正向或逆向离散余弦变换。函数 cv::dct 执行一维或二维浮点数组的正向或逆向离散余弦变换 (DCT)
        • N个元素的一维向量的正向余弦变换：\(Y = C^{(N)} \cdot X\)，其中\(C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\)，且\(\alpha_0=1\)，当 *j > 0* 时，\(\alpha_j=2\)。
        • N个元素的一维向量的逆余弦变换：\(X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\)（因为\(C^{(N)}\)是正交矩阵，\(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\)）
        • M x N矩阵的正向二维余弦变换：\(Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\)
        • M x N矩阵的逆向二维余弦变换：\(X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\)
        函数通过查看标志和输入数组的大小来选择操作模式。
        • 如果 (flags & #DCT_INVERSE) == 0，则函数执行正向一维或二维变换。否则，它是一个逆向一维或二维变换。
        • 如果 (flags & #DCT_ROWS) != 0，则函数对每一行执行一维变换。
        • 如果数组是单列或单行，则函数执行一维变换。
        • 如果以上都不成立，则函数执行二维变换。
        注意：当前dct支持偶数大小的数组（2, 4, 6 ...）。对于数据分析和近似，如有必要，可以对数组进行填充。此外，函数性能很大程度上取决于数组大小，并且不是单调的（参见getOptimalDFTSize）。在当前实现中，大小为N的向量的DCT是通过大小为N/2的向量的DFT计算的。因此，最佳DCT大小N1 >= N可以计算如下： size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } N1 = getOptimalDCTSize(N);
        参数
        src - 输入浮点型数组。
        dst - 与src大小和类型相同的输出数组。参见：dft, getOptimalDFTSize, idct

      • idct

        public static void idct​(Mat src,
                        Mat dst,
                        int flags)
        计算一维或二维数组的逆离散余弦变换。idct(src, dst, flags) 等效于 dct(src, dst, flags | DCT_INVERSE)。
        参数
        src - 输入单通道浮点数组。
        dst - 与 src 大小和类型相同的输出数组。
        flags - 操作标志。参见：dct, dft, idft, getOptimalDFTSize

      • idct

        public static void idct​(Mat src,
                        Mat dst)
        计算一维或二维数组的逆离散余弦变换。idct(src, dst, flags) 等效于 dct(src, dst, flags | DCT_INVERSE)。
        参数
        src - 输入单通道浮点数组。
        dst - 与src大小和类型相同的输出数组。参见：dct, dft, idft, getOptimalDFTSize

      • mulSpectrums

        public static void mulSpectrums​(Mat a,
                                Mat b,
                                Mat c,
                                int flags,
                                boolean conjB)
        执行两个傅里叶频谱的逐元素相乘。函数cv::mulSpectrums执行两个CCS打包或复数矩阵的逐元素相乘，这两个矩阵是实数或复数傅里叶变换的结果。该函数与dft和idft一起可以快速计算两个数组的卷积（pass conjB=false）或相关性（pass conjB=true）。当数组是复数时，它们只是简单地（逐元素）相乘，可以选择共轭第二个数组的元素。当数组是实数时，假定它们是CCS打包的（详情参见dft）。
        参数
        a - 第一个输入数组。
        b - 第二个输入数组，大小和类型与src1相同。
        c - 与src1大小和类型相同的输出数组。
        flags - 操作标志；目前，唯一支持的标志是cv::DFT_ROWS，它指示src1和src2的每一行都是独立的一维傅里叶频谱。如果您不想使用此标志，则只需添加值为0。
        conjB - 可选标志，在乘法之前对第二个输入数组进行共轭(true)或不共轭(false)。

      • mulSpectrums

        public static void mulSpectrums​(Mat a,
                                Mat b,
                                Mat c,
                                int flags)
        执行两个傅里叶频谱的逐元素相乘。函数cv::mulSpectrums执行两个CCS打包或复数矩阵的逐元素相乘，这两个矩阵是实数或复数傅里叶变换的结果。该函数与dft和idft一起可以快速计算两个数组的卷积（pass conjB=false）或相关性（pass conjB=true）。当数组是复数时，它们只是简单地（逐元素）相乘，可以选择共轭第二个数组的元素。当数组是实数时，假定它们是CCS打包的（详情参见dft）。
        参数
        a - 第一个输入数组。
        b - 第二个输入数组，大小和类型与src1相同。
        c - 与src1大小和类型相同的输出数组。
        flags - 操作标志；目前，唯一支持的标志是cv::DFT_ROWS，它指示src1和src2的每一行都是独立的一维傅里叶频谱。如果您不想使用此标志，则只需添加值为0。

      • getOptimalDFTSize

        public static int getOptimalDFTSize​(int vecsize)
        返回给定向量大小的最佳DFT大小。DFT性能不是向量大小的单调函数。因此，当计算两个数组的卷积或执行数组的光谱分析时，通常有意义的是用零填充输入数据以获得稍大的数组，该数组可以比原始数组更快地进行变换。大小为2的幂（2, 4, 8, 16, 32, ...）的数组处理速度最快。但是，大小为2、3和5的乘积（例如，300 = 5\*5\*3\*2\*2）的数组也能相当有效地处理。函数cv::getOptimalDFTSize返回大于或等于vecsize的最小数字N，以便可以高效地处理大小为N的向量的DFT。在当前实现中，N = 2 ^p^ \* 3 ^q^ \* 5 ^r^，其中p、q、r为整数。如果vecsize太大（非常接近INT_MAX），则函数返回负数。虽然该函数不能直接用于估计DCT变换的最佳向量大小（因为当前DCT实现仅支持偶数大小的向量），但它可以很容易地处理为getOptimalDFTSize((vecsize+1)/2)\*2。
        参数
        vecsize - 向量大小。参见：dft, dct, idft, idct, mulSpectrums
        返回
        自动生成

      • setRNGSeed

        public static void setRNGSeed​(int seed)
        设置默认随机数生成器的状态。函数cv::setRNGSeed将默认随机数生成器的状态设置为自定义值。
        参数
        seed - 默认随机数生成器的新状态 参见：RNG, randu, randn

      • randu

        public static void randu​(Mat dst,
                         double low,
                         double high)
        生成单个均匀分布的随机数或随机数数组。函数的非模板变体用指定范围内的均匀分布的随机数填充矩阵dst：\(\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\)
        参数
        dst - 随机数的输出数组；该数组必须预先分配。
        low - 生成的随机数的包含下界。
        high - 生成的随机数的独占上界。参见：RNG, randn, theRNG

      • randn

        public static void randn​(Mat dst,
                         double mean,
                         double stddev)
        用正态分布的随机数填充数组。函数cv::randn用指定均值向量和标准差矩阵填充矩阵dst的正态分布随机数。生成的随机数被裁剪以适应输出数组数据类型的数值范围。
        参数
        dst - 随机数的输出数组；该数组必须预先分配，并有1到4个通道。
        mean - 生成的随机数的均值（期望值）。
        stddev - 生成的随机数的标准差；它可以是向量（在这种情况下，假设对角线标准差矩阵）或方阵。参见：RNG, randu

      • randShuffle

        public static void randShuffle​(Mat dst,
                               double iterFactor)
        随机打乱数组元素。函数cv::randShuffle通过随机选择元素对并交换它们来打乱指定的1D数组。这种交换操作的次数将为dst.rows\*dst.cols\*iterFactor。
        参数
        dst - 输入/输出数值1D数组。
        iterFactor - 确定随机交换操作次数的比例因子（见下文）。参见：RNG, sort

      • randShuffle

        public static void randShuffle​(Mat dst)
        随机打乱数组元素。函数cv::randShuffle通过随机选择元素对并交换它们来打乱指定的1D数组。这种交换操作的次数将为dst.rows\*dst.cols\*iterFactor。
        参数
        dst - 输入/输出数值1D数组。参见：RNG, sort

      • kmeans

        public static double kmeans​(Mat data,
                            int K,
                            Mat bestLabels,
                            TermCriteria criteria,
                            int attempts,
                            int flags,
                            Mat centers)
        查找聚类的中心，并将输入样本分组到聚类周围。函数kmeans实现k-means算法，该算法查找cluster_count个聚类的中心，并将输入样本分组到聚类周围。作为输出，\(\texttt{bestLabels}_i\)包含存储在样本矩阵第\(i^{th}\)行的样本的基于0的聚类索引。注意：
        • (Python)关于k-means聚类的示例可以在opencv_source_code/samples/python/kmeans.py中找到。
        参数
        data - 用于聚类的数据。需要一个具有浮点坐标的N维点数组。此数组的示例可以是
        • Mat points(count, 2, CV_32F);
        • Mat points(count, 1, CV_32FC2);
        • Mat points(1, count, CV_32FC2);
        • std::vector<cv::Point2f> points(sampleCount);
        K - 将集合划分为的簇数。
        bestLabels - 输入/输出整数数组，存储每个样本的簇索引。
        criteria - 算法终止条件，即最大迭代次数和/或所需的精度。精度由criteria.epsilon指定。一旦在某次迭代中每个簇中心移动的距离小于criteria.epsilon，算法就停止。
        attempts - 指定使用不同的初始标记执行算法的次数的标志。算法返回产生最佳紧凑性的标签（参见最后一个函数参数）。
        flags - 可以取cv::KmeansFlags值的标志
        centers - 簇中心的输出矩阵，每行代表一个簇中心。
        返回
        该函数返回紧凑性度量，该度量在每次尝试后计算为\(\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\)。选择最佳（最小）值，并由函数返回相应的标签和紧凑性值。基本上，您可以只使用函数的核心，将尝试次数设置为1，每次使用自定义算法初始化标签，使用（flags = #KMEANS_USE_INITIAL_LABELS）标志传递它们，然后选择最佳（最紧凑）聚类。

      • kmeans

        public static double kmeans​(Mat data,
                            int K,
                            Mat bestLabels,
                            TermCriteria criteria,
                            int attempts,
                            int flags)
        查找聚类的中心，并将输入样本分组到聚类周围。函数kmeans实现k-means算法，该算法查找cluster_count个聚类的中心，并将输入样本分组到聚类周围。作为输出，\(\texttt{bestLabels}_i\)包含存储在样本矩阵第\(i^{th}\)行的样本的基于0的聚类索引。注意：
        • (Python)关于k-means聚类的示例可以在opencv_source_code/samples/python/kmeans.py中找到。
        参数
        data - 用于聚类的数据。需要一个具有浮点坐标的N维点数组。此数组的示例可以是
        • Mat points(count, 2, CV_32F);
        • Mat points(count, 1, CV_32FC2);
        • Mat points(1, count, CV_32FC2);
        • std::vector<cv::Point2f> points(sampleCount);
        K - 将集合划分为的簇数。
        bestLabels - 输入/输出整数数组，存储每个样本的簇索引。
        criteria - 算法终止条件，即最大迭代次数和/或所需的精度。精度由criteria.epsilon指定。一旦在某次迭代中每个簇中心移动的距离小于criteria.epsilon，算法就停止。
        attempts - 指定使用不同的初始标记执行算法的次数的标志。算法返回产生最佳紧凑性的标签（参见最后一个函数参数）。
        flags - 可以取cv::KmeansFlags值的标志
        返回
        该函数返回紧凑性度量，该度量在每次尝试后计算为\(\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\)。选择最佳（最小）值，并由函数返回相应的标签和紧凑性值。基本上，您可以只使用函数的核心，将尝试次数设置为1，每次使用自定义算法初始化标签，使用（flags = #KMEANS_USE_INITIAL_LABELS）标志传递它们，然后选择最佳（最紧凑）聚类。

      • setNumThreads

        public static void setNumThreads​(int nthreads)
        OpenCV将尝试为后续的并行区域设置线程数。如果threads == 1，OpenCV将禁用线程优化并按顺序运行其所有函数。传递threads < 0 将线程数重置为系统默认值。该函数不是线程安全的。它不能在并行区域或并发线程中调用。OpenCV将尝试使用指定的线程数运行其函数，但某些行为与框架不同。
        • TBB - 如果没有指定其他线程数，则用户定义的并行构造将使用相同的线程数运行。如果用户稍后创建他自己的调度器，OpenCV将使用它。
        • OpenMP - 没有特殊定义的行为。
        • Concurrency - 如果threads == 1，OpenCV将禁用线程优化并按顺序运行其函数。
        • GCD - 只支持值 <= 0。
        • C= - 没有特殊定义的行为。
        参数
        nthreads - OpenCV使用的线程数。参见：getNumThreads，getThreadNum

      • getNumThreads

        public static int getNumThreads()
        返回OpenCV用于并行区域的线程数。如果OpenCV在没有线程支持的情况下构建，则始终返回1。返回值的确切含义取决于OpenCV库使用的线程框架。
        • TBB - OpenCV将尝试用于并行区域的线程数。如果用户代码中存在任何与OpenCV冲突的tbb::thread_scheduler_init，则函数返回TBB库使用的默认线程数。
        • OpenMP - 可用于形成新团队的线程数的上限。
        • Concurrency - OpenCV将尝试用于并行区域的线程数。
        • GCD - 不支持；为兼容性返回GCD线程池限制（512）。
        • C= - 如果之前使用threads > 0调用setNumThreads，OpenCV将尝试用于并行区域的线程数，否则返回进程可用的逻辑CPU数。参见：setNumThreads，getThreadNum
        返回
        自动生成

      • getThreadNum

        @Deprecated
public static int getThreadNum()
        已弃用。
        当前实现与本文档不符。返回值的确切含义取决于OpenCV库使用的线程框架。
        • TBB - 当前4.1 TBB版本不支持。将来可能会支持。
        • OpenMP - 调用线程在当前团队中的线程号。
        • Concurrency - 当前上下文正在其上执行的虚拟处理器的ID（主线程为0，其他线程为唯一编号，但不一定是1,2,3,...）。
        • GCD - 系统调用线程的ID。在并行区域内从不返回0。
        • C= - 当前并行任务的索引。参见：setNumThreads，getNumThreads
        返回当前并行区域中当前执行线程的索引。如果在并行区域之外调用，则始终返回0。
        返回
        自动生成

      • getBuildInformation

        public static java.lang.String getBuildInformation()
        返回完整的配置时间cmake输出。返回值是原始cmake输出，包括版本控制系统修订版、编译器版本、编译器标志、启用的模块和第三方库等。输出格式取决于目标架构。
        返回
        自动生成

      • getVersionString

        public static java.lang.String getVersionString()
        返回库版本字符串，例如“3.4.1-dev”。参见：getMajorVersion，getMinorVersion，getRevisionVersion
        返回
        自动生成

      • getVersionMajor

        public static int getVersionMajor()
        返回主库版本。
        返回
        自动生成

      • getVersionMinor

        public static int getVersionMinor()
        返回次要库版本。
        返回
        自动生成

      • getVersionRevision

        public static int getVersionRevision()
        返回库版本的修订字段。
        返回
        自动生成

      • getTickCount

        public static long getTickCount()
        返回刻度数。该函数返回某个事件后的刻度数（例如，机器启动时）。它可用于初始化RNG或通过在函数调用之前和之后读取刻度计数来测量函数执行时间。参见：getTickFrequency，TickMeter
        返回
        自动生成

      • getTickFrequency

        public static double getTickFrequency()
        返回每秒的刻度数。该函数返回每秒的刻度数。也就是说，以下代码计算以秒为单位的执行时间： double t = (double)getTickCount(); // 执行某些操作 ... t = ((double)getTickCount() - t)/getTickFrequency(); 参见：getTickCount，TickMeter
        返回
        自动生成

      • getCPUTickCount

        public static long getCPUTickCount()
        返回CPU刻度数。该函数返回某些架构（例如x86、x64、PowerPC）上的当前CPU刻度数。在其他平台上，该函数等效于getTickCount。它也可用于非常精确的时间测量以及RNG初始化。请注意，在多CPU系统的情况下，调用getCPUTickCount的线程可能会被挂起并在另一个具有其自身计数器的CPU上恢复。因此，理论上（以及实际上）对该函数的后续调用不一定返回单调递增的值。此外，由于现代CPU会根据负载改变CPU频率，因此某些代码中使用的CPU时钟数不能直接转换为时间单位。因此，getTickCount通常是测量执行时间的更可取的解决方案。
        返回
        自动生成

      • checkHardwareSupport

        public static boolean checkHardwareSupport​(int feature)
        如果主机硬件支持指定的特性，则返回true。如果主机硬件支持指定的特性，则该函数返回true。当用户调用setUseOptimized(false)时，后续对checkHardwareSupport()的调用将返回false，直到调用setUseOptimized(true)为止。通过这种方式，用户可以动态地打开和关闭OpenCV中的优化代码。
        参数
        feature - 感兴趣的特性，cv::CpuFeatures之一
        返回
        自动生成

      • getHardwareFeatureName

        public static java.lang.String getHardwareFeatureName​(int feature)
        根据 ID 返回特性名称。如果未定义特性，则返回空字符串。
        参数
        feature - 自动生成
        返回
        自动生成

      • getCPUFeaturesLine

        public static java.lang.String getCPUFeaturesLine()
        返回编译期间启用的CPU特性列表。返回值是一个字符串，包含用以下标记分隔的CPU特性的空格分隔列表
        • 无标记 - 基线特性
        • 前缀* - 分发器中启用的特性
        • 后缀? - 已启用但硬件中不可用的特性
        示例：SSE SSE2 SSE3 *SSE4.1 *SSE4.2 *FP16 *AVX *AVX2 *AVX512-SKX?
        返回
        自动生成

      • getNumberOfCPUs

        public static int getNumberOfCPUs()
        返回进程可用的逻辑 CPU 数量。
        返回
        自动生成

      • getDefaultAlgorithmHint

        public static int getDefaultAlgorithmHint()

      • setUseOptimized

        public static void setUseOptimized​(boolean onoff)
        启用或禁用优化代码。该函数可用于动态地打开和关闭优化的分派代码（在支持它的平台上使用SSE4.2、AVX/AVX2和其他指令的代码）。它设置一个全局标志，OpenCV函数将进一步检查该标志。由于该标志未在OpenCV内部循环中检查，因此只有在应用程序的顶层调用该函数才是安全的，在该层您可以确保没有其他OpenCV函数正在执行。默认情况下，除非在CMake中禁用，否则优化代码将启用。可以使用useOptimized检索当前状态。
        参数
        onoff - 指定是否应使用优化代码(onoff=true)或不使用优化代码(onoff=false)的布尔标志。

      • useOptimized

        public static boolean useOptimized()
        返回优化代码使用状态。如果启用了优化代码，则该函数返回true。否则，它返回false。
        返回
        自动生成

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path,
                                        boolean required,
                                        boolean silentMode)
        尝试查找请求的数据文件。搜索目录：1. 通过addSamplesDataSearchPath()传递的目录；2. OPENCV_SAMPLES_DATA_PATH_HINT环境变量；3. OPENCV_SAMPLES_DATA_PATH环境变量；如果参数值非空且未找到任何文件，则停止搜索。4. 基于以下内容检测构建/安装路径：a. 当前工作目录 (CWD)；b. 和/或二进制模块位置 (opencv_core/opencv_world，静态链接无效)；5. 如果检测到构建目录或当前目录位于源代码树中，则扫描&lt;source&gt;/{,data,samples/data}目录；6. 如果检测到安装目录，则扫描&lt;install&gt;/share/OpenCV目录。参见：cv::utils::findDataFile
        参数
        relative_path - 数据文件的相对路径
        required - 指定“文件未找到”的处理方式。如果为真，则函数打印信息消息并引发cv::Exception异常。如果为假，则函数返回空结果。
        silentMode - 禁用消息
        返回
        返回路径（绝对路径或相对于当前目录的相对路径），如果文件未找到则返回空字符串。

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path,
                                        boolean required)
        尝试查找请求的数据文件。搜索目录：1. 通过addSamplesDataSearchPath()传递的目录；2. OPENCV_SAMPLES_DATA_PATH_HINT环境变量；3. OPENCV_SAMPLES_DATA_PATH环境变量；如果参数值非空且未找到任何文件，则停止搜索。4. 基于以下内容检测构建/安装路径：a. 当前工作目录 (CWD)；b. 和/或二进制模块位置 (opencv_core/opencv_world，静态链接无效)；5. 如果检测到构建目录或当前目录位于源代码树中，则扫描&lt;source&gt;/{,data,samples/data}目录；6. 如果检测到安装目录，则扫描&lt;install&gt;/share/OpenCV目录。参见：cv::utils::findDataFile
        参数
        relative_path - 数据文件的相对路径
        required - 指定“文件未找到”的处理方式。如果为真，则函数打印信息消息并引发cv::Exception异常。如果为假，则函数返回空结果。
        返回
        返回路径（绝对路径或相对于当前目录的相对路径），如果文件未找到则返回空字符串。

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path)
        尝试查找请求的数据文件。搜索目录：1. 通过addSamplesDataSearchPath()传递的目录；2. OPENCV_SAMPLES_DATA_PATH_HINT环境变量；3. OPENCV_SAMPLES_DATA_PATH环境变量；如果参数值非空且未找到任何文件，则停止搜索。4. 基于以下内容检测构建/安装路径：a. 当前工作目录 (CWD)；b. 和/或二进制模块位置 (opencv_core/opencv_world，静态链接无效)；5. 如果检测到构建目录或当前目录位于源代码树中，则扫描&lt;source&gt;/{,data,samples/data}目录；6. 如果检测到安装目录，则扫描&lt;install&gt;/share/OpenCV目录。参见：cv::utils::findDataFile
        参数
        relative_path - 数据文件的相对路径。如果为真，则函数打印信息消息并引发cv::Exception异常。如果为假，则函数返回空结果。
        返回
        返回路径（绝对路径或相对于当前目录的相对路径），如果文件未找到则返回空字符串。

      • findFileOrKeep

        public static java.lang.String findFileOrKeep​(java.lang.String relative_path,
                                              boolean silentMode)

      • findFileOrKeep

        public static java.lang.String findFileOrKeep​(java.lang.String relative_path)

      • addSamplesDataSearchPath

        public static void addSamplesDataSearchPath​(java.lang.String path)
        通过添加新的搜索位置来覆盖搜索数据路径。仅当需要覆盖默认行为时才使用此方法。传入的路径按后进先出 (LIFO) 顺序使用。
        参数
        path - 使用的样本数据的路径

      • addSamplesDataSearchSubDirectory

        public static void addSamplesDataSearchSubDirectory​(java.lang.String subdir)
        追加样本搜索数据子目录。一般用法是添加OpenCV模块名称 (&lt;opencv_contrib&gt;/modules/&lt;name&gt;/samples/data -> &lt;name&gt;/samples/data + modules/&lt;name&gt;/samples/data)。传入的子目录按后进先出 (LIFO) 顺序使用。
        参数
        subdir - 样本数据子目录

      • setErrorVerbosity

        public static void setErrorVerbosity​(boolean verbose)

      • add

        public static void add​(Mat src1,
                       Scalar src2,
                       Mat dst,
                       Mat mask,
                       int dtype)

      • add

        public static void add​(Mat src1,
                       Scalar src2,
                       Mat dst,
                       Mat mask)

      • add

        public static void add​(Mat src1,
                       Scalar src2,
                       Mat dst)

      • subtract

        public static void subtract​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            Mat mask,
                            int dtype)

      • subtract

        public static void subtract​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            Mat mask)

      • subtract

        public static void subtract​(Mat src1,
                            Scalar src2,
                            Mat dst)

      • multiply

        public static void multiply​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            double scale,
                            int dtype)

      • multiply

        public static void multiply​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            double scale)

      • multiply

        public static void multiply​(Mat src1,
                            Scalar src2,
                            Mat dst)

      • divide

        public static void divide​(Mat src1,
                          Scalar src2,
                          Mat dst,
                          double scale,
                          int dtype)

      • divide

        public static void divide​(Mat src1,
                          Scalar src2,
                          Mat dst,
                          double scale)

      • divide

        public static void divide​(Mat src1,
                          Scalar src2,
                          Mat dst)

      • absdiff

        public static void absdiff​(Mat src1,
                           Scalar src2,
                           Mat dst)

      • compare

        public static void compare​(Mat src1,
                           Scalar src2,
                           Mat dst,
                           int cmpop)

      • min

        public static void min​(Mat src1,
                       Scalar src2,
                       Mat dst)

      • max

        public static void max​(Mat src1,
                       Scalar src2,
                       Mat dst)