软件包 org.opencv.core

类 Core

  • public class Core
extends java.lang.Object

    • 构造函数摘要

      构造函数 
      构造函数 描述
      Core()  

    • 方法摘要

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

      • 从类 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)
        以度为单位计算 2D 向量的角度。函数 fastAtan2 计算输入 2D 向量的全范围角度。角度以度为单位，范围从 0 到 360 度。精度约为 0.3 度。
        参数
        x - 向量的 x 坐标。
        y - 向量的 y 坐标。
        返回
        自动生成

      • useIPP

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

      • setUseIPP

        public static void setUseIPP​(boolean flag)

      • getIppVersion

        public static java.lang.String getIppVersion()

      • useIPP_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 时，无论 p 和 len 如何，函数总是返回 -1。另请参阅：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 时，不应用饱和（Saturation）。在溢出的情况下，您甚至可能会得到符号错误的结果。 注意： (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 时，不应用饱和（Saturation）。在溢出的情况下，您甚至可能会得到符号错误的结果。 注意： (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 时，不应用饱和（Saturation）。在溢出的情况下，您甚至可能会得到符号错误的结果。 注意： (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) 值为零的情况没有特殊定义的行为。使用常规的浮点除法。对于浮点数据（带有 NaN, Inf 结果值），预期符合 IEEE-754 标准的行为。 注意： 当输出数组深度为 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) 值为零的情况没有特殊定义的行为。使用常规的浮点除法。对于浮点数据（带有 NaN, Inf 结果值），预期符合 IEEE-754 标准的行为。 注意： 当输出数组深度为 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) 值为零的情况没有特殊定义的行为。使用常规的浮点除法。对于浮点数据（带有 NaN, Inf 结果值），预期符合 IEEE-754 标准的行为。 注意： 当输出数组深度为 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) 也可以完成任务，// 但它会分配一个临时矩阵
        参数
        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) 也可以完成任务，// 但它会分配一个临时矩阵
        参数
        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) 也可以完成任务，// 但它会分配一个临时矩阵
        参数
        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 以代表位深。如果输入数组不属于这两种类型，函数将报错。半精度浮点数的格式定义在 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 = \forkthree{0}{如果 \(\texttt{src}\) 的深度为 \(\texttt{CV_8U}\) 或 \(\texttt{CV_16U}\)}{128}{如果 \(\texttt{src}\) 的深度为 \(\texttt{CV_8S}\)}{32768}{如果 \(\texttt{src}\) 的深度为 \(\texttt{CV_16S}\)}\)
        参数
        src - 由 8 位或 16 位整数元素组成的输入数组。
        lut - 包含 256 个元素的查找表（如果 src 深度为 CV_8U 或 CV_8S）或 65536 个元素的查找表（如果 src 深度为 CV_16U 或 CV_16S）；在多通道输入数组的情况下，该表应为单通道（此时所有通道使用相同的表）或具有与输入数组相同的通道数。
        dst - 与 src 具有相同大小和通道数，且与 lut 具有相同深度的输出数组。 参阅：convertScaleAbs, Mat::convertTo

      • sumElems

        public static Scalar sumElems​(Mat src)
        计算数组元素的总和。cv::sum 函数为每个通道独立计算并返回数组元素的总和。
        参数
        src - 必须具有 1 到 4 个通道的输入数组。 参阅：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)
        返回非零像素的位置列表。给定一个二值矩阵（通常由 threshold()、compare()、>、== 等操作返回），将所有非零索引作为 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，并通过输出参数返回：\(\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\) 当所有掩码元素都为 0 时，该函数返回 mean=stddev=Scalar::all(0)。注意： 计算出的标准差仅是完整归一化协方差矩阵的对角线。如果需要全矩阵，您可以将多通道数组 M x N 重塑为单通道数组 M*N x mtx.channels()（仅当矩阵连续时可行），然后将矩阵传递给 calcCovarMatrix。
        参数
        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，并通过输出参数返回：\(\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\) 当所有掩码元素都为 0 时，该函数返回 mean=stddev=Scalar::all(0)。注意： 计算出的标准差仅是完整归一化协方差矩阵的对角线。如果需要全矩阵，您可以将多通道数组 M x N 重塑为单通道数组 M*N x mtx.channels()（仅当矩阵连续时可行），然后将矩阵传递给 calcCovarMatrix。
        参数
        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} \) 范数计算如下 \(align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \) 对于 \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\)，计算结果为 \(align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \) 下图显示了三个范数函数 \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) 和 \(\| r(x) \|_{L_\infty}\) 的所有值。值得注意的是，对于示例函数 \( r(x) \)，\( L_{1} \) 范数构成了上限，而 \( L_{\infty} \) 范数构成了下限。![上述示例中不同范数函数的图表](pics/NormTypes_OneArray_1-2-INF.png) 当指定了掩码参数且不为空时，范数仅在掩码指定的区域内计算。如果未指定 normType，则使用 #NORM_L2。多通道输入数组被视为单通道数组，即所有通道的结果被合并。汉明范数（Hamming norms）只能使用 CV_8U 深度的数组进行计算。
        参数
        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} \) 范数计算如下 \(align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \) 对于 \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\)，计算结果为 \(align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \) 下图显示了三个范数函数 \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) 和 \(\| r(x) \|_{L_\infty}\) 的所有值。值得注意的是，对于示例函数 \( r(x) \)，\( L_{1} \) 范数构成了上限，而 \( L_{\infty} \) 范数构成了下限。![上述示例中不同范数函数的图表](pics/NormTypes_OneArray_1-2-INF.png) 当指定了掩码参数且不为空时，范数仅在掩码指定的区域内计算。如果未指定 normType，则使用 #NORM_L2。多通道输入数组被视为单通道数组，即所有通道的结果被合并。汉明范数（Hamming norms）只能使用 CV_8U 深度的数组进行计算。
        参数
        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} \) 范数计算如下 \(align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \) 对于 \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\)，计算结果为 \(align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \) 下图显示了三个范数函数 \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) 和 \(\| r(x) \|_{L_\infty}\) 的所有值。值得注意的是，对于示例函数 \( r(x) \)，\( L_{1} \) 范数构成了上限，而 \( L_{\infty} \) 范数构成了下限。![上述示例中不同范数函数的图表](pics/NormTypes_OneArray_1-2-INF.png) 当指定了掩码参数且不为空时，范数仅在掩码指定的区域内计算。如果未指定 normType，则使用 #NORM_L2。多通道输入数组被视为单通道数组，即所有通道的结果被合并。汉明范数（Hamming norms）只能使用 CV_8U 深度的数组进行计算。
        参数
        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 的计算方式如下：\( \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \) 其中 R 是深度的最大整数值（例如在 CV_8U 数据的情况下为 255），MSE 是两个数组之间的均方误差。
        参数
        src1 - 第一个输入数组。
        src2 - 与 src1 大小相同的第二个输入数组。
        R - 最大像素值（默认为 255）
        返回
        自动生成

      • PSNR

        public static double PSNR​(Mat src1,
                          Mat src2)
        计算峰值信噪比（PSNR）图像质量指标。该函数计算两个输入数组 src1 和 src2 之间的峰值信噪比（PSNR）图像质量指标，单位为分贝（dB）。数组必须具有相同的类型。PSNR 的计算方式如下：\( \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \) 其中 R 是深度的最大整数值（例如在 CV_8U 数据的情况下为 255），MSE 是两个数组之间的均方误差。
        参数
        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 待办事项：编写文档
        参数
        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 待办事项：编写文档
        参数
        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 待办事项：编写文档
        参数
        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 待办事项：编写文档
        参数
        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 待办事项：编写文档
        参数
        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 待办事项：编写文档
        参数
        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。在稀疏矩阵的情况下，仅分析和转换非零值。因此，稀疏矩阵不允许范围转换，因为这可能会偏移零级。一些正样本数据的可能用法示例： vector<double> positiveData = { 2.0, 8.0, 10.0 }; vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; // 归一化为概率（总计数） // sum(numbers) = 20.0 // 2.0 变为 0.1 (2.0/20.0) // 8.0 变为 0.4 (8.0/20.0) // 10.0 变为 0.5 (10.0/20.0) normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); // 归一化为单位向量: ||positiveData|| = 1.0 // 2.0 变为 0.15 // 8.0 变为 0.62 // 10.0 变为 0.77 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); // 归一化为最大元素 // 2.0 变为 0.2 (2.0/10.0) // 8.0 变为 0.8 (8.0/10.0) // 10.0 变为 1.0 (10.0/10.0) normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); // 归一化到范围 [0.0;1.0] // 2.0 变为 0.0 (移动到左边界) // 8.0 变为 0.75 (6.0/8.0) // 10.0 变为 1.0 (移动到右边界) normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 注意： 由于舍入问题，最大最小归一化可能会导致产生超出提供边界的值。如果需要严格符合范围，可以使用以下解决方法：
        • 使用双精度浮点数（dtype = CV_64F）
        • 手动裁剪数值（cv::max(res, left_bound, res), cv::min(res, right_bound, res) 或 np.clip）
        参数
        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。在稀疏矩阵的情况下，仅分析和转换非零值。因此，稀疏矩阵不允许范围转换，因为这可能会偏移零级。一些正样本数据的可能用法示例： vector<double> positiveData = { 2.0, 8.0, 10.0 }; vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; // 归一化为概率（总计数） // sum(numbers) = 20.0 // 2.0 变为 0.1 (2.0/20.0) // 8.0 变为 0.4 (8.0/20.0) // 10.0 变为 0.5 (10.0/20.0) normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); // 归一化为单位向量: ||positiveData|| = 1.0 // 2.0 变为 0.15 // 8.0 变为 0.62 // 10.0 变为 0.77 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); // 归一化为最大元素 // 2.0 变为 0.2 (2.0/10.0) // 8.0 变为 0.8 (8.0/10.0) // 10.0 变为 1.0 (10.0/10.0) normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); // 归一化到范围 [0.0;1.0] // 2.0 变为 0.0 (移动到左边界) // 8.0 变为 0.75 (6.0/8.0) // 10.0 变为 1.0 (移动到右边界) normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 注意： 由于舍入问题，最大最小归一化可能会导致产生超出提供边界的值。如果需要严格符合范围，可以使用以下解决方法：
        • 使用双精度浮点数（dtype = CV_64F）
        • 手动裁剪数值（cv::max(res, left_bound, res), cv::min(res, right_bound, res) 或 np.clip）
        参数
        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。在稀疏矩阵的情况下，仅分析和转换非零值。因此，稀疏矩阵不允许范围转换，因为这可能会偏移零级。一些正样本数据的可能用法示例： vector<double> positiveData = { 2.0, 8.0, 10.0 }; vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; // 归一化为概率（总计数） // sum(numbers) = 20.0 // 2.0 变为 0.1 (2.0/20.0) // 8.0 变为 0.4 (8.0/20.0) // 10.0 变为 0.5 (10.0/20.0) normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); // 归一化为单位向量: ||positiveData|| = 1.0 // 2.0 变为 0.15 // 8.0 变为 0.62 // 10.0 变为 0.77 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); // 归一化为最大元素 // 2.0 变为 0.2 (2.0/10.0) // 8.0 变为 0.8 (8.0/10.0) // 10.0 变为 1.0 (10.0/10.0) normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); // 归一化到范围 [0.0;1.0] // 2.0 变为 0.0 (移动到左边界) // 8.0 变为 0.75 (6.0/8.0) // 10.0 变为 1.0 (移动到右边界) normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 注意： 由于舍入问题，最大最小归一化可能会导致产生超出提供边界的值。如果需要严格符合范围，可以使用以下解决方法：
        • 使用双精度浮点数（dtype = CV_64F）
        • 手动裁剪数值（cv::max(res, left_bound, res), cv::min(res, right_bound, res) 或 np.clip）
        参数
        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。在稀疏矩阵的情况下，仅分析和转换非零值。因此，稀疏矩阵不允许范围转换，因为这可能会偏移零级。一些正样本数据的可能用法示例： vector<double> positiveData = { 2.0, 8.0, 10.0 }; vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; // 归一化为概率（总计数） // sum(numbers) = 20.0 // 2.0 变为 0.1 (2.0/20.0) // 8.0 变为 0.4 (8.0/20.0) // 10.0 变为 0.5 (10.0/20.0) normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); // 归一化为单位向量: ||positiveData|| = 1.0 // 2.0 变为 0.15 // 8.0 变为 0.62 // 10.0 变为 0.77 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); // 归一化为最大元素 // 2.0 变为 0.2 (2.0/10.0) // 8.0 变为 0.8 (8.0/10.0) // 10.0 变为 1.0 (10.0/10.0) normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); // 归一化到范围 [0.0;1.0] // 2.0 变为 0.0 (移动到左边界) // 8.0 变为 0.75 (6.0/8.0) // 10.0 变为 1.0 (移动到右边界) normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 注意： 由于舍入问题，最大最小归一化可能会导致产生超出提供边界的值。如果需要严格符合范围，可以使用以下解决方法：
        • 使用双精度浮点数（dtype = CV_64F）
        • 手动裁剪数值（cv::max(res, left_bound, res), cv::min(res, right_bound, res) 或 np.clip）
        参数
        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。在稀疏矩阵的情况下，仅分析和转换非零值。因此，稀疏矩阵不允许范围转换，因为这可能会偏移零级。一些正样本数据的可能用法示例： vector<double> positiveData = { 2.0, 8.0, 10.0 }; vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; // 归一化为概率（总计数） // sum(numbers) = 20.0 // 2.0 变为 0.1 (2.0/20.0) // 8.0 变为 0.4 (8.0/20.0) // 10.0 变为 0.5 (10.0/20.0) normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); // 归一化为单位向量: ||positiveData|| = 1.0 // 2.0 变为 0.15 // 8.0 变为 0.62 // 10.0 变为 0.77 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); // 归一化为最大元素 // 2.0 变为 0.2 (2.0/10.0) // 8.0 变为 0.8 (8.0/10.0) // 10.0 变为 1.0 (10.0/10.0) normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); // 归一化到范围 [0.0;1.0] // 2.0 变为 0.0 (移动到左边界) // 8.0 变为 0.75 (6.0/8.0) // 10.0 变为 1.0 (移动到右边界) normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 注意： 由于舍入问题，最大最小归一化可能会导致产生超出提供边界的值。如果需要严格符合范围，可以使用以下解决方法：
        • 使用双精度浮点数（dtype = CV_64F）
        • 手动裁剪数值（cv::max(res, left_bound, res), cv::min(res, right_bound, res) 或 np.clip）
        参数
        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。在稀疏矩阵的情况下，仅分析和转换非零值。因此，稀疏矩阵不允许范围转换，因为这可能会偏移零级。一些正样本数据的可能用法示例： vector<double> positiveData = { 2.0, 8.0, 10.0 }; vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; // 归一化为概率（总计数） // sum(numbers) = 20.0 // 2.0 变为 0.1 (2.0/20.0) // 8.0 变为 0.4 (8.0/20.0) // 10.0 变为 0.5 (10.0/20.0) normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); // 归一化为单位向量: ||positiveData|| = 1.0 // 2.0 变为 0.15 // 8.0 变为 0.62 // 10.0 变为 0.77 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); // 归一化为最大元素 // 2.0 变为 0.2 (2.0/10.0) // 8.0 变为 0.8 (8.0/10.0) // 10.0 变为 1.0 (10.0/10.0) normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); // 归一化到范围 [0.0;1.0] // 2.0 变为 0.0 (移动到左边界) // 8.0 变为 0.75 (6.0/8.0) // 10.0 变为 1.0 (移动到右边界) normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 注意： 由于舍入问题，最大最小归一化可能会导致产生超出提供边界的值。如果需要严格符合范围，可以使用以下解决方法：
        • 使用双精度浮点数（dtype = CV_64F）
        • 手动裁剪数值（cv::max(res, left_bound, res), cv::min(res, right_bound, res) 或 np.clip）
        参数
        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* OS 上视频处理中的典型操作。水平翻转图像，随后进行水平位移和绝对差值计算，以检查垂直轴对称性（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)。顺时针旋转 270 度 (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 }\) 该函数的第二个变体更方便与 参考：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）。如果是多通道数组，每个通道将独立处理。在第 2 和第 3 种情况下，标量首先转换为数组类型。
        参数
        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）。如果是多通道数组，每个通道将独立处理。在第 2 和第 3 种情况下，标量首先转换为数组类型。
        参数
        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 时，不应用饱和运算（Saturation）。在溢出的情况下，您甚至可能会得到负值。注意： (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 - 包含型的上边界数组 or 标量。
        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 - 类型为 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}}{如果 \(\texttt{power}\) 是整数}{|\texttt{src}(I)|^{power}}{否则}\)。因此，对于非整数幂指数，使用输入数组元素的绝对值。然而，可以通过一些额外的操作来获得负值的真实值。在下面的示例中，计算数组 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。目前，该函数在输出时将非规范化值（denormalized values）转换为零。不处理特殊值 (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 函数计算由幅度（magnitude）和角度（angle）的相应元素表示的每个二维向量的笛卡尔坐标：\(\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 函数计算由幅度（magnitude）和角度（angle）的相应元素表示的每个二维向量的笛卡尔坐标：\(\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 时，相应的角度 (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 时，相应的角度 (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 - 输入数组。超出范围还是抛出异常。
        返回
        自动生成

      • patchNaNs

        public static void patchNaNs​(Mat a,
                             double val)
        将矩阵中的 NaN（非数字值）替换为指定值。该函数就地修改输入矩阵。输入矩阵必须是 CV_32F 或 CV_64F 类型；不支持其他类型。
        参数
        a - 输入/输出矩阵（CV_32F 或 CV_64F 类型）。
        val - 用于替换 NaN 的值（默认为 0）。

      • patchNaNs

        public static void patchNaNs​(Mat a)
        将矩阵中的 NaN（非数字值）替换为指定值。该函数就地修改输入矩阵。输入矩阵必须是 CV_32F 或 CV_64F 类型；不支持其他类型。
        参数
        a - 输入/输出矩阵（CV_32F 或 CV_64F 类型）。

      • 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 为零时，它可以作为通用矩阵乘积 A*B（当 B=A' 时）的更快替代方案。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。请参阅下面的说明。
        delta - 乘法前从 src 中减去的可选增量矩阵。当矩阵为空（delta=noArray()）时，假设为零，即不减去任何内容。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（见 repeat）以覆盖整个 src 然后减去。当 delta 矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。请参阅下面的 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 为零时，它可以作为通用矩阵乘积 A*B（当 B=A' 时）的更快替代方案。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。请参阅下面的说明。
        delta - 乘法前从 src 中减去的可选增量矩阵。当矩阵为空（delta=noArray()）时，假设为零，即不减去任何内容。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（见 repeat）以覆盖整个 src 然后减去。当 delta 矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。请参阅下面的 dtype 参数说明。
        scale - 矩阵乘积的可选缩放因子。否则，它的类型将是 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 为零时，它可以作为通用矩阵乘积 A*B（当 B=A' 时）的更快替代方案。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。请参阅下面的说明。
        delta - 乘法前从 src 中减去的可选增量矩阵。当矩阵为空（delta=noArray()）时，假设为零，即不减去任何内容。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（见 repeat）以覆盖整个 src 然后减去。当 delta 矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。请参阅下面的 dtype 参数说明。否则，它的类型将是 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 为零时，它可以作为通用矩阵乘积 A*B（当 B=A' 时）的更快替代方案。
        参数
        src - 输入单通道矩阵。注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。请参阅下面的说明。否则，它的类型将是 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 - 输入数组，其通道数（1 到 4）必须与 m.cols 或 m.cols-1 相同。
        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) \rightarrow (x'/w, y'/w, z'/w)\)，其中 \((x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\) 且 \(w = \fork{w'}{如果 \(w' \ne 0\)}{\infty}{否则}\)。这里显示的是三维向量变换。在二维向量变换的情况下，省略 z 分量。注意： 该函数变换一组稀疏的二维或三维向量。如果您想使用透视变换来变换图像，请使用 warpPerspective。如果您遇到逆问题，即想从几对对应点中计算出最可能的透视变换，可以使用 getPerspectiveTransform 或 findHomography。
        参数
        src - 输入双通道或三通道浮点数组；每个元素都是要变换的 2D/3D 向量。
        dst - 与 src 大小和类型相同的输出数组。
        m - 3x3 或 4x4 浮点变换矩阵。 参阅：transform, warpPerspective, getPerspectiveTransform, findHomography

      • completeSymm

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

      • completeSymm

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

      • setIdentity

        public static void setIdentity​(Mat mtx,
                               Scalar s)
        初始化缩放单位矩阵。cv::setIdentity 函数初始化一个缩放单位矩阵：\(\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{否则}\)。该函数也可以使用矩阵初始化器和矩阵表达式来模拟： 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 函数初始化一个缩放单位矩阵：\(\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{否则}\)。该函数也可以使用矩阵初始化器和矩阵表达式来模拟： 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 对角线元素的总和。\(\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{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 实现）：\(\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\)。如果使用 #DECOMP_LU 或 #DECOMP_CHOLESKY 方法，如果 src1（或 \(\texttt{src1}^T\texttt{src1}\)）是非奇异的，函数返回 1。否则返回 0。在后一种情况下，dst 是无效的。其他方法在左侧部分为奇异的情况下寻找伪解。注意： 如果您想寻找欠定奇异系统 \(\texttt{src1}\cdot\texttt{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 实现）：\(\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\)。如果使用 #DECOMP_LU 或 #DECOMP_CHOLESKY 方法，如果 src1（或 \(\texttt{src1}^T\texttt{src1}\)）是非奇异的，函数返回 1。否则返回 0。在后一种情况下，dst 是无效的。其他方法在左侧部分为奇异的情况下寻找伪解。注意： 如果您想寻找欠定奇异系统 \(\texttt{src1}\cdot\texttt{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 - 具有 0、1、2 或 3 个元素的实根输出数组。
        返回
        实根的数量。它可以是 -1（所有实数）、0、1、2 或 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() 并增加 eigenvalues 输出参数
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        eigenvalues - 自动生成
        maxComponents - 自动生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues)
        封装 PCA::operator() 并增加 eigenvalues 输出参数
        参数
        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() 并增加 eigenvalues 输出参数
        参数
        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)
        计算两个向量之间的马哈拉诺比斯距离（Mahalanobis distance）。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 - 第一个一维输入向量。
        v2 - 第二个一维输入向量。
        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（Intel* 图像处理库）。以下是二维 *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）的数组才能被高效处理。这种高效的 DFT 大小可以使用 getOptimalDFTSize 方法计算。下面的示例说明了如何计算两个二维实数数组的基于 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 分割成多个分块（tiles）。对于每个分块，估计需要 A 和 B 的哪些部分来计算该分块中的卷积。如果 C 中的分块太小，由于重复工作，速度会大幅下降。在极端情况下，当 C 中的每个分块都是单个像素时，该算法等同于朴素卷积算法。如果分块太大，临时数组 tempA 和 tempB 会变得过大，并且由于缓存局部性变差也会导致速度下降。因此，在中间某个位置存在一个最佳的分块大小。
        • 如果 C 中的不同分块可以并行计算，从而实现分部分完成卷积，那么循环可以进行多线程处理。
        上述所有改进已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，您可以获得甚至优于上述理论上最佳实现的性能。不过，这两个函数实际上计算的是互相关（cross-correlation）而非卷积，因此您需要使用 flip 将第二个卷积操作数 B 进行垂直和水平“翻转”。注意：
        • 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 中找到
        • (Python) 使用 dft 功能执行维纳去卷积（Wiener deconvolution）的示例可以在 opencv_source/samples/python/deconvolution.py 中找到
        • (Python) 重新排列傅里叶图像象限的示例可以在 opencv_source/samples/python/dft.py 中找到
        参数
        src - 输入数组，可以是实数或复数。
        dst - 输出数组，其大小和类型取决于标志（flags）。
        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（Intel* 图像处理库）。以下是二维 *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）的数组才能被高效处理。这种高效的 DFT 大小可以使用 getOptimalDFTSize 方法计算。下面的示例说明了如何计算两个二维实数数组的基于 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 分割成多个分块（tiles）。对于每个分块，估计需要 A 和 B 的哪些部分来计算该分块中的卷积。如果 C 中的分块太小，由于重复工作，速度会大幅下降。在极端情况下，当 C 中的每个分块都是单个像素时，该算法等同于朴素卷积算法。如果分块太大，临时数组 tempA 和 tempB 会变得过大，并且由于缓存局部性变差也会导致速度下降。因此，在中间某个位置存在一个最佳的分块大小。
        • 如果 C 中的不同分块可以并行计算，从而实现分部分完成卷积，那么循环可以进行多线程处理。
        上述所有改进已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，您可以获得甚至优于上述理论上最佳实现的性能。不过，这两个函数实际上计算的是互相关（cross-correlation）而非卷积，因此您需要使用 flip 将第二个卷积操作数 B 进行垂直和水平“翻转”。注意：
        • 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 中找到
        • (Python) 使用 dft 功能执行维纳去卷积（Wiener deconvolution）的示例可以在 opencv_source/samples/python/deconvolution.py 中找到
        • (Python) 重新排列傅里叶图像象限的示例可以在 opencv_source/samples/python/dft.py 中找到
        参数
        src - 输入数组，可以是实数或复数。
        dst - 输出数组，其大小和类型取决于标志（flags）。
        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（Intel* 图像处理库）。以下是二维 *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）的数组才能被高效处理。这种高效的 DFT 大小可以使用 getOptimalDFTSize 方法计算。下面的示例说明了如何计算两个二维实数数组的基于 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 分割成多个分块（tiles）。对于每个分块，估计需要 A 和 B 的哪些部分来计算该分块中的卷积。如果 C 中的分块太小，由于重复工作，速度会大幅下降。在极端情况下，当 C 中的每个分块都是单个像素时，该算法等同于朴素卷积算法。如果分块太大，临时数组 tempA 和 tempB 会变得过大，并且由于缓存局部性变差也会导致速度下降。因此，在中间某个位置存在一个最佳的分块大小。
        • 如果 C 中的不同分块可以并行计算，从而实现分部分完成卷积，那么循环可以进行多线程处理。
        上述所有改进已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，您可以获得甚至优于上述理论上最佳实现的性能。不过，这两个函数实际上计算的是互相关（cross-correlation）而非卷积，因此您需要使用 flip 将第二个卷积操作数 B 进行垂直和水平“翻转”。注意：
        • 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 中找到
        • (Python) 使用 dft 功能执行维纳去卷积（Wiener deconvolution）的示例可以在 opencv_source/samples/python/deconvolution.py 中找到
        • (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 或 idft 之一传递 #DFT_SCALE，以使这些变换互为逆变换。参阅：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 或 idft 之一传递 #DFT_SCALE，以使这些变换互为逆变换。参阅：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 或 idft 之一传递 #DFT_SCALE，以使这些变换互为逆变换。参阅：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 )\) 且当 *j = 0* 时 \(\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）和输入数组的大小来选择操作模式。
        • 如果 (flags & #DCT_INVERSE) == 0，则函数执行正向一维或二维变换。否则，执行逆一维或二维变换。
        • 如果 (flags & #DCT_ROWS) != 0，则函数对每一行执行一维变换。
        • 如果数组是单列或单行，则函数执行一维变换。
        • 如果以上皆不满足，则函数执行二维变换。
        注意：目前 dct 支持偶数大小的数组（2, 4, 6 ...）。对于数据分析和逼近，您可以在必要时对数组进行填充。此外，函数性能很大程度上（且非单调地）取决于数组大小（参见 getOptimalDFTSize）。在当前实现中，大小为 N 的向量的 DCT 是通过大小为 N/2 的向量的 DFT 计算的。因此，大于等于 N 的最佳 DCT 大小 N1 可以计算为： 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 )\) 且当 *j = 0* 时 \(\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）和输入数组的大小来选择操作模式。
        • 如果 (flags & #DCT_INVERSE) == 0，则函数执行正向一维或二维变换。否则，执行逆一维或二维变换。
        • 如果 (flags & #DCT_ROWS) != 0，则函数对每一行执行一维变换。
        • 如果数组是单列或单行，则函数执行一维变换。
        • 如果以上皆不满足，则函数执行二维变换。
        注意：目前 dct 支持偶数大小的数组（2, 4, 6 ...）。对于数据分析和逼近，您可以在必要时对数组进行填充。此外，函数性能很大程度上（且非单调地）取决于数组大小（参见 getOptimalDFTSize）。在当前实现中，大小为 N 的向量的 DCT 是通过大小为 N/2 的向量的 DFT 计算的。因此，大于等于 N 的最佳 DCT 大小 N1 可以计算为： 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 配合使用，快速计算两个数组的卷积（传递 conjB=false）或相关（传递 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 配合使用，快速计算两个数组的卷积（传递 conjB=false）或相关（传递 conjB=true）。当数组为复数时，它们直接（按元素）相乘，并可选择对第二个数组的元素进行共轭。当数组为实数时，假设它们是 CCS 压缩的（详见 dft）。
        参数
        a - 第一个输入数组。
        b - 第二个输入数组，与 src1 具有相同的大小和类型。
        c - 输出数组，与 src1 具有相同的大小和类型。
        flags - 操作标志；目前唯一支持的标志是 cv::DFT_ROWS，它表示 src1 和 src2 的每一行都是独立的一维傅里叶光谱。如果您不想使用此标志，只需添加 0 作为值，或不使用（false）。

      • 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 可以被高效处理。在当前实现中，对于某些整数 p, q, r，满足 N = 2 ^p^ \* 3 ^q^ \* 5 ^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 通过随机选择元素对并交换它们来打乱指定的一维数组。此类交换操作的数量将为 dst.rows\*dst.cols\*iterFactor。
        参数
        dst - 输入/输出数值型一维数组。
        iterFactor - 决定随机交换操作数量的比例因子（详见下文）。参阅：RNG, sort

      • randShuffle

        public static void randShuffle​(Mat dst)
        随机打乱数组元素。函数 cv::randShuffle 通过随机选择元素对并交换它们来打乱指定的一维数组。此类交换操作的数量将为 dst.rows\*dst.cols\*iterFactor。
        参数
        dst - 输入/输出数值型一维数组。（详见下文）。参阅：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\) 包含了存储在 samples 矩阵第 \(i\) 行的样本的从 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\) 包含了存储在 samples 矩阵第 \(i\) 行的样本的从 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= - 如果之前调用 setNumThreads 且 threads > 0，则为 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()
        返回滴答数（ticks）。该函数返回特定事件（例如机器开机）后的滴答数。它可用于初始化 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。当用户调用 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 功能列表的字符串，带有以下标记：
        • 无标记 - 基础功能
        • 前缀 * - 在调度器（dispatcher）中启用的功能
        • 后缀 ? - 已启用但在硬件中不可用的功能
        示例：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 - 指定“文件未找到”的处理方式。如果为 true，函数打印信息消息并抛出 cv::Exception。如果为 false，函数返回空结果
        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 - 指定“文件未找到”的处理方式。如果为 true，函数打印信息消息并抛出 cv::Exception。如果为 false，函数返回空结果
        返回
        返回路径（绝对路径或相对于当前目录的路径），如果未找到文件则返回空字符串

      • 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 - 数据文件的相对路径。如果为 true，函数打印信息消息并抛出 cv::Exception。如果为 false，函数返回空结果
        返回
        返回路径（绝对路径或相对于当前目录的路径），如果未找到文件则返回空字符串

      • 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)