包 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)
      Calculates the magnitude and angle of 2D vectors.
      static void cartToPolar​(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)
      Calculates the magnitude and angle of 2D vectors.
      static boolean checkHardwareSupport​(int feature)
      如果宿主硬件支持指定功能，则返回 true。
      static boolean checkRange​(Mat a)
      Checks every element of an input array for invalid values.
      static boolean checkRange​(Mat a, boolean quiet)
      Checks every element of an input array for invalid values.
      static boolean checkRange​(Mat a, boolean quiet, double minVal)
      Checks every element of an input array for invalid values.
      static boolean checkRange​(Mat a, boolean quiet, double minVal, double maxVal)
      Checks every element of an input array for invalid values.
      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)
      Forms a border around an image.
      static void copyMakeBorder​(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)
      Forms a border around an image.
      static void copyTo​(Mat src, Mat dst, Mat mask)
      这是一个重载成员函数，为方便起见提供（Python）。将矩阵复制到另一个矩阵。
      static int countNonZero​(Mat src)
      Counts non-zero array elements.
      静态浮点型 cubeRoot​(float val)
      Computes the cube root of an argument.
      static void dct​(Mat src, Mat dst)
      对一维或二维数组执行正向或逆向离散余弦变换。
      static void dct​(Mat src, Mat dst, int flags)
      对一维或二维数组执行正向或逆向离散余弦变换。
      静态双精度浮点型 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 的索引）
      静态浮点型 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 (x,y) 返回。例如： cv::Mat binaryImage; // 输入，二值图像 cv::Mat locations; // 输出，非零像素位置 cv::findNonZero(binaryImage, locations); // 访问像素坐标 Point pnt = locations.at(i); 或者 cv::Mat binaryImage; // 输入，二值图像 vector locations; // 输出，非零像素位置 cv::findNonZero(binaryImage, locations); // 访问像素坐标 Point pnt = locations[i]; 该函数不适用于多通道数组。
      static void flip​(Mat src, Mat dst, int flipCode)
      沿垂直、水平或两个轴翻转 2D 数组。
      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 功能列表。
      静态长整型 getCPUTickCount()
      返回 CPU 时钟周期数。
      static int getDefaultAlgorithmHint()  
      static java.lang.String getHardwareFeatureName​(int feature)
      通过 ID 返回功能名称。如果功能未定义，则返回空字符串。
      static java.lang.String 获取Ipp版本()  
      static int getNumberOfCPUs()
      返回进程可用的逻辑 CPU 数量。
      static int getNumThreads()
      返回 OpenCV 用于并行区域的线程数。
      static int getOptimalDFTSize​(int vecsize)
      返回给定向量大小的最佳 DFT 大小。
      static int getThreadNum()
      已弃用。
      当前实现与此文档不符。
      静态长整型 getTickCount()
      返回时钟周期数。
      静态双精度浮点型 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 的索引）
      静态双精度浮点型 invert​(Mat src, Mat dst)
      查找矩阵的逆或伪逆。
      静态双精度浮点型 invert​(Mat src, Mat dst, int flags)
      查找矩阵的逆或伪逆。
      静态双精度浮点型 kmeans​(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)
      查找簇中心并将输入样本分组到这些簇周围。
      静态双精度浮点型 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)
      计算二维向量的幅度。
      静态双精度浮点型 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)  
      静态 Scalar mean​(Mat src)
      计算数组元素的平均值（均值）。
      静态 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)  
      静态 Core.MinMaxLocResult minMaxLoc​(Mat src)  
      静态 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)
      计算矩阵及其转置的乘积。
      静态双精度浮点型 norm​(Mat src1)
      计算数组的绝对范数。
      静态双精度浮点型 norm​(Mat src1, int normType)
      计算数组的绝对范数。
      静态双精度浮点型 norm​(Mat src1, int normType, Mat mask)
      计算数组的绝对范数。
      静态双精度浮点型 norm​(Mat src1, Mat src2)
      计算绝对差范数或相对差范数。
      静态双精度浮点型 norm​(Mat src1, Mat src2, int normType)
      计算绝对差范数或相对差范数。
      静态双精度浮点型 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() 并添加特征值输出参数
      static void PCACompute2​(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)
      封装 PCA::operator() 并添加特征值输出参数
      static void PCACompute2​(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)
      封装 PCA::operator() 并添加特征值输出参数
      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)
      将每个数组元素提升到指定幂。
      静态双精度浮点型 PSNR​(Mat src1, Mat src2)
      计算峰值信噪比（PSNR）图像质量度量。
      静态双精度浮点型 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 度的倍数。
      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)
      查找三次方程的实根。
      静态双精度浮点型 solvePoly​(Mat coeffs, Mat roots)
      查找多项式方程的实根或复根。
      静态双精度浮点型 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)  
      静态 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
      静态 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 使用IPP()
      hal::Cholesky的代理
      static boolean 使用IPP_非精确()  
      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

    • 构造函数详细信息

      • Core

        public Core()

    • 方法详细信息

      • cubeRoot

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

      • fastAtan2

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

      • 使用IPP

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

      • setUseIPP

        public static void setUseIPP​(boolean flag)

      • 获取Ipp版本

        public static java.lang.String getIppVersion()

      • 使用IPP_非精确

        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 时，不应用饱和。在溢出情况下，您甚至可能得到不正确的符号结果。注意: (Python) 请注意 src1/src2 为单个数字和它们为元组/数组时的行为差异。add(src,X) 意味着 add(src,(X,X,X,X))。add(src,(X,)) 意味着 add(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，与输入数组(s) 具有相同的大小和通道数；深度由 dtype 或 src1/src2 定义。
        mask - 可选操作掩码 - 8 位单通道数组，指定要更改的输出数组元素。
        dtype - 可选的输出数组深度（参见下文讨论）。参见：subtract, addWeighted, scaleAdd, Mat::convertTo

      • add

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

      • add

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

      • subtract

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

      • subtract

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

      • subtract

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

      • multiply

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

      • multiply

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

      • multiply

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

      • divide

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

      • divide

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

      • divide

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

      • divide

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

      • divide

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

      • scaleAdd

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

      • addWeighted

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

      • addWeighted

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

      • convertScaleAbs

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

      • convertScaleAbs

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

      • convertScaleAbs

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

      • convertFp16

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

      • LUT

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

      • sumElems

        public static Scalar sumElems​(Mat src)
        计算数组元素的和。函数cv::sum计算并返回数组元素的和，每个通道独立计算。
        参数
        src - 输入数组，必须有1到4个通道。参见：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; // input, binary image cv::Mat locations; // output, locations of non-zero pixels cv::findNonZero(binaryImage, locations); // access pixel coordinates Point pnt = locations.at<Point>(i); 或 cv::Mat binaryImage; // input, binary image vector<Point> locations; // output, locations of non-zero pixels cv::findNonZero(binaryImage, locations); // access pixel coordinates 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}\)的所有值。值得注意的是，\( L_{1} \)范数构成了示例函数\( r(x) \)的上限，而\( L_{\infty} \)范数构成了下限。Graphs for the different norm functions from the above example 当指定mask参数且不为空时，范数仅在mask指定的区域上计算。如果未指定normType，则使用#NORM_L2。多通道输入数组被视为单通道数组，即所有通道的结果合并。汉明范数只能用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}\)的所有值。值得注意的是，\( L_{1} \)范数构成了示例函数\( r(x) \)的上限，而\( L_{\infty} \)范数构成了下限。Graphs for the different norm functions from the above example 当指定mask参数且不为空时，范数仅在mask指定的区域上计算。如果未指定normType，则使用#NORM_L2。多通道输入数组被视为单通道数组，即所有通道的结果合并。汉明范数只能用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}\)的所有值。值得注意的是，\( L_{1} \)范数构成了示例函数\( r(x) \)的上限，而\( L_{\infty} \)范数构成了下限。Graphs for the different norm functions from the above example 当指定mask参数且不为空时，范数仅在mask指定的区域上计算。如果未指定normType，则使用#NORM_L2。多通道输入数组被视为单通道数组，即所有通道的结果合并。汉明范数只能用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; // Norm to probability (total count) // 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); // Norm to unit vector: ||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); // Norm to max element // 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); // Norm to range [0.0;1.0] // 2.0 0.0 (shift to left border) // 8.0 0.75 (6.0/8.0) // 10.0 1.0 (shift to right border) 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; // Norm to probability (total count) // 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); // Norm to unit vector: ||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); // Norm to max element // 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); // Norm to range [0.0;1.0] // 2.0 0.0 (shift to left border) // 8.0 0.75 (6.0/8.0) // 10.0 1.0 (shift to right border) 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; // Norm to probability (total count) // 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); // Norm to unit vector: ||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); // Norm to max element // 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); // Norm to range [0.0;1.0] // 2.0 0.0 (shift to left border) // 8.0 0.75 (6.0/8.0) // 10.0 1.0 (shift to right border) 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; // Norm to probability (total count) // 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); // Norm to unit vector: ||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); // Norm to max element // 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); // Norm to range [0.0;1.0] // 2.0 0.0 (shift to left border) // 8.0 0.75 (6.0/8.0) // 10.0 1.0 (shift to right border) 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; // Norm to probability (total count) // 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); // Norm to unit vector: ||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); // Norm to max element // 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); // Norm to range [0.0;1.0] // 2.0 0.0 (shift to left border) // 8.0 0.75 (6.0/8.0) // 10.0 1.0 (shift to right border) 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; // Norm to probability (total count) // 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); // Norm to unit vector: ||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); // Norm to max element // 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); // Norm to range [0.0;1.0] // 2.0 0.0 (shift to left border) // 8.0 0.75 (6.0/8.0) // 10.0 1.0 (shift to right border) 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\*操作系统中视频处理的典型操作。图像的水平翻转，随后进行水平移位和绝对差计算，以检查垂直轴对称性（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计算：当src1和src2大小和类型相同时的两个数组之间的绝对差：\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\)；当第二个数组由Scalar构造或与src1通道数相同元素数量时的一个数组与一个标量之间的绝对差：\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\)；当第一个数组由Scalar构造或与src2通道数相同元素数量时的一个标量与一个数组之间的绝对差：\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\)，其中I是数组元素的多维索引。对于多通道数组，每个通道独立处理。注意：当数组深度为CV_32S时，不应用饱和处理。在溢出情况下，您甚至可能得到负值。注意：(Python)请注意src1/src2为单个数字与它们为元组/数组时的行为差异。absdiff(src,X)表示absdiff(src,(X,X,X,X))。absdiff(src,(X,))表示absdiff(src,(X,0,0,0))。
        参数
        src1 - 第一个输入数组或标量。
        src2 - 第二个输入数组或标量。
        dst - 输出数组，与输入数组具有相同的大小和类型。参见：cv::abs(const Mat&)

      • copyTo

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

      • inRange

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

      • compare

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

      • min

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

      • max

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

      • sqrt

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

      • pow

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

      • exp

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

      • log

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

      • polarToCart

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

      • polarToCart

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

      • cartToPolar

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

      • cartToPolar

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

      • phase

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

      • phase

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

      • magnitude

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

      • checkRange

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

      • checkRange

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

      • checkRange

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

      • checkRange

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

      • patchNaNs

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

      • patchNaNs

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

      • gemm

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

      • gemm

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

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta,
                                 double scale,
                                 int dtype)
        计算矩阵及其转置的乘积。函数cv::mulTransposed计算src及其转置的乘积：如果aTa=true，则\(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\)；否则，\(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\)。该函数用于计算协方差矩阵。当delta为零时，它可以用作一般矩阵乘积A\*B当B=A'时的更快替代方法。
        参数
        src - 输入单通道矩阵。请注意，与gemm不同，该函数不仅可以乘以浮点矩阵。
        dst - 输出方阵。
        aTa - 指定乘法顺序的标志。参见下面的描述。
        delta - 可选的增量矩阵，在乘法前从src中减去。当矩阵为空（delta=noArray()）时，假定为零，即不减去任何东西。如果它与src大小相同，则直接减去。否则，它会“重复”（参见repeat）以覆盖整个src，然后减去。当delta矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。参见下面的dtype参数描述。
        scale - 矩阵乘积的可选缩放因子。
        dtype - 输出矩阵的可选类型。当为负值时，输出矩阵将与src类型相同。否则，其类型将为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 - 矩阵乘积的可选缩放因子。输出矩阵将与src类型相同。否则，其类型将为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参数描述。输出矩阵将与src类型相同。否则，其类型将为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 - 指定乘法顺序的标志。参见下面的描述。乘法。当矩阵为空（delta=noArray()）时，假定为零，即不减去任何东西。如果它与src大小相同，则直接减去。否则，它会“重复”（参见repeat）以覆盖整个src，然后减去。当delta矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。参见下面的dtype参数描述。输出矩阵将与src类型相同。否则，其类型将为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的每个元素视为2D或3D向量进行变换，如下所示：\((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'}{if \(w' \ne 0\)}{\infty}{otherwise}\)。这里显示了3D向量变换。如果是2D向量变换，则省略z分量。注意：此函数变换稀疏的2D或3D向量集。如果要使用透视变换来变换图像，请使用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 - 操作标志；如果为真，则将下半部分复制到上半部分。否则，将上半部分复制到下半部分。参见：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}{otherwise}\)。该函数也可以使用矩阵初始化器和矩阵表达式来模拟： Mat A = Mat::eye(4, 3, CV_32F)*5; // A will be set to [[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}{otherwise}\)。该函数也可以使用矩阵初始化器和矩阵表达式来模拟： Mat A = Mat::eye(4, 3, CV_32F)*5; // A will be set to [[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。在后一种情况下，dst无效。对于#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。在后一种情况下，dst无效。对于#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 will probably contain // (because of equal elements in A some permutations are possible): // [[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() 并添加特征值输出参数
        参数
        data - 自动生成
        mean - 自动生成
        eigenvectors - 自动生成
        eigenvalues - 自动生成
        maxComponents - 自动生成

      • PCACompute2

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

      • PCACompute

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

      • PCACompute2

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

      • PCAProject

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

      • PCABackProject

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

      • SVDecomp

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

      • SVDecomp

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

      • SVBackSubst

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

      • Mahalanobis

        public static double Mahalanobis​(Mat v1,
                                 Mat v2,
                                 Mat icovar)
        计算两个向量之间的马氏距离。函数cv::Mahalanobis计算并返回两个向量之间的加权距离：\(d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\)。协方差矩阵可以使用#calcCovarMatrix函数计算，然后使用invert函数求逆（优选使用#DECOMP_SVD方法，因为其最准确）。
        参数
        v1 - 第一个一维输入向量。
        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）乘积的数组才能高效处理。可以使用 getOptimalDFTSize 方法计算出这种高效的 DFT 大小。下面的示例说明了如何计算两个二维实数数组的基于 DFT 的卷积： void convolveDFT(InputArray A, InputArray B, OutputArray C) { // 如果需要，重新分配输出数组 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); Size dftSize; // 计算 DFT 变换的大小 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); // 分配临时缓冲区并将其初始化为 0 Mat tempA(dftSize, A.type(), Scalar::all(0)); Mat tempB(dftSize, B.type(), Scalar::all(0)); // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); A.copyTo(roiA); Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); B.copyTo(roiB); // 现在对填充后的 A 和 B 进行就地变换； // 使用 "nonzeroRows" 提示以加快处理速度 dft(tempA, tempA, 0, A.rows); dft(tempB, tempB, 0, B.rows); // 频谱相乘； // 该函数能够很好地处理紧凑频谱表示 mulSpectrums(tempA, tempB, tempA); // 将乘积从频域反变换回来。 // 即使所有结果行都将是非零的， // 但你只需要其中的前 C.rows 行，因此你 // 传入 nonzeroRows == C.rows dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); // 现在将结果复制回 C。 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); // 所有临时缓冲区将自动释放 } 为了优化此示例，请考虑以下方法：
        • 由于 nonzeroRows != 0 被传递给正向变换调用，并且 A 和 B 分别被复制到 tempA 和 tempB 的左上角，因此不需要清空整个 tempA 和 tempB。只需要清空矩阵最右侧的 tempA.cols - A.cols ( tempB.cols - B.cols) 列。
        • 这种基于 DFT 的卷积不必应用于整个大型数组，尤其是当 B 明显小于 A 或反之亦然时。相反，你可以分部分计算卷积。为此，你需要将输出数组 C 分割成多个块。对于每个块，估计计算该块中卷积所需的 A 和 B 的哪些部分。如果 C 中的块太小，由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个块都是单个像素时，该算法变得等同于朴素卷积算法。如果块太大，临时数组 tempA 和 tempB 会变得太大，并且由于缓存局部性差也会导致速度下降。因此，在中间某个地方存在一个最佳块大小。
        • 如果 C 中不同的块可以并行计算，从而分部分完成卷积，则循环可以进行线程化处理。
        上述所有改进都已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，你可以获得比上述理论上最优实现更好的性能。然而，这两个函数实际上计算的是互相关，而不是卷积，所以你需要使用 flip 将第二个卷积操作数 B 垂直和水平“翻转”。注意：
        • 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 找到。
        • (Python) 使用 dft 功能执行维纳反卷积的示例可以在 opencv_source/samples/python/deconvolution.py 找到。
        • (Python) 重排傅里叶图像象限的示例可以在 opencv_source/samples/python/dft.py 找到。
        参数
        src - 输入数组，可以是实数或复数。
        dst - 输出数组，其大小和类型取决于标志。
        flags - 变换标志，表示 #DftFlags 的组合。
        nonzeroRows - 当该参数不为零时，函数假定输入数组（未设置 #DFT_INVERSE 时）或输出数组（设置 #DFT_INVERSE 时）的仅前 nonzeroRows 行包含非零值，因此函数可以更有效地处理其余行并节省一些时间；此技术对于使用 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）乘积的数组才能高效处理。可以使用 getOptimalDFTSize 方法计算出这种高效的 DFT 大小。下面的示例说明了如何计算两个二维实数数组的基于 DFT 的卷积： void convolveDFT(InputArray A, InputArray B, OutputArray C) { // 如果需要，重新分配输出数组 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); Size dftSize; // 计算 DFT 变换的大小 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); // 分配临时缓冲区并将其初始化为 0 Mat tempA(dftSize, A.type(), Scalar::all(0)); Mat tempB(dftSize, B.type(), Scalar::all(0)); // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); A.copyTo(roiA); Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); B.copyTo(roiB); // 现在对填充后的 A 和 B 进行就地变换； // 使用 "nonzeroRows" 提示以加快处理速度 dft(tempA, tempA, 0, A.rows); dft(tempB, tempB, 0, B.rows); // 频谱相乘； // 该函数能够很好地处理紧凑频谱表示 mulSpectrums(tempA, tempB, tempA); // 将乘积从频域反变换回来。 // 即使所有结果行都将是非零的， // 但你只需要其中的前 C.rows 行，因此你 // 传入 nonzeroRows == C.rows dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); // 现在将结果复制回 C。 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); // 所有临时缓冲区将自动释放 } 为了优化此示例，请考虑以下方法：
        • 由于 nonzeroRows != 0 被传递给正向变换调用，并且 A 和 B 分别被复制到 tempA 和 tempB 的左上角，因此不需要清空整个 tempA 和 tempB。只需要清空矩阵最右侧的 tempA.cols - A.cols ( tempB.cols - B.cols) 列。
        • 这种基于 DFT 的卷积不必应用于整个大型数组，尤其是当 B 明显小于 A 或反之亦然时。相反，你可以分部分计算卷积。为此，你需要将输出数组 C 分割成多个块。对于每个块，估计计算该块中卷积所需的 A 和 B 的哪些部分。如果 C 中的块太小，由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个块都是单个像素时，该算法变得等同于朴素卷积算法。如果块太大，临时数组 tempA 和 tempB 会变得太大，并且由于缓存局部性差也会导致速度下降。因此，在中间某个地方存在一个最佳块大小。
        • 如果 C 中不同的块可以并行计算，从而分部分完成卷积，则循环可以进行线程化处理。
        上述所有改进都已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，你可以获得比上述理论上最优实现更好的性能。然而，这两个函数实际上计算的是互相关，而不是卷积，所以你需要使用 flip 将第二个卷积操作数 B 垂直和水平“翻转”。注意：
        • 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 找到。
        • (Python) 使用 dft 功能执行维纳反卷积的示例可以在 opencv_source/samples/python/deconvolution.py 找到。
        • (Python) 重排傅里叶图像象限的示例可以在 opencv_source/samples/python/dft.py 找到。
        参数
        src - 输入数组，可以是实数或复数。
        dst - 输出数组，其大小和类型取决于标志。
        flags - 变换标志，表示 #DftFlags nonzeroRows 行的组合，这些行是输入数组（未设置 #DFT_INVERSE 时）或输出数组（设置 #DFT_INVERSE 时）的前 nonzeroRows 行，其中包含非零值，因此函数可以更有效地处理其余行并节省一些时间；此技术对于使用 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）乘积的数组才能高效处理。可以使用 getOptimalDFTSize 方法计算出这种高效的 DFT 大小。下面的示例说明了如何计算两个二维实数数组的基于 DFT 的卷积： void convolveDFT(InputArray A, InputArray B, OutputArray C) { // 如果需要，重新分配输出数组 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); Size dftSize; // 计算 DFT 变换的大小 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); // 分配临时缓冲区并将其初始化为 0 Mat tempA(dftSize, A.type(), Scalar::all(0)); Mat tempB(dftSize, B.type(), Scalar::all(0)); // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); A.copyTo(roiA); Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); B.copyTo(roiB); // 现在对填充后的 A 和 B 进行就地变换； // 使用 "nonzeroRows" 提示以加快处理速度 dft(tempA, tempA, 0, A.rows); dft(tempB, tempB, 0, B.rows); // 频谱相乘； // 该函数能够很好地处理紧凑频谱表示 mulSpectrums(tempA, tempB, tempA); // 将乘积从频域反变换回来。 // 即使所有结果行都将是非零的， // 但你只需要其中的前 C.rows 行，因此你 // 传入 nonzeroRows == C.rows dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); // 现在将结果复制回 C。 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); // 所有临时缓冲区将自动释放 } 为了优化此示例，请考虑以下方法：
        • 由于 nonzeroRows != 0 被传递给正向变换调用，并且 A 和 B 分别被复制到 tempA 和 tempB 的左上角，因此不需要清空整个 tempA 和 tempB。只需要清空矩阵最右侧的 tempA.cols - A.cols ( tempB.cols - B.cols) 列。
        • 这种基于 DFT 的卷积不必应用于整个大型数组，尤其是当 B 明显小于 A 或反之亦然时。相反，你可以分部分计算卷积。为此，你需要将输出数组 C 分割成多个块。对于每个块，估计计算该块中卷积所需的 A 和 B 的哪些部分。如果 C 中的块太小，由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个块都是单个像素时，该算法变得等同于朴素卷积算法。如果块太大，临时数组 tempA 和 tempB 会变得太大，并且由于缓存局部性差也会导致速度下降。因此，在中间某个地方存在一个最佳块大小。
        • 如果 C 中不同的块可以并行计算，从而分部分完成卷积，则循环可以进行线程化处理。
        上述所有改进都已在 #matchTemplate 和 #filter2D 中实现。因此，通过使用它们，你可以获得比上述理论上最优实现更好的性能。然而，这两个函数实际上计算的是互相关，而不是卷积，所以你需要使用 flip 将第二个卷积操作数 B 垂直和水平“翻转”。注意：
        • 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 找到。
        • (Python) 使用 dft 功能执行维纳反卷积的示例可以在 opencv_source/samples/python/deconvolution.py 找到。
        • (Python) 重排傅里叶图像象限的示例可以在 opencv_source/samples/python/dft.py 找到。
        参数
        src - 输入数组，可以是实数或复数。
        dst - 输出数组，其大小和类型取决于标志。输入数组（未设置 #DFT_INVERSE 时）或输出数组（设置 #DFT_INVERSE 时）的前 nonzeroRows 行包含非零值，因此函数可以更有效地处理其余行并节省一些时间；此技术对于使用 DFT 计算数组互相关或卷积非常有用。参见：dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

      • idft

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

      • idft

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

      • idft

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

      • dct

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

      • dct

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

      • idct

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

      • idct

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

      • mulSpectrums

        public static void mulSpectrums​(Mat a,
                                Mat b,
                                Mat c,
                                int flags,
                                boolean conjB)
        执行两个傅里叶频谱的逐元素乘法。函数 cv::mulSpectrums 对实数或复数傅里叶变换结果的两个 CCS 紧凑格式或复数矩阵执行逐元素乘法。该函数与 dft 和 idft 一起，可以快速计算两个数组的卷积（传递 conjB=false）或互相关（传递 conjB=true）。当数组为复数时，它们仅进行逐元素相乘，并可选择对第二个数组的元素进行共轭。当数组为实数时，它们被假定为 CCS 紧凑格式（详见 dft）。
        参数
        a - 第一个输入数组。
        b - 第二个输入数组，与 src1 具有相同的大小和类型。
        c - 输出数组，与 src1 具有相同的大小和类型。
        flags - 操作标志；目前唯一支持的标志是 cv::DFT_ROWS，它表示 src1 和 src2 的每一行都是独立的 1D 傅里叶频谱。如果你不想使用此标志，只需将其值设为 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 的每一行都是独立的 1D 傅里叶频谱。如果你不想使用此标志，只需将其值设为 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 可以高效处理。在当前实现中，N = 2 ^p^ \* 3 ^q^ \* 5 ^r^，其中 p、q、r 为某些整数。如果 vecsize 太大（非常接近 INT_MAX），该函数返回一个负数。虽然该函数不能直接用于估计 DCT 变换的最佳向量大小（因为当前的 DCT 实现只支持偶数大小的向量），但它可以通过 getOptimalDFTSize((vecsize+1)/2)\*2 轻松处理。
        参数
        vecsize - 向量大小。参见：dft, dct, idft, idct, mulSpectrums
        返回
        自动生成

      • setRNGSeed

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

      • randu

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

      • randn

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

      • randShuffle

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

      • randShuffle

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

      • kmeans

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

      • kmeans

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

      • setNumThreads

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

      • getNumThreads

        public static int getNumThreads()
        返回 OpenCV 用于并行区域的线程数。如果 OpenCV 构建时没有线程支持，则始终返回 1。返回值的确切含义取决于 OpenCV 库使用的线程框架。
        • TBB - OpenCV 将尝试用于并行区域的线程数。如果用户代码中有与 OpenCV 冲突的 tbb::thread_scheduler_init，则函数返回 TBB 库使用的默认线程数。
        • OpenMP - 可用于组建新团队的线程数的上限。
        • Concurrency - OpenCV 将尝试用于并行区域的线程数。
        • GCD - 不支持；为兼容性返回 GCD 线程池限制 (512)。
        • C= - 如果之前调用 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()
        返回时钟周期数。该函数返回某个事件（例如，机器开启）后的时钟周期数。它可用于初始化 RNG 或通过在函数调用前后读取时钟周期数来测量函数执行时间。参见：getTickFrequency, TickMeter
        返回
        自动生成

      • getTickFrequency

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

      • getCPUTickCount

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

      • checkHardwareSupport

        public static boolean checkHardwareSupport​(int feature)
        如果主机硬件支持指定功能，则返回 true。该函数在主机硬件支持指定功能时返回 true。当用户调用 setUseOptimized(false) 时，对 checkHardwareSupport() 的后续调用将返回 false，直到调用 setUseOptimized(true)。这样用户可以在 OpenCV 中动态地开启和关闭优化代码。
        参数
        feature - 感兴趣的功能，是 cv::CpuFeatures 中的一个。
        返回
        自动生成

      • getHardwareFeatureName

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

      • getCPUFeaturesLine

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

      • getNumberOfCPUs

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

      • getDefaultAlgorithmHint

        public static int getDefaultAlgorithmHint()

      • setUseOptimized

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

      • useOptimized

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

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path,
                                        boolean required,
                                        boolean silentMode)
        尝试查找请求的数据文件。搜索目录： 1. 通过 addSamplesDataSearchPath() 传入的目录 2. OPENCV_SAMPLES_DATA_PATH_HINT 环境变量 3. OPENCV_SAMPLES_DATA_PATH 环境变量 如果参数值非空且未找到任何内容，则停止搜索。 4. 根据以下方式检测构建/安装路径： a. 当前工作目录 (CWD) b. 和/或二进制模块位置 (opencv_core/opencv_world, 不适用于静态链接) 5. 如果检测到构建目录或当前目录在源码树中，则扫描 &lt;source&gt;/{,data,samples/data} 目录。 6. 如果检测到安装目录，则扫描 &lt;install&gt;/share/OpenCV 目录。参见：cv::utils::findDataFile
        参数
        relative_path - 数据文件的相对路径。
        required - 指定“文件未找到”的处理方式。如果为 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)