Core (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.opencv.core.Core

```
public class Core
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Core.MinMaxLocResult

Nested Classes
Modifier and Type	Class and Description
`static class`	`Core.MinMaxLocResult`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`BadAlign`
`static int`	`BadAlphaChannel`
`static int`	`BadCallBack`
`static int`	`BadCOI`
`static int`	`BadDataPtr`
`static int`	`BadDepth`
`static int`	`BadImageSize`
`static int`	`BadModelOrChSeq`
`static int`	`BadNumChannel1U`
`static int`	`BadNumChannels`
`static int`	`BadOffset`
`static int`	`BadOrder`
`static int`	`BadOrigin`
`static int`	`BadROISize`
`static int`	`BadStep`
`static int`	`BadTileSize`
`static int`	`BORDER_CONSTANT`
`static int`	`BORDER_DEFAULT`
`static int`	`BORDER_ISOLATED`
`static int`	`BORDER_REFLECT`
`static int`	`BORDER_REFLECT_101`
`static int`	`BORDER_REFLECT101`
`static int`	`BORDER_REPLICATE`
`static int`	`BORDER_TRANSPARENT`
`static int`	`BORDER_WRAP`
`static int`	`CMP_EQ`
`static int`	`CMP_GE`
`static int`	`CMP_GT`
`static int`	`CMP_LE`
`static int`	`CMP_LT`
`static int`	`CMP_NE`
`static int`	`COVAR_COLS`
`static int`	`COVAR_NORMAL`
`static int`	`COVAR_ROWS`
`static int`	`COVAR_SCALE`
`static int`	`COVAR_SCRAMBLED`
`static int`	`COVAR_USE_AVG`
`static int`	`DCT_INVERSE`
`static int`	`DCT_ROWS`
`static int`	`DECOMP_CHOLESKY`
`static int`	`DECOMP_EIG`
`static int`	`DECOMP_LU`
`static int`	`DECOMP_NORMAL`
`static int`	`DECOMP_QR`
`static int`	`DECOMP_SVD`
`static int`	`DFT_COMPLEX_INPUT`
`static int`	`DFT_COMPLEX_OUTPUT`
`static int`	`DFT_INVERSE`
`static int`	`DFT_REAL_OUTPUT`
`static int`	`DFT_ROWS`
`static int`	`DFT_SCALE`
`static int`	`FILLED`
`static int`	`Formatter_FMT_C`
`static int`	`Formatter_FMT_CSV`
`static int`	`Formatter_FMT_DEFAULT`
`static int`	`Formatter_FMT_MATLAB`
`static int`	`Formatter_FMT_NUMPY`
`static int`	`Formatter_FMT_PYTHON`
`static int`	`GEMM_1_T`
`static int`	`GEMM_2_T`
`static int`	`GEMM_3_T`
`static int`	`GpuApiCallError`
`static int`	`GpuNotSupported`
`static int`	`HeaderIsNull`
`static int`	`KMEANS_PP_CENTERS`
`static int`	`KMEANS_RANDOM_CENTERS`
`static int`	`KMEANS_USE_INITIAL_LABELS`
`static int`	`MaskIsTiled`
`static String`	`NATIVE_LIBRARY_NAME`
`static int`	`NORM_HAMMING`
`static int`	`NORM_HAMMING2`
`static int`	`NORM_INF`
`static int`	`NORM_L1`
`static int`	`NORM_L2`
`static int`	`NORM_L2SQR`
`static int`	`NORM_MINMAX`
`static int`	`NORM_RELATIVE`
`static int`	`NORM_TYPE_MASK`
`static int`	`OpenCLApiCallError`
`static int`	`OpenCLDoubleNotSupported`
`static int`	`OpenCLInitError`
`static int`	`OpenCLNoAMDBlasFft`
`static int`	`OpenGlApiCallError`
`static int`	`OpenGlNotSupported`
`static int`	`Param_ALGORITHM`
`static int`	`Param_BOOLEAN`
`static int`	`Param_FLOAT`
`static int`	`Param_INT`
`static int`	`Param_MAT`
`static int`	`Param_MAT_VECTOR`
`static int`	`Param_REAL`
`static int`	`Param_SCALAR`
`static int`	`Param_STRING`
`static int`	`Param_UCHAR`
`static int`	`Param_UINT64`
`static int`	`Param_UNSIGNED_INT`
`static int`	`PCA_DATA_AS_COL`
`static int`	`PCA_DATA_AS_ROW`
`static int`	`PCA_USE_AVG`
`static int`	`REDUCE_AVG`
`static int`	`REDUCE_MAX`
`static int`	`REDUCE_MIN`
`static int`	`REDUCE_SUM`
`static int`	`RNG_NORMAL`
`static int`	`RNG_UNIFORM`
`static int`	`ROTATE_180`
`static int`	`ROTATE_90_CLOCKWISE`
`static int`	`ROTATE_90_COUNTERCLOCKWISE`
`static int`	`SORT_ASCENDING`
`static int`	`SORT_DESCENDING`
`static int`	`SORT_EVERY_COLUMN`
`static int`	`SORT_EVERY_ROW`
`static int`	`StsAssert`
`static int`	`StsAutoTrace`
`static int`	`StsBackTrace`
`static int`	`StsBadArg`
`static int`	`StsBadFlag`
`static int`	`StsBadFunc`
`static int`	`StsBadMask`
`static int`	`StsBadMemBlock`
`static int`	`StsBadPoint`
`static int`	`StsBadSize`
`static int`	`StsDivByZero`
`static int`	`StsError`
`static int`	`StsFilterOffsetErr`
`static int`	`StsFilterStructContentErr`
`static int`	`StsInplaceNotSupported`
`static int`	`StsInternal`
`static int`	`StsKernelStructContentErr`
`static int`	`StsNoConv`
`static int`	`StsNoMem`
`static int`	`StsNotImplemented`
`static int`	`StsNullPtr`
`static int`	`StsObjectNotFound`
`static int`	`StsOk`
`static int`	`StsOutOfRange`
`static int`	`StsParseError`
`static int`	`StsUnmatchedFormats`
`static int`	`StsUnmatchedSizes`
`static int`	`StsUnsupportedFormat`
`static int`	`StsVecLengthErr`
`static int`	`SVD_FULL_UV`
`static int`	`SVD_MODIFY_A`
`static int`	`SVD_NO_UV`
`static String`	`VERSION`
`static int`	`VERSION_MAJOR`
`static int`	`VERSION_MINOR`
`static int`	`VERSION_REVISION`
`static String`	`VERSION_STATUS`

Constructor Summary

Constructors
Constructor and Description

Core()

Constructors
Constructor and Description
`Core()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static void`	`absdiff(Mat src1, Mat src2, Mat dst)` Calculates the per-element absolute difference between two arrays or between an array and a scalar.
`static void`	`absdiff(Mat src1, Scalar src2, Mat dst)`
`static void`	`add(Mat src1, Mat src2, Mat dst)` Calculates the per-element sum of two arrays or an array and a scalar.
`static void`	`add(Mat src1, Mat src2, Mat dst, Mat mask)` Calculates the per-element sum of two arrays or an array and a scalar.
`static void`	`add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)` Calculates the per-element sum of two arrays or an array and a scalar.
`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(String path)` Override search data path by adding new search location Use this only to override default behavior Passed paths are used in LIFO order.
`static void`	`addSamplesDataSearchSubDirectory(String subdir)` Append samples search data sub directory General usage is to add OpenCV modules name (`<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)` Calculates the weighted sum of two arrays.
`static void`	`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)` Calculates the weighted sum of two arrays.
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)` naive nearest neighbor finder see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType)` naive nearest neighbor finder see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K)` naive nearest neighbor finder see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask)` naive nearest neighbor finder see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update)` naive nearest neighbor finder see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)` naive nearest neighbor finder see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document
`static void`	`bitwise_and(Mat src1, Mat src2, Mat dst)` computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
`static void`	`bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask)` computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
`static void`	`bitwise_not(Mat src, Mat dst)` Inverts every bit of an array.
`static void`	`bitwise_not(Mat src, Mat dst, Mat mask)` Inverts every bit of an array.
`static void`	`bitwise_or(Mat src1, Mat src2, Mat dst)` Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
`static void`	`bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask)` Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
`static void`	`bitwise_xor(Mat src1, Mat src2, Mat dst)` Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
`static void`	`bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask)` Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
`static int`	`borderInterpolate(int p, int len, int borderType)` Computes the source location of an extrapolated pixel.
`static void`	`calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags)` Note: use #COVAR_ROWS or #COVAR_COLS flag
`static void`	`calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype)` Note: use #COVAR_ROWS or #COVAR_COLS flag
`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`	`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)` Performs the per-element comparison of two arrays or an array and scalar value.
`static void`	`compare(Mat src1, Scalar src2, Mat dst, int cmpop)`
`static void`	`completeSymm(Mat m)` Copies the lower or the upper half of a square matrix to its another half.
`static void`	`completeSymm(Mat m, boolean lowerToUpper)` Copies the lower or the upper half of a square matrix to its another half.
`static void`	`convertFp16(Mat src, Mat dst)` Converts an array to half precision floating number.
`static void`	`convertScaleAbs(Mat src, Mat dst)` Scales, calculates absolute values, and converts the result to 8-bit.
`static void`	`convertScaleAbs(Mat src, Mat dst, double alpha)` Scales, calculates absolute values, and converts the result to 8-bit.
`static void`	`convertScaleAbs(Mat src, Mat dst, double alpha, double beta)` Scales, calculates absolute values, and converts the result to 8-bit.
`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)` This is an overloaded member function, provided for convenience (python) Copies the matrix to another one.
`static int`	`countNonZero(Mat src)` Counts non-zero array elements.
`static float`	`cubeRoot(float val)` Computes the cube root of an argument.
`static void`	`dct(Mat src, Mat dst)` Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
`static void`	`dct(Mat src, Mat dst, int flags)` Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
`static double`	`determinant(Mat mtx)` Returns the determinant of a square floating-point matrix.
`static void`	`dft(Mat src, Mat dst)` Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
`static void`	`dft(Mat src, Mat dst, int flags)` Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
`static void`	`dft(Mat src, Mat dst, int flags, int nonzeroRows)` Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
`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)` Performs per-element division of two arrays or a scalar by an array.
`static void`	`divide(Mat src1, Mat src2, Mat dst, double scale)` Performs per-element division of two arrays or a scalar by an array.
`static void`	`divide(Mat src1, Mat src2, Mat dst, double scale, int dtype)` Performs per-element division of two arrays or a scalar by an array.
`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)` Calculates eigenvalues and eigenvectors of a symmetric matrix.
`static boolean`	`eigen(Mat src, Mat eigenvalues, Mat eigenvectors)` Calculates eigenvalues and eigenvectors of a symmetric matrix.
`static void`	`eigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors)` Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
`static void`	`exp(Mat src, Mat dst)` Calculates the exponent of every array element.
`static void`	`extractChannel(Mat src, Mat dst, int coi)` Extracts a single channel from src (coi is 0-based index)
`static float`	`fastAtan2(float y, float x)` Calculates the angle of a 2D vector in degrees.
`static String`	`findFile(String relative_path)` Try to find requested data file Search directories: 1.
`static String`	`findFile(String relative_path, boolean required)` Try to find requested data file Search directories: 1.
`static String`	`findFile(String relative_path, boolean required, boolean silentMode)` Try to find requested data file Search directories: 1.
`static String`	`findFileOrKeep(String relative_path)`
`static String`	`findFileOrKeep(String relative_path, boolean silentMode)`
`static void`	`findNonZero(Mat src, Mat idx)` Returns the list of locations of non-zero pixels Given a binary matrix (likely returned from an operation such as threshold(), compare(), >, ==, etc, return all of the non-zero indices as a cv::Mat or std::vector<cv::Point> (x,y) For example: `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);` or `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];`
`static void`	`flip(Mat src, Mat dst, int flipCode)` Flips a 2D array around vertical, horizontal, or both axes.
`static void`	`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)` Performs generalized matrix multiplication.
`static void`	`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)` Performs generalized matrix multiplication.
`static String`	`getBuildInformation()` Returns full configuration time cmake output.
`static String`	`getCPUFeaturesLine()` Returns list of CPU features enabled during compilation.
`static long`	`getCPUTickCount()` Returns the number of CPU ticks.
`static String`	`getHardwareFeatureName(int feature)` Returns feature name by ID Returns empty string if feature is not defined
`static String`	`getIppVersion()`
`static int`	`getNumberOfCPUs()` Returns the number of logical CPUs available for the process.
`static int`	`getNumThreads()` Returns the number of threads used by OpenCV for parallel regions.
`static int`	`getOptimalDFTSize(int vecsize)` Returns the optimal DFT size for a given vector size.
`static int`	`getThreadNum()` Deprecated. Current implementation doesn't corresponding to this documentation. The exact meaning of the return value depends on the threading framework used by OpenCV library: `TBB` - Unsupported with current 4.1 TBB release. Maybe will be supported in future. `OpenMP` - The thread number, within the current team, of the calling thread. `Concurrency` - An ID for the virtual processor that the current context is executing on (0 for master thread and unique number for others, but not necessary 1,2,3,...). `GCD` - System calling thread's ID. Never returns 0 inside parallel region. `C=` - The index of the current parallel task. SEE: setNumThreads, getNumThreads
`static long`	`getTickCount()` Returns the number of ticks.
`static double`	`getTickFrequency()` Returns the number of ticks per second.
`static int`	`getVersionMajor()` Returns major library version
`static int`	`getVersionMinor()` Returns minor library version
`static int`	`getVersionRevision()` Returns revision field of the library version
`static String`	`getVersionString()` Returns library version string For example "3.4.1-dev".
`static void`	`hconcat(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)` Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
`static void`	`idct(Mat src, Mat dst, int flags)` Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
`static void`	`idft(Mat src, Mat dst)` Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
`static void`	`idft(Mat src, Mat dst, int flags)` Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
`static void`	`idft(Mat src, Mat dst, int flags, int nonzeroRows)` Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
`static void`	`inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst)` Checks if array elements lie between the elements of two other arrays.
`static void`	`insertChannel(Mat src, Mat dst, int coi)` Inserts a single channel to dst (coi is 0-based index)
`static double`	`invert(Mat src, Mat dst)` Finds the inverse or pseudo-inverse of a matrix.
`static double`	`invert(Mat src, Mat dst, int flags)` Finds the inverse or pseudo-inverse of a matrix.
`static double`	`kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)` Finds centers of clusters and groups input samples around the clusters.
`static double`	`kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)` Finds centers of clusters and groups input samples around the clusters.
`static void`	`log(Mat src, Mat dst)` Calculates the natural logarithm of every array element.
`static void`	`LUT(Mat src, Mat lut, Mat dst)` Performs a look-up table transform of an array.
`static void`	`magnitude(Mat x, Mat y, Mat magnitude)` Calculates the magnitude of 2D vectors.
`static double`	`Mahalanobis(Mat v1, Mat v2, Mat icovar)` Calculates the Mahalanobis distance between two vectors.
`static void`	`max(Mat src1, Mat src2, Mat dst)` Calculates per-element maximum of two arrays or an array and a scalar.
`static void`	`max(Mat src1, Scalar src2, Mat dst)`
`static Scalar`	`mean(Mat src)` Calculates an average (mean) of array elements.
`static Scalar`	`mean(Mat src, Mat mask)` Calculates an average (mean) of array elements.
`static void`	`meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev)` Calculates a mean and standard deviation of array elements.
`static void`	`meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev, Mat mask)` Calculates a mean and standard deviation of array elements.
`static void`	`merge(List<Mat> mv, Mat dst)`
`static void`	`min(Mat src1, Mat src2, Mat dst)` Calculates per-element minimum of two arrays or an array and a scalar.
`static void`	`min(Mat src1, Scalar src2, Mat dst)`
`static Core.MinMaxLocResult`	`minMaxLoc(Mat src)`
`static Core.MinMaxLocResult`	`minMaxLoc(Mat src, Mat mask)`
`static void`	`mixChannels(List<Mat> src, List<Mat> dst, MatOfInt fromTo)`
`static void`	`mulSpectrums(Mat a, Mat b, Mat c, int flags)` Performs the per-element multiplication of two Fourier spectrums.
`static void`	`mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)` Performs the per-element multiplication of two Fourier spectrums.
`static void`	`multiply(Mat src1, Mat src2, Mat dst)` Calculates the per-element scaled product of two arrays.
`static void`	`multiply(Mat src1, Mat src2, Mat dst, double scale)` Calculates the per-element scaled product of two arrays.
`static void`	`multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype)` Calculates the per-element scaled product of two arrays.
`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)` Calculates the product of a matrix and its transposition.
`static void`	`mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta)` Calculates the product of a matrix and its transposition.
`static void`	`mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale)` Calculates the product of a matrix and its transposition.
`static void`	`mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)` Calculates the product of a matrix and its transposition.
`static double`	`norm(Mat src1)` Calculates the absolute norm of an array.
`static double`	`norm(Mat src1, int normType)` Calculates the absolute norm of an array.
`static double`	`norm(Mat src1, int normType, Mat mask)` Calculates the absolute norm of an array.
`static double`	`norm(Mat src1, Mat src2)` Calculates an absolute difference norm or a relative difference norm.
`static double`	`norm(Mat src1, Mat src2, int normType)` Calculates an absolute difference norm or a relative difference norm.
`static double`	`norm(Mat src1, Mat src2, int normType, Mat mask)` Calculates an absolute difference norm or a relative difference norm.
`static void`	`normalize(Mat src, Mat dst)` Normalizes the norm or value range of an array.
`static void`	`normalize(Mat src, Mat dst, double alpha)` Normalizes the norm or value range of an array.
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta)` Normalizes the norm or value range of an array.
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type)` Normalizes the norm or value range of an array.
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)` Normalizes the norm or value range of an array.
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)` Normalizes the norm or value range of an array.
`static void`	`patchNaNs(Mat a)` converts NaN's to the given number
`static void`	`patchNaNs(Mat a, double val)` converts NaN's to the given number
`static void`	`PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result)` wrap PCA::backProject
`static void`	`PCACompute(Mat data, Mat mean, Mat eigenvectors)` wrap PCA::operator()
`static void`	`PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)` wrap PCA::operator()
`static void`	`PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents)` wrap PCA::operator()
`static void`	`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result)` wrap PCA::project
`static void`	`perspectiveTransform(Mat src, Mat dst, Mat m)` Performs the perspective matrix transformation of vectors.
`static void`	`phase(Mat x, Mat y, Mat angle)` Calculates the rotation angle of 2D vectors.
`static void`	`phase(Mat x, Mat y, Mat angle, boolean angleInDegrees)` Calculates the rotation angle of 2D vectors.
`static void`	`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)` Calculates x and y coordinates of 2D vectors from their magnitude and angle.
`static void`	`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)` Calculates x and y coordinates of 2D vectors from their magnitude and angle.
`static void`	`pow(Mat src, double power, Mat dst)` Raises every array element to a power.
`static double`	`PSNR(Mat src1, Mat src2)` Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
`static double`	`PSNR(Mat src1, Mat src2, double R)` Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
`static void`	`randn(Mat dst, double mean, double stddev)` Fills the array with normally distributed random numbers.
`static void`	`randShuffle(Mat dst)` Shuffles the array elements randomly.
`static void`	`randShuffle(Mat dst, double iterFactor)` Shuffles the array elements randomly.
`static void`	`randu(Mat dst, double low, double high)` Generates a single uniformly-distributed random number or an array of random numbers.
`static void`	`reduce(Mat src, Mat dst, int dim, int rtype)` Reduces a matrix to a vector.
`static void`	`reduce(Mat src, Mat dst, int dim, int rtype, int dtype)` Reduces a matrix to a vector.
`static void`	`repeat(Mat src, int ny, int nx, Mat dst)` Fills the output array with repeated copies of the input array.
`static void`	`rotate(Mat src, Mat dst, int rotateCode)` Rotates a 2D array in multiples of 90 degrees.
`static void`	`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)` Calculates the sum of a scaled array and another array.
`static void`	`setErrorVerbosity(boolean verbose)`
`static void`	`setIdentity(Mat mtx)` Initializes a scaled identity matrix.
`static void`	`setIdentity(Mat mtx, Scalar s)` Initializes a scaled identity matrix.
`static void`	`setNumThreads(int nthreads)` OpenCV will try to set the number of threads for the next parallel region.
`static void`	`setRNGSeed(int seed)` Sets state of default random number generator.
`static void`	`setUseIPP_NotExact(boolean flag)`
`static void`	`setUseIPP(boolean flag)`
`static boolean`	`solve(Mat src1, Mat src2, Mat dst)` Solves one or more linear systems or least-squares problems.
`static boolean`	`solve(Mat src1, Mat src2, Mat dst, int flags)` Solves one or more linear systems or least-squares problems.
`static int`	`solveCubic(Mat coeffs, Mat roots)` Finds the real roots of a cubic equation.
`static double`	`solvePoly(Mat coeffs, Mat roots)` Finds the real or complex roots of a polynomial equation.
`static double`	`solvePoly(Mat coeffs, Mat roots, int maxIters)` Finds the real or complex roots of a polynomial equation.
`static void`	`sort(Mat src, Mat dst, int flags)` Sorts each row or each column of a matrix.
`static void`	`sortIdx(Mat src, Mat dst, int flags)` Sorts each row or each column of a matrix.
`static void`	`split(Mat m, List<Mat> mv)`
`static void`	`sqrt(Mat src, Mat dst)` Calculates a square root of array elements.
`static void`	`subtract(Mat src1, Mat src2, Mat dst)` Calculates the per-element difference between two arrays or array and a scalar.
`static void`	`subtract(Mat src1, Mat src2, Mat dst, Mat mask)` Calculates the per-element difference between two arrays or array and a scalar.
`static void`	`subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)` Calculates the per-element difference between two arrays or array and a scalar.
`static void`	`subtract(Mat src1, Scalar src2, Mat dst)`
`static void`	`subtract(Mat src1, Scalar src2, Mat dst, Mat mask)`
`static void`	`subtract(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)`
`static Scalar`	`sumElems(Mat src)` Calculates the sum of array elements.
`static void`	`SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)` wrap SVD::backSubst
`static void`	`SVDecomp(Mat src, Mat w, Mat u, Mat vt)` wrap SVD::compute
`static void`	`SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags)` wrap SVD::compute
`static Scalar`	`trace(Mat mtx)` Returns the trace of a matrix.
`static void`	`transform(Mat src, Mat dst, Mat m)` Performs the matrix transformation of every array element.
`static void`	`transpose(Mat src, Mat dst)` Transposes a matrix.
`static boolean`	`useIPP_NotExact()`
`static boolean`	`useIPP()` proxy for hal::Cholesky
`static void`	`vconcat(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]`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - VERSION
```
public static final String VERSION
```
  - NATIVE_LIBRARY_NAME
```
public static final String NATIVE_LIBRARY_NAME
```
  - VERSION_MAJOR
```
public static final int VERSION_MAJOR
```
  - VERSION_MINOR
```
public static final int VERSION_MINOR
```
  - VERSION_REVISION
```
public static final int VERSION_REVISION
```
  - VERSION_STATUS
```
public static final String VERSION_STATUS
```
  - DECOMP_LU
```
public static final int DECOMP_LU
```
    See Also:
    
    Constant Field Values
  - DECOMP_SVD
```
public static final int DECOMP_SVD
```
    See Also:
    
    Constant Field Values
  - DECOMP_EIG
```
public static final int DECOMP_EIG
```
    See Also:
    
    Constant Field Values
  - DECOMP_CHOLESKY
```
public static final int DECOMP_CHOLESKY
```
    See Also:
    
    Constant Field Values
  - DECOMP_QR
```
public static final int DECOMP_QR
```
    See Also:
    
    Constant Field Values
  - DECOMP_NORMAL
```
public static final int DECOMP_NORMAL
```
    See Also:
    
    Constant Field Values
  - BORDER_CONSTANT
```
public static final int BORDER_CONSTANT
```
    See Also:
    
    Constant Field Values
  - BORDER_REPLICATE
```
public static final int BORDER_REPLICATE
```
    See Also:
    
    Constant Field Values
  - BORDER_REFLECT
```
public static final int BORDER_REFLECT
```
    See Also:
    
    Constant Field Values
  - BORDER_WRAP
```
public static final int BORDER_WRAP
```
    See Also:
    
    Constant Field Values
  - BORDER_REFLECT_101
```
public static final int BORDER_REFLECT_101
```
    See Also:
    
    Constant Field Values
  - BORDER_TRANSPARENT
```
public static final int BORDER_TRANSPARENT
```
    See Also:
    
    Constant Field Values
  - BORDER_REFLECT101
```
public static final int BORDER_REFLECT101
```
    See Also:
    
    Constant Field Values
  - BORDER_DEFAULT
```
public static final int BORDER_DEFAULT
```
    See Also:
    
    Constant Field Values
  - BORDER_ISOLATED
```
public static final int BORDER_ISOLATED
```
    See Also:
    
    Constant Field Values
  - GEMM_1_T
```
public static final int GEMM_1_T
```
    See Also:
    
    Constant Field Values
  - GEMM_2_T
```
public static final int GEMM_2_T
```
    See Also:
    
    Constant Field Values
  - GEMM_3_T
```
public static final int GEMM_3_T
```
    See Also:
    
    Constant Field Values
  - KMEANS_RANDOM_CENTERS
```
public static final int KMEANS_RANDOM_CENTERS
```
    See Also:
    
    Constant Field Values
  - KMEANS_PP_CENTERS
```
public static final int KMEANS_PP_CENTERS
```
    See Also:
    
    Constant Field Values
  - KMEANS_USE_INITIAL_LABELS
```
public static final int KMEANS_USE_INITIAL_LABELS
```
    See Also:
    
    Constant Field Values
  - CMP_EQ
```
public static final int CMP_EQ
```
    See Also:
    
    Constant Field Values
  - CMP_GT
```
public static final int CMP_GT
```
    See Also:
    
    Constant Field Values
  - CMP_GE
```
public static final int CMP_GE
```
    See Also:
    
    Constant Field Values
  - CMP_LT
```
public static final int CMP_LT
```
    See Also:
    
    Constant Field Values
  - CMP_LE
```
public static final int CMP_LE
```
    See Also:
    
    Constant Field Values
  - CMP_NE
```
public static final int CMP_NE
```
    See Also:
    
    Constant Field Values
  - SVD_MODIFY_A
```
public static final int SVD_MODIFY_A
```
    See Also:
    
    Constant Field Values
  - SVD_NO_UV
```
public static final int SVD_NO_UV
```
    See Also:
    
    Constant Field Values
  - SVD_FULL_UV
```
public static final int SVD_FULL_UV
```
    See Also:
    
    Constant Field Values
  - FILLED
```
public static final int FILLED
```
    See Also:
    
    Constant Field Values
  - REDUCE_SUM
```
public static final int REDUCE_SUM
```
    See Also:
    
    Constant Field Values
  - REDUCE_AVG
```
public static final int REDUCE_AVG
```
    See Also:
    
    Constant Field Values
  - REDUCE_MAX
```
public static final int REDUCE_MAX
```
    See Also:
    
    Constant Field Values
  - REDUCE_MIN
```
public static final int REDUCE_MIN
```
    See Also:
    
    Constant Field Values
  - RNG_UNIFORM
```
public static final int RNG_UNIFORM
```
    See Also:
    
    Constant Field Values
  - RNG_NORMAL
```
public static final int RNG_NORMAL
```
    See Also:
    
    Constant Field Values
  - PCA_DATA_AS_ROW
```
public static final int PCA_DATA_AS_ROW
```
    See Also:
    
    Constant Field Values
  - PCA_DATA_AS_COL
```
public static final int PCA_DATA_AS_COL
```
    See Also:
    
    Constant Field Values
  - PCA_USE_AVG
```
public static final int PCA_USE_AVG
```
    See Also:
    
    Constant Field Values
  - DFT_INVERSE
```
public static final int DFT_INVERSE
```
    See Also:
    
    Constant Field Values
  - DFT_SCALE
```
public static final int DFT_SCALE
```
    See Also:
    
    Constant Field Values
  - DFT_ROWS
```
public static final int DFT_ROWS
```
    See Also:
    
    Constant Field Values
  - DFT_COMPLEX_OUTPUT
```
public static final int DFT_COMPLEX_OUTPUT
```
    See Also:
    
    Constant Field Values
  - DFT_REAL_OUTPUT
```
public static final int DFT_REAL_OUTPUT
```
    See Also:
    
    Constant Field Values
  - DFT_COMPLEX_INPUT
```
public static final int DFT_COMPLEX_INPUT
```
    See Also:
    
    Constant Field Values
  - DCT_INVERSE
```
public static final int DCT_INVERSE
```
    See Also:
    
    Constant Field Values
  - DCT_ROWS
```
public static final int DCT_ROWS
```
    See Also:
    
    Constant Field Values
  - COVAR_SCRAMBLED
```
public static final int COVAR_SCRAMBLED
```
    See Also:
    
    Constant Field Values
  - COVAR_NORMAL
```
public static final int COVAR_NORMAL
```
    See Also:
    
    Constant Field Values
  - COVAR_USE_AVG
```
public static final int COVAR_USE_AVG
```
    See Also:
    
    Constant Field Values
  - COVAR_SCALE
```
public static final int COVAR_SCALE
```
    See Also:
    
    Constant Field Values
  - COVAR_ROWS
```
public static final int COVAR_ROWS
```
    See Also:
    
    Constant Field Values
  - COVAR_COLS
```
public static final int COVAR_COLS
```
    See Also:
    
    Constant Field Values
  - SORT_EVERY_ROW
```
public static final int SORT_EVERY_ROW
```
    See Also:
    
    Constant Field Values
  - SORT_EVERY_COLUMN
```
public static final int SORT_EVERY_COLUMN
```
    See Also:
    
    Constant Field Values
  - SORT_ASCENDING
```
public static final int SORT_ASCENDING
```
    See Also:
    
    Constant Field Values
  - SORT_DESCENDING
```
public static final int SORT_DESCENDING
```
    See Also:
    
    Constant Field Values
  - Formatter_FMT_DEFAULT
```
public static final int Formatter_FMT_DEFAULT
```
    See Also:
    
    Constant Field Values
  - Formatter_FMT_MATLAB
```
public static final int Formatter_FMT_MATLAB
```
    See Also:
    
    Constant Field Values
  - Formatter_FMT_CSV
```
public static final int Formatter_FMT_CSV
```
    See Also:
    
    Constant Field Values
  - Formatter_FMT_PYTHON
```
public static final int Formatter_FMT_PYTHON
```
    See Also:
    
    Constant Field Values
  - Formatter_FMT_NUMPY
```
public static final int Formatter_FMT_NUMPY
```
    See Also:
    
    Constant Field Values
  - Formatter_FMT_C
```
public static final int Formatter_FMT_C
```
    See Also:
    
    Constant Field Values
  - Param_INT
```
public static final int Param_INT
```
    See Also:
    
    Constant Field Values
  - Param_BOOLEAN
```
public static final int Param_BOOLEAN
```
    See Also:
    
    Constant Field Values
  - Param_REAL
```
public static final int Param_REAL
```
    See Also:
    
    Constant Field Values
  - Param_STRING
```
public static final int Param_STRING
```
    See Also:
    
    Constant Field Values
  - Param_MAT
```
public static final int Param_MAT
```
    See Also:
    
    Constant Field Values
  - Param_MAT_VECTOR
```
public static final int Param_MAT_VECTOR
```
    See Also:
    
    Constant Field Values
  - Param_ALGORITHM
```
public static final int Param_ALGORITHM
```
    See Also:
    
    Constant Field Values
  - Param_FLOAT
```
public static final int Param_FLOAT
```
    See Also:
    
    Constant Field Values
  - Param_UNSIGNED_INT
```
public static final int Param_UNSIGNED_INT
```
    See Also:
    
    Constant Field Values
  - Param_UINT64
```
public static final int Param_UINT64
```
    See Also:
    
    Constant Field Values
  - Param_UCHAR
```
public static final int Param_UCHAR
```
    See Also:
    
    Constant Field Values
  - Param_SCALAR
```
public static final int Param_SCALAR
```
    See Also:
    
    Constant Field Values
  - NORM_INF
```
public static final int NORM_INF
```
    See Also:
    
    Constant Field Values
  - NORM_L1
```
public static final int NORM_L1
```
    See Also:
    
    Constant Field Values
  - NORM_L2
```
public static final int NORM_L2
```
    See Also:
    
    Constant Field Values
  - NORM_L2SQR
```
public static final int NORM_L2SQR
```
    See Also:
    
    Constant Field Values
  - NORM_HAMMING
```
public static final int NORM_HAMMING
```
    See Also:
    
    Constant Field Values
  - NORM_HAMMING2
```
public static final int NORM_HAMMING2
```
    See Also:
    
    Constant Field Values
  - NORM_TYPE_MASK
```
public static final int NORM_TYPE_MASK
```
    See Also:
    
    Constant Field Values
  - NORM_RELATIVE
```
public static final int NORM_RELATIVE
```
    See Also:
    
    Constant Field Values
  - NORM_MINMAX
```
public static final int NORM_MINMAX
```
    See Also:
    
    Constant Field Values
  - ROTATE_90_CLOCKWISE
```
public static final int ROTATE_90_CLOCKWISE
```
    See Also:
    
    Constant Field Values
  - ROTATE_180
```
public static final int ROTATE_180
```
    See Also:
    
    Constant Field Values
  - ROTATE_90_COUNTERCLOCKWISE
```
public static final int ROTATE_90_COUNTERCLOCKWISE
```
    See Also:
    
    Constant Field Values
  - StsOk
```
public static final int StsOk
```
    See Also:
    
    Constant Field Values
  - StsBackTrace
```
public static final int StsBackTrace
```
    See Also:
    
    Constant Field Values
  - StsError
```
public static final int StsError
```
    See Also:
    
    Constant Field Values
  - StsInternal
```
public static final int StsInternal
```
    See Also:
    
    Constant Field Values
  - StsNoMem
```
public static final int StsNoMem
```
    See Also:
    
    Constant Field Values
  - StsBadArg
```
public static final int StsBadArg
```
    See Also:
    
    Constant Field Values
  - StsBadFunc
```
public static final int StsBadFunc
```
    See Also:
    
    Constant Field Values
  - StsNoConv
```
public static final int StsNoConv
```
    See Also:
    
    Constant Field Values
  - StsAutoTrace
```
public static final int StsAutoTrace
```
    See Also:
    
    Constant Field Values
  - HeaderIsNull
```
public static final int HeaderIsNull
```
    See Also:
    
    Constant Field Values
  - BadImageSize
```
public static final int BadImageSize
```
    See Also:
    
    Constant Field Values
  - BadOffset
```
public static final int BadOffset
```
    See Also:
    
    Constant Field Values
  - BadDataPtr
```
public static final int BadDataPtr
```
    See Also:
    
    Constant Field Values
  - BadStep
```
public static final int BadStep
```
    See Also:
    
    Constant Field Values
  - BadModelOrChSeq
```
public static final int BadModelOrChSeq
```
    See Also:
    
    Constant Field Values
  - BadNumChannels
```
public static final int BadNumChannels
```
    See Also:
    
    Constant Field Values
  - BadNumChannel1U
```
public static final int BadNumChannel1U
```
    See Also:
    
    Constant Field Values
  - BadDepth
```
public static final int BadDepth
```
    See Also:
    
    Constant Field Values
  - BadAlphaChannel
```
public static final int BadAlphaChannel
```
    See Also:
    
    Constant Field Values
  - BadOrder
```
public static final int BadOrder
```
    See Also:
    
    Constant Field Values
  - BadOrigin
```
public static final int BadOrigin
```
    See Also:
    
    Constant Field Values
  - BadAlign
```
public static final int BadAlign
```
    See Also:
    
    Constant Field Values
  - BadCallBack
```
public static final int BadCallBack
```
    See Also:
    
    Constant Field Values
  - BadTileSize
```
public static final int BadTileSize
```
    See Also:
    
    Constant Field Values
  - BadCOI
```
public static final int BadCOI
```
    See Also:
    
    Constant Field Values
  - BadROISize
```
public static final int BadROISize
```
    See Also:
    
    Constant Field Values
  - MaskIsTiled
```
public static final int MaskIsTiled
```
    See Also:
    
    Constant Field Values
  - StsNullPtr
```
public static final int StsNullPtr
```
    See Also:
    
    Constant Field Values
  - StsVecLengthErr
```
public static final int StsVecLengthErr
```
    See Also:
    
    Constant Field Values
  - StsFilterStructContentErr
```
public static final int StsFilterStructContentErr
```
    See Also:
    
    Constant Field Values
  - StsKernelStructContentErr
```
public static final int StsKernelStructContentErr
```
    See Also:
    
    Constant Field Values
  - StsFilterOffsetErr
```
public static final int StsFilterOffsetErr
```
    See Also:
    
    Constant Field Values
  - StsBadSize
```
public static final int StsBadSize
```
    See Also:
    
    Constant Field Values
  - StsDivByZero
```
public static final int StsDivByZero
```
    See Also:
    
    Constant Field Values
  - StsInplaceNotSupported
```
public static final int StsInplaceNotSupported
```
    See Also:
    
    Constant Field Values
  - StsObjectNotFound
```
public static final int StsObjectNotFound
```
    See Also:
    
    Constant Field Values
  - StsUnmatchedFormats
```
public static final int StsUnmatchedFormats
```
    See Also:
    
    Constant Field Values
  - StsBadFlag
```
public static final int StsBadFlag
```
    See Also:
    
    Constant Field Values
  - StsBadPoint
```
public static final int StsBadPoint
```
    See Also:
    
    Constant Field Values
  - StsBadMask
```
public static final int StsBadMask
```
    See Also:
    
    Constant Field Values
  - StsUnmatchedSizes
```
public static final int StsUnmatchedSizes
```
    See Also:
    
    Constant Field Values
  - StsUnsupportedFormat
```
public static final int StsUnsupportedFormat
```
    See Also:
    
    Constant Field Values
  - StsOutOfRange
```
public static final int StsOutOfRange
```
    See Also:
    
    Constant Field Values
  - StsParseError
```
public static final int StsParseError
```
    See Also:
    
    Constant Field Values
  - StsNotImplemented
```
public static final int StsNotImplemented
```
    See Also:
    
    Constant Field Values
  - StsBadMemBlock
```
public static final int StsBadMemBlock
```
    See Also:
    
    Constant Field Values
  - StsAssert
```
public static final int StsAssert
```
    See Also:
    
    Constant Field Values
  - GpuNotSupported
```
public static final int GpuNotSupported
```
    See Also:
    
    Constant Field Values
  - GpuApiCallError
```
public static final int GpuApiCallError
```
    See Also:
    
    Constant Field Values
  - OpenGlNotSupported
```
public static final int OpenGlNotSupported
```
    See Also:
    
    Constant Field Values
  - OpenGlApiCallError
```
public static final int OpenGlApiCallError
```
    See Also:
    
    Constant Field Values
  - OpenCLApiCallError
```
public static final int OpenCLApiCallError
```
    See Also:
    
    Constant Field Values
  - OpenCLDoubleNotSupported
```
public static final int OpenCLDoubleNotSupported
```
    See Also:
    
    Constant Field Values
  - OpenCLInitError
```
public static final int OpenCLInitError
```
    See Also:
    
    Constant Field Values
  - OpenCLNoAMDBlasFft
```
public static final int OpenCLNoAMDBlasFft
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Core
```
public Core()
```
- Method Detail
  - mean
```
public static Scalar mean(Mat src,
                          Mat mask)
```
    Calculates an average (mean) of array elements. The function cv::mean calculates the mean value M of array elements, independently for each channel, and return it: \(\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}\) When all the mask elements are 0's, the function returns Scalar::all(0)
    
    Parameters:
    
    src - input array that should have from 1 to 4 channels so that the result can be stored in Scalar_ .
    
    mask - optional operation mask. SEE: countNonZero, meanStdDev, norm, minMaxLoc
    
    Returns:
    
    automatically generated
  - mean
```
public static Scalar mean(Mat src)
```
    Calculates an average (mean) of array elements. The function cv::mean calculates the mean value M of array elements, independently for each channel, and return it: \(\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}\) When all the mask elements are 0's, the function returns Scalar::all(0)
    
    Parameters:
    
    src - input array that should have from 1 to 4 channels so that the result can be stored in Scalar_ . SEE: countNonZero, meanStdDev, norm, minMaxLoc
    
    Returns:
    
    automatically generated
  - sumElems
```
public static Scalar sumElems(Mat src)
```
    Calculates the sum of array elements. The function cv::sum calculates and returns the sum of array elements, independently for each channel.
    
    Parameters:
    
    src - input array that must have from 1 to 4 channels. SEE: countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce
    
    Returns:
    
    automatically generated
  - trace
```
public static Scalar trace(Mat mtx)
```
    Returns the trace of a matrix. The function cv::trace returns the sum of the diagonal elements of the matrix mtx . \(\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\)
    
    Parameters:
    
    mtx - input matrix.
    
    Returns:
    
    automatically generated
  - getBuildInformation
```
public static String getBuildInformation()
```
    Returns full configuration time cmake output. Returned value is raw cmake output including version control system revision, compiler version, compiler flags, enabled modules and third party libraries, etc. Output format depends on target architecture.
    
    Returns:
    
    automatically generated
  - getHardwareFeatureName
```
public static String getHardwareFeatureName(int feature)
```
    Returns feature name by ID Returns empty string if feature is not defined
    
    Parameters:
    
    feature - automatically generated
    
    Returns:
    
    automatically generated
  - getVersionString
```
public static String getVersionString()
```
    Returns library version string For example "3.4.1-dev". SEE: getMajorVersion, getMinorVersion, getRevisionVersion
    
    Returns:
    
    automatically generated
  - getIppVersion
```
public static String getIppVersion()
```
  - findFile
```
public static String findFile(String relative_path,
                              boolean required,
                              boolean silentMode)
```
    Try to find requested data file Search directories: 1. Directories passed via addSamplesDataSearchPath() 2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable 3. OPENCV_SAMPLES_DATA_PATH environment variable If parameter value is not empty and nothing is found then stop searching. 4. Detects build/install path based on: a. current working directory (CWD) b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage) 5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan <install>/share/OpenCV directory if install directory is detected. SEE: cv::utils::findDataFile
    
    Parameters:
    
    relative_path - Relative path to data file
    
    required - Specify "file not found" handling. If true, function prints information message and raises cv::Exception. If false, function returns empty result
    
    silentMode - Disables messages
    
    Returns:
    
    Returns path (absolute or relative to the current directory) or empty string if file is not found
  - findFile
```
public static String findFile(String relative_path,
                              boolean required)
```
    Try to find requested data file Search directories: 1. Directories passed via addSamplesDataSearchPath() 2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable 3. OPENCV_SAMPLES_DATA_PATH environment variable If parameter value is not empty and nothing is found then stop searching. 4. Detects build/install path based on: a. current working directory (CWD) b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage) 5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan <install>/share/OpenCV directory if install directory is detected. SEE: cv::utils::findDataFile
    
    Parameters:
    
    relative_path - Relative path to data file
    
    required - Specify "file not found" handling. If true, function prints information message and raises cv::Exception. If false, function returns empty result
    
    Returns:
    
    Returns path (absolute or relative to the current directory) or empty string if file is not found
  - findFile
```
public static String findFile(String relative_path)
```
    Try to find requested data file Search directories: 1. Directories passed via addSamplesDataSearchPath() 2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable 3. OPENCV_SAMPLES_DATA_PATH environment variable If parameter value is not empty and nothing is found then stop searching. 4. Detects build/install path based on: a. current working directory (CWD) b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage) 5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan <install>/share/OpenCV directory if install directory is detected. SEE: cv::utils::findDataFile
    
    Parameters:
    
    relative_path - Relative path to data file If true, function prints information message and raises cv::Exception. If false, function returns empty result
    
    Returns:
    
    Returns path (absolute or relative to the current directory) or empty string if file is not found
  - findFileOrKeep
```
public static String findFileOrKeep(String relative_path,
                                    boolean silentMode)
```
  - findFileOrKeep
```
public static String findFileOrKeep(String relative_path)
```
  - checkRange
```
public static boolean checkRange(Mat a,
                                 boolean quiet,
                                 double minVal,
                                 double maxVal)
```
    Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
    - DBL_MAX and maxVal < DBL_MAX, the function also checks that each value is between minVal and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the function either returns false (when quiet=true) or throws an exception.
    Parameters:
    
    a - input array.
    
    quiet - a flag, indicating whether the functions quietly return false when the array elements are out of range or they throw an exception. elements.
    
    minVal - inclusive lower boundary of valid values range.
    
    maxVal - exclusive upper boundary of valid values range.
  Returns:
  
  automatically generated
- checkRange
```
public static boolean checkRange(Mat a,
                                 boolean quiet,
                                 double minVal)
```
  Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
  - DBL_MAX and maxVal < DBL_MAX, the function also checks that each value is between minVal and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the function either returns false (when quiet=true) or throws an exception.
  Parameters:
  
  a - input array.
  
  quiet - a flag, indicating whether the functions quietly return false when the array elements are out of range or they throw an exception. elements.
  
  minVal - inclusive lower boundary of valid values range.
Returns:

automatically generated

checkRange
```
public static boolean checkRange(Mat a,
                                 boolean quiet)
```
Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
- DBL_MAX and maxVal < DBL_MAX, the function also checks that each value is between minVal and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the function either returns false (when quiet=true) or throws an exception.
Parameters:

a - input array.

quiet - a flag, indicating whether the functions quietly return false when the array elements are out of range or they throw an exception. elements.

Returns:

automatically generated

checkRange
```
public static boolean checkRange(Mat a)
```
Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
- DBL_MAX and maxVal < DBL_MAX, the function also checks that each value is between minVal and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the function either returns false (when quiet=true) or throws an exception.
Parameters:

a - input array. are out of range or they throw an exception. elements.

Returns:

automatically generated

eigen
```
public static boolean eigen(Mat src,
                            Mat eigenvalues,
                            Mat eigenvectors)
```
Calculates eigenvalues and eigenvectors of a symmetric matrix. The function cv::eigen calculates just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix src: src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() Note: Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.

Parameters:

src - input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical (src ^T^ == src).

eigenvalues - output vector of eigenvalues of the same type as src; the eigenvalues are stored in the descending order.

eigenvectors - output matrix of eigenvectors; it has the same size and type as src; the eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues. SEE: eigenNonSymmetric, completeSymm , PCA

Returns:

automatically generated

eigen
```
public static boolean eigen(Mat src,
                            Mat eigenvalues)
```
Calculates eigenvalues and eigenvectors of a symmetric matrix. The function cv::eigen calculates just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix src: src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() Note: Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.

Parameters:

src - input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical (src ^T^ == src).

eigenvalues - output vector of eigenvalues of the same type as src; the eigenvalues are stored in the descending order. eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues. SEE: eigenNonSymmetric, completeSymm , PCA

Returns:

automatically generated

solve
```
public static boolean solve(Mat src1,
                            Mat src2,
                            Mat dst,
                            int flags)
```
Solves one or more linear systems or least-squares problems. The function cv::solve solves a linear system or least-squares problem (the latter is possible with SVD or QR methods, or by specifying the flag #DECOMP_NORMAL ): \(\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\) If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \(\texttt{src1}^T\texttt{src1}\) ) is non-singular. Otherwise, it returns 0. In the latter case, dst is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part. Note: If you want to find a unity-norm solution of an under-defined singular system \(\texttt{src1}\cdot\texttt{dst}=0\) , the function solve will not do the work. Use SVD::solveZ instead.

Parameters:

src1 - input matrix on the left-hand side of the system.

src2 - input matrix on the right-hand side of the system.

dst - output solution.

flags - solution (matrix inversion) method (#DecompTypes) SEE: invert, SVD, eigen

Returns:

automatically generated

solve
```
public static boolean solve(Mat src1,
                            Mat src2,
                            Mat dst)
```
Solves one or more linear systems or least-squares problems. The function cv::solve solves a linear system or least-squares problem (the latter is possible with SVD or QR methods, or by specifying the flag #DECOMP_NORMAL ): \(\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\) If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \(\texttt{src1}^T\texttt{src1}\) ) is non-singular. Otherwise, it returns 0. In the latter case, dst is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part. Note: If you want to find a unity-norm solution of an under-defined singular system \(\texttt{src1}\cdot\texttt{dst}=0\) , the function solve will not do the work. Use SVD::solveZ instead.

Parameters:

src1 - input matrix on the left-hand side of the system.

src2 - input matrix on the right-hand side of the system.

dst - output solution. SEE: invert, SVD, eigen

Returns:

automatically generated

useIPP
```
public static boolean useIPP()
```
proxy for hal::Cholesky

Returns:

automatically generated

useIPP_NotExact

public static boolean useIPP_NotExact()

Mahalanobis
```
public static double Mahalanobis(Mat v1,
                                 Mat v2,
                                 Mat icovar)
```
Calculates the Mahalanobis distance between two vectors. The function cv::Mahalanobis calculates and returns the weighted distance between two vectors: \(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)})} }\) The covariance matrix may be calculated using the #calcCovarMatrix function and then inverted using the invert function (preferably using the #DECOMP_SVD method, as the most accurate).

Parameters:

v1 - first 1D input vector.

v2 - second 1D input vector.

icovar - inverse covariance matrix.

Returns:

automatically generated

PSNR
```
public static double PSNR(Mat src1,
                          Mat src2,
                          double R)
```
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric. This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality metric in decibels (dB), between two input arrays src1 and src2. The arrays must have the same type. The PSNR is calculated as follows: \( \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \) where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U data) and MSE is the mean squared error between the two arrays.

Parameters:

src1 - first input array.

src2 - second input array of the same size as src1.

R - the maximum pixel value (255 by default)

Returns:

automatically generated

PSNR
```
public static double PSNR(Mat src1,
                          Mat src2)
```
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric. This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality metric in decibels (dB), between two input arrays src1 and src2. The arrays must have the same type. The PSNR is calculated as follows: \( \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \) where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U data) and MSE is the mean squared error between the two arrays.

Parameters:

src1 - first input array.

src2 - second input array of the same size as src1.

Returns:

automatically generated

determinant
```
public static double determinant(Mat mtx)
```
Returns the determinant of a square floating-point matrix. The function cv::determinant calculates and returns the determinant of the specified matrix. For small matrices ( mtx.cols=mtx.rows<=3 ), the direct method is used. For larger matrices, the function uses LU factorization with partial pivoting. For symmetric positively-determined matrices, it is also possible to use eigen decomposition to calculate the determinant.

Parameters:

mtx - input matrix that must have CV_32FC1 or CV_64FC1 type and square size. SEE: trace, invert, solve, eigen, REF: MatrixExpressions

Returns:

automatically generated

getTickFrequency
```
public static double getTickFrequency()
```
Returns the number of ticks per second. The function returns the number of ticks per second. That is, the following code computes the execution time in seconds: double t = (double)getTickCount(); // do something ... t = ((double)getTickCount() - t)/getTickFrequency(); SEE: getTickCount, TickMeter

Returns:

automatically generated

invert
```
public static double invert(Mat src,
                            Mat dst,
                            int flags)
```
Finds the inverse or pseudo-inverse of a matrix. The function cv::invert inverts the matrix src and stores the result in dst . When the matrix src is singular or non-square, the function calculates the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is minimal, where I is an identity matrix. In case of the #DECOMP_LU method, the function returns non-zero value if the inverse has been successfully calculated and 0 if src is singular. In case of the #DECOMP_SVD method, the function returns the inverse condition number of src (the ratio of the smallest singular value to the largest singular value) and 0 if src is singular. The SVD method calculates a pseudo-inverse matrix if src is singular. Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in dst and returns non-zero. Otherwise, it returns 0.

Parameters:

src - input floating-point M x N matrix.

dst - output matrix of N x M size and the same type as src.

flags - inversion method (cv::DecompTypes) SEE: solve, SVD

Returns:

automatically generated

invert
```
public static double invert(Mat src,
                            Mat dst)
```
Finds the inverse or pseudo-inverse of a matrix. The function cv::invert inverts the matrix src and stores the result in dst . When the matrix src is singular or non-square, the function calculates the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is minimal, where I is an identity matrix. In case of the #DECOMP_LU method, the function returns non-zero value if the inverse has been successfully calculated and 0 if src is singular. In case of the #DECOMP_SVD method, the function returns the inverse condition number of src (the ratio of the smallest singular value to the largest singular value) and 0 if src is singular. The SVD method calculates a pseudo-inverse matrix if src is singular. Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in dst and returns non-zero. Otherwise, it returns 0.

Parameters:

src - input floating-point M x N matrix.

dst - output matrix of N x M size and the same type as src. SEE: solve, SVD

Returns:

automatically generated

kmeans
```
public static double kmeans(Mat data,
                            int K,
                            Mat bestLabels,
                            TermCriteria criteria,
                            int attempts,
                            int flags,
                            Mat centers)
```
Finds centers of clusters and groups input samples around the clusters. The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters and groups the input samples around the clusters. As an output, \(\texttt{bestLabels}_i\) contains a 0-based cluster index for the sample stored in the \(i^{th}\) row of the samples matrix. Note:
- (Python) An example on K-means clustering can be found at opencv_source_code/samples/python/kmeans.py
Parameters:

data - Data for clustering. An array of N-Dimensional points with float coordinates is needed. Examples of this array can be:
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 - Number of clusters to split the set by.

bestLabels - Input/output integer array that stores the cluster indices for every sample.

criteria - The algorithm termination criteria, that is, the maximum number of iterations and/or the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster centers moves by less than criteria.epsilon on some iteration, the algorithm stops.

attempts - Flag to specify the number of times the algorithm is executed using different initial labellings. The algorithm returns the labels that yield the best compactness (see the last function parameter).

flags - Flag that can take values of cv::KmeansFlags

centers - Output matrix of the cluster centers, one row per each cluster center.

Returns:

The function returns the compactness measure that is computed as \(\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\) after every attempt. The best (minimum) value is chosen and the corresponding labels and the compactness value are returned by the function. Basically, you can use only the core of the function, set the number of attempts to 1, initialize labels each time using a custom algorithm, pass them with the ( flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best (most-compact) clustering.

kmeans
```
public static double kmeans(Mat data,
                            int K,
                            Mat bestLabels,
                            TermCriteria criteria,
                            int attempts,
                            int flags)
```
Finds centers of clusters and groups input samples around the clusters. The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters and groups the input samples around the clusters. As an output, \(\texttt{bestLabels}_i\) contains a 0-based cluster index for the sample stored in the \(i^{th}\) row of the samples matrix. Note:
- (Python) An example on K-means clustering can be found at opencv_source_code/samples/python/kmeans.py
Parameters:

data - Data for clustering. An array of N-Dimensional points with float coordinates is needed. Examples of this array can be:
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 - Number of clusters to split the set by.

bestLabels - Input/output integer array that stores the cluster indices for every sample.

criteria - The algorithm termination criteria, that is, the maximum number of iterations and/or the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster centers moves by less than criteria.epsilon on some iteration, the algorithm stops.

attempts - Flag to specify the number of times the algorithm is executed using different initial labellings. The algorithm returns the labels that yield the best compactness (see the last function parameter).

flags - Flag that can take values of cv::KmeansFlags

Returns:

The function returns the compactness measure that is computed as \(\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\) after every attempt. The best (minimum) value is chosen and the corresponding labels and the compactness value are returned by the function. Basically, you can use only the core of the function, set the number of attempts to 1, initialize labels each time using a custom algorithm, pass them with the ( flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best (most-compact) clustering.

norm
```
public static double norm(Mat src1,
                          Mat src2,
                          int normType,
                          Mat mask)
```
Calculates an absolute difference norm or a relative difference norm. This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.

Parameters:

src1 - first input array.

src2 - second input array of the same size and the same type as src1.

normType - type of the norm (see #NormTypes).

mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.

Returns:

automatically generated

norm
```
public static double norm(Mat src1,
                          Mat src2,
                          int normType)
```
Calculates an absolute difference norm or a relative difference norm. This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.

Parameters:

src1 - first input array.

src2 - second input array of the same size and the same type as src1.

normType - type of the norm (see #NormTypes).

Returns:

automatically generated

norm
```
public static double norm(Mat src1,
                          Mat src2)
```
Calculates an absolute difference norm or a relative difference norm. This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.

Parameters:

src1 - first input array.

src2 - second input array of the same size and the same type as src1.

Returns:

automatically generated

norm
```
public static double norm(Mat src1,
                          int normType,
                          Mat mask)
```
Calculates the absolute norm of an array. This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes. As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows \(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 \) and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is \(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. \) The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \). ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png) When the mask parameter is specified and it is not empty, the norm is If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask. Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined. Hamming norms can only be calculated with CV_8U depth arrays.

Parameters:

src1 - first input array.

normType - type of the norm (see #NormTypes).

mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.

Returns:

automatically generated

norm
```
public static double norm(Mat src1,
                          int normType)
```
Calculates the absolute norm of an array. This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes. As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows \(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 \) and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is \(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. \) The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \). ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png) When the mask parameter is specified and it is not empty, the norm is If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask. Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined. Hamming norms can only be calculated with CV_8U depth arrays.

Parameters:

src1 - first input array.

normType - type of the norm (see #NormTypes).

Returns:

automatically generated

norm
```
public static double norm(Mat src1)
```
Calculates the absolute norm of an array. This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes. As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows \(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 \) and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is \(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. \) The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \). ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png) When the mask parameter is specified and it is not empty, the norm is If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask. Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined. Hamming norms can only be calculated with CV_8U depth arrays.

Parameters:

src1 - first input array.

Returns:

automatically generated

solvePoly
```
public static double solvePoly(Mat coeffs,
                               Mat roots,
                               int maxIters)
```
Finds the real or complex roots of a polynomial equation. The function cv::solvePoly finds real and complex roots of a polynomial equation: \(\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\)

Parameters:

coeffs - array of polynomial coefficients.

roots - output (complex) array of roots.

maxIters - maximum number of iterations the algorithm does.

Returns:

automatically generated

solvePoly
```
public static double solvePoly(Mat coeffs,
                               Mat roots)
```
Finds the real or complex roots of a polynomial equation. The function cv::solvePoly finds real and complex roots of a polynomial equation: \(\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\)

Parameters:

coeffs - array of polynomial coefficients.

roots - output (complex) array of roots.

Returns:

automatically generated

cubeRoot
```
public static float cubeRoot(float val)
```
Computes the cube root of an argument. The function cubeRoot computes \(\sqrt[3]{\texttt{val}}\). Negative arguments are handled correctly. NaN and Inf are not handled. The accuracy approaches the maximum possible accuracy for single-precision data.

Parameters:

val - A function argument.

Returns:

automatically generated

fastAtan2
```
public static float fastAtan2(float y,
                              float x)
```
Calculates the angle of a 2D vector in degrees. The function fastAtan2 calculates the full-range angle of an input 2D vector. The angle is measured in degrees and varies from 0 to 360 degrees. The accuracy is about 0.3 degrees.

Parameters:

x - x-coordinate of the vector.

y - y-coordinate of the vector.

Returns:

automatically generated

borderInterpolate
```
public static int borderInterpolate(int p,
                                    int len,
                                    int borderType)
```
Computes the source location of an extrapolated pixel. The function computes and returns the coordinate of a donor pixel corresponding to the specified extrapolated pixel when using the specified extrapolation border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img , it looks like: float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101), borderInterpolate(-5, img.cols, cv::BORDER_WRAP)); Normally, the function is not called directly. It is used inside filtering functions and also in copyMakeBorder.

Parameters:

p - 0-based coordinate of the extrapolated pixel along one of the axes, likely <0 or >= len

len - Length of the array along the corresponding axis.

borderType - Border type, one of the #BorderTypes, except for #BORDER_TRANSPARENT and #BORDER_ISOLATED . When borderType==#BORDER_CONSTANT , the function always returns -1, regardless of p and len. SEE: copyMakeBorder

Returns:

automatically generated

countNonZero
```
public static int countNonZero(Mat src)
```
Counts non-zero array elements. The function returns the number of non-zero elements in src : \(\sum _{I: \; \texttt{src} (I) \ne0 } 1\)

Parameters:

src - single-channel array. SEE: mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

Returns:

automatically generated

getNumThreads
```
public static int getNumThreads()
```
Returns the number of threads used by OpenCV for parallel regions. Always returns 1 if OpenCV is built without threading support. The exact meaning of return value depends on the threading framework used by OpenCV library:
- TBB - The number of threads, that OpenCV will try to use for parallel regions. If there is any tbb::thread_scheduler_init in user code conflicting with OpenCV, then function returns default number of threads used by TBB library.
- OpenMP - An upper bound on the number of threads that could be used to form a new team.
- Concurrency - The number of threads, that OpenCV will try to use for parallel regions.
- GCD - Unsupported; returns the GCD thread pool limit (512) for compatibility.
- C= - The number of threads, that OpenCV will try to use for parallel regions, if before called setNumThreads with threads > 0, otherwise returns the number of logical CPUs, available for the process. SEE: setNumThreads, getThreadNum
Returns:

automatically generated

getNumberOfCPUs
```
public static int getNumberOfCPUs()
```
Returns the number of logical CPUs available for the process.

Returns:

automatically generated

getOptimalDFTSize
```
public static int getOptimalDFTSize(int vecsize)
```
Returns the optimal DFT size for a given vector size. DFT performance is not a monotonic function of a vector size. Therefore, when you calculate convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to pad the input data with zeros to get a bit larger array that can be transformed much faster than the original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process. Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5\*5\*3\*2\*2) are also processed quite efficiently. The function cv::getOptimalDFTSize returns the minimum number N that is greater than or equal to vecsize so that the DFT of a vector of size N can be processed efficiently. In the current implementation N = 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some integer p, q, r. The function returns a negative number if vecsize is too large (very close to INT_MAX ). While the function cannot be used directly to estimate the optimal vector size for DCT transform (since the current DCT implementation supports only even-size vectors), it can be easily processed as getOptimalDFTSize((vecsize+1)/2)\*2.

Parameters:

vecsize - vector size. SEE: dft , dct , idft , idct , mulSpectrums

Returns:

automatically generated

getThreadNum
```
@Deprecated
public static int getThreadNum()
```
Deprecated.
Current implementation doesn't corresponding to this documentation. The exact meaning of the return value depends on the threading framework used by OpenCV library:
- TBB - Unsupported with current 4.1 TBB release. Maybe will be supported in future.
- OpenMP - The thread number, within the current team, of the calling thread.
- Concurrency - An ID for the virtual processor that the current context is executing on (0 for master thread and unique number for others, but not necessary 1,2,3,...).
- GCD - System calling thread's ID. Never returns 0 inside parallel region.
- C= - The index of the current parallel task. SEE: setNumThreads, getNumThreads
Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.

Returns:

automatically generated

getVersionMajor
```
public static int getVersionMajor()
```
Returns major library version

Returns:

automatically generated

getVersionMinor
```
public static int getVersionMinor()
```
Returns minor library version

Returns:

automatically generated

getVersionRevision
```
public static int getVersionRevision()
```
Returns revision field of the library version

Returns:

automatically generated

solveCubic
```
public static int solveCubic(Mat coeffs,
                             Mat roots)
```
Finds the real roots of a cubic equation. The function solveCubic finds the real roots of a cubic equation:
- if coeffs is a 4-element vector: \(\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\)
- if coeffs is a 3-element vector: \(x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\)
The roots are stored in the roots array.
Parameters:

coeffs - equation coefficients, an array of 3 or 4 elements.

roots - output array of real roots that has 1 or 3 elements.

Returns:

number of real roots. It can be 0, 1 or 2.

getCPUTickCount
```
public static long getCPUTickCount()
```
Returns the number of CPU ticks. The function returns the current number of CPU ticks on some architectures (such as x86, x64, PowerPC). On other platforms the function is equivalent to getTickCount. It can also be used for very accurate time measurements, as well as for RNG initialization. Note that in case of multi-CPU systems a thread, from which getCPUTickCount is called, can be suspended and resumed at another CPU with its own counter. So, theoretically (and practically) the subsequent calls to the function do not necessary return the monotonously increasing values. Also, since a modern CPU varies the CPU frequency depending on the load, the number of CPU clocks spent in some code cannot be directly converted to time units. Therefore, getTickCount is generally a preferable solution for measuring execution time.

Returns:

automatically generated

getTickCount
```
public static long getTickCount()
```
Returns the number of ticks. The function returns the number of ticks after the certain event (for example, when the machine was turned on). It can be used to initialize RNG or to measure a function execution time by reading the tick count before and after the function call. SEE: getTickFrequency, TickMeter

Returns:

automatically generated

getCPUFeaturesLine
```
public static String getCPUFeaturesLine()
```
Returns list of CPU features enabled during compilation. Returned value is a string containing space separated list of CPU features with following markers:
- no markers - baseline features
- prefix * - features enabled in dispatcher
- suffix ? - features enabled but not available in HW
Example: SSE SSE2 SSE3 *SSE4.1 *SSE4.2 *FP16 *AVX *AVX2 *AVX512-SKX?
Returns:

automatically generated

LUT
```
public static void LUT(Mat src,
                       Mat lut,
                       Mat dst)
```
Performs a look-up table transform of an array. The function LUT fills the output array with values from the look-up table. Indices of the entries are taken from the input array. That is, the function processes each element of src as follows: \(\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\) where \(d = \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\)

Parameters:

src - input array of 8-bit elements.

lut - look-up table of 256 elements; in case of multi-channel input array, the table should either have a single channel (in this case the same table is used for all channels) or the same number of channels as in the input array.

dst - output array of the same size and number of channels as src, and the same depth as lut. SEE: convertScaleAbs, Mat::convertTo

PCABackProject

public static void PCABackProject(Mat data,
                                  Mat mean,
                                  Mat eigenvectors,
                                  Mat result)

wrap PCA::backProject

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; result - automatically generated

PCACompute2

public static void PCACompute2(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues,
                               double retainedVariance)

wrap PCA::operator() and add eigenvalues output parameter

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; eigenvalues - automatically generated; retainedVariance - automatically generated

PCACompute2

public static void PCACompute2(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues,
                               int maxComponents)

wrap PCA::operator() and add eigenvalues output parameter

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; eigenvalues - automatically generated; maxComponents - automatically generated

PCACompute2

public static void PCACompute2(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues)

wrap PCA::operator() and add eigenvalues output parameter

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; eigenvalues - automatically generated

PCACompute

public static void PCACompute(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              double retainedVariance)

wrap PCA::operator()

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; retainedVariance - automatically generated

PCACompute

public static void PCACompute(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              int maxComponents)

wrap PCA::operator()

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; maxComponents - automatically generated

PCACompute

public static void PCACompute(Mat data,
                              Mat mean,
                              Mat eigenvectors)

wrap PCA::operator()

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated

PCAProject

public static void PCAProject(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              Mat result)

wrap PCA::project

Parameters:: data - automatically generated; mean - automatically generated; eigenvectors - automatically generated; result - automatically generated

SVBackSubst

public static void SVBackSubst(Mat w,
                               Mat u,
                               Mat vt,
                               Mat rhs,
                               Mat dst)

wrap SVD::backSubst

Parameters:: w - automatically generated; u - automatically generated; vt - automatically generated; rhs - automatically generated; dst - automatically generated

SVDecomp

public static void SVDecomp(Mat src,
                            Mat w,
                            Mat u,
                            Mat vt,
                            int flags)

wrap SVD::compute

Parameters:: src - automatically generated; w - automatically generated; u - automatically generated; vt - automatically generated; flags - automatically generated

SVDecomp

public static void SVDecomp(Mat src,
                            Mat w,
                            Mat u,
                            Mat vt)

wrap SVD::compute

Parameters:: src - automatically generated; w - automatically generated; u - automatically generated; vt - automatically generated

absdiff
```
public static void absdiff(Mat src1,
                           Mat src2,
                           Mat dst)
```
Calculates the per-element absolute difference between two arrays or between an array and a scalar. The function cv::absdiff calculates: Absolute difference between two arrays when they have the same size and type: \(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\) Absolute difference between an array and a scalar when the second array is constructed from Scalar or has as many elements as the number of channels in src1: \(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\) Absolute difference between a scalar and an array when the first array is constructed from Scalar or has as many elements as the number of channels in src2: \(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. Note: Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value in the case of overflow.

Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and type as input arrays. SEE: cv::abs(const Mat&)

absdiff

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

add
```
public static void add(Mat src1,
                       Mat src2,
                       Mat dst,
                       Mat mask,
                       int dtype)
```
Calculates the per-element sum of two arrays or an array and a scalar. The function add calculates:
- Sum of two arrays when both input arrays have the same size and the same number of channels: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
- Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
- Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.
The first function in the list above can be replaced with matrix expressions: dst = src1 + src2; dst += src1; // equivalent to add(dst, src1, dst); The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both. Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.
Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

mask - optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed.

dtype - optional depth of the output array (see the discussion below). SEE: subtract, addWeighted, scaleAdd, Mat::convertTo

add
```
public static void add(Mat src1,
                       Mat src2,
                       Mat dst,
                       Mat mask)
```
Calculates the per-element sum of two arrays or an array and a scalar. The function add calculates:
- Sum of two arrays when both input arrays have the same size and the same number of channels: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
- Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
- Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.
The first function in the list above can be replaced with matrix expressions: dst = src1 + src2; dst += src1; // equivalent to add(dst, src1, dst); The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both. Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.
Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

mask - optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed. SEE: subtract, addWeighted, scaleAdd, Mat::convertTo

add
```
public static void add(Mat src1,
                       Mat src2,
                       Mat dst)
```
Calculates the per-element sum of two arrays or an array and a scalar. The function add calculates:
- Sum of two arrays when both input arrays have the same size and the same number of channels: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
- Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
- Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.
The first function in the list above can be replaced with matrix expressions: dst = src1 + src2; dst += src1; // equivalent to add(dst, src1, dst); The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both. Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.
Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2. output array to be changed. SEE: subtract, addWeighted, scaleAdd, Mat::convertTo

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)

addWeighted
```
public static void addWeighted(Mat src1,
                               double alpha,
                               Mat src2,
                               double beta,
                               double gamma,
                               Mat dst,
                               int dtype)
```
Calculates the weighted sum of two arrays. The function addWeighted calculates the weighted sum of two arrays as follows: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression: dst = src1*alpha + src2*beta + gamma; Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

Parameters:

src1 - first input array.

alpha - weight of the first array elements.

src2 - second input array of the same size and channel number as src1.

beta - weight of the second array elements.

gamma - scalar added to each sum.

dst - output array that has the same size and number of channels as the input arrays.

dtype - optional depth of the output array; when both input arrays have the same depth, dtype can be set to -1, which will be equivalent to src1.depth(). SEE: add, subtract, scaleAdd, Mat::convertTo

addWeighted
```
public static void addWeighted(Mat src1,
                               double alpha,
                               Mat src2,
                               double beta,
                               double gamma,
                               Mat dst)
```
Calculates the weighted sum of two arrays. The function addWeighted calculates the weighted sum of two arrays as follows: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression: dst = src1*alpha + src2*beta + gamma; Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

Parameters:

src1 - first input array.

alpha - weight of the first array elements.

src2 - second input array of the same size and channel number as src1.

beta - weight of the second array elements.

gamma - scalar added to each sum.

dst - output array that has the same size and number of channels as the input arrays. can be set to -1, which will be equivalent to src1.depth(). SEE: add, subtract, scaleAdd, Mat::convertTo