@property (class, readonly) int SVD_MODIFY_A

class var SVD_MODIFY_A: Int32 { get }

@property (class, readonly) int SVD_NO_UV

class var SVD_NO_UV: Int32 { get }

@property (class, readonly) int SVD_FULL_UV

class var SVD_FULL_UV: Int32 { get }

@property (class, readonly) int FILLED

class var FILLED: Int32 { get }

@property (class, readonly) int REDUCE_SUM

class var REDUCE_SUM: Int32 { get }

@property (class, readonly) int REDUCE_AVG

class var REDUCE_AVG: Int32 { get }

@property (class, readonly) int REDUCE_MAX

class var REDUCE_MAX: Int32 { get }

@property (class, readonly) int REDUCE_MIN

class var REDUCE_MIN: Int32 { get }

@property (class, readonly) int RNG_UNIFORM

class var RNG_UNIFORM: Int32 { get }

@property (class, readonly) int RNG_NORMAL

class var RNG_NORMAL: Int32 { get }

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:

When all the mask elements are 0’s, the function returns Scalar::all(0)

+ (nonnull Scalar *)mean:(nonnull Mat *)src mask:(nonnull Mat *)mask;

class func mean(src: Mat, mask: Mat) -> Scalar

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:

When all the mask elements are 0’s, the function returns Scalar::all(0)

+ (nonnull Scalar *)mean:(nonnull Mat *)src;

class func mean(src: Mat) -> Scalar

Calculates the sum of array elements.

The function cv::sum calculates and returns the sum of array elements, independently for each channel.

+ (nonnull Scalar *)sumElems:(nonnull Mat *)src;

class func sum(src: Mat) -> Scalar

Returns the trace of a matrix.

The function cv::trace returns the sum of the diagonal elements of the matrix mtx .

+ (nonnull Scalar *)trace:(nonnull Mat *)mtx;

class func trace(mtx: Mat) -> Scalar

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.

+ (nonnull NSString *)getBuildInformation;

class func getBuildInformation() -> String

Returns feature name by ID

Returns empty string if feature is not defined

+ (nonnull NSString *)getHardwareFeatureName:(int)feature;

class func getHardwareFeatureName(feature: Int32) -> String

Returns library version string

For example “3.4.1-dev”.

+ (nonnull NSString *)getVersionString;

class func getVersionString() -> String

+ (NSString*)getIppVersion NS_SWIFT_NAME(getIppVersion());

class func getIppVersion() -> String

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.

+ (nonnull NSString *)findFile:(nonnull NSString *)relative_path
                      required:(BOOL)required
                    silentMode:(BOOL)silentMode;

class func findFile(relative_path: String, required: Bool, silentMode: Bool) -> String

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.

+ (nonnull NSString *)findFile:(nonnull NSString *)relative_path
                      required:(BOOL)required;

class func findFile(relative_path: String, required: Bool) -> String

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.

+ (nonnull NSString *)findFile:(nonnull NSString *)relative_path;

class func findFile(relative_path: String) -> String

+ (NSString*)findFileOrKeep:(NSString*)relative_path silentMode:(BOOL)silentMode NS_SWIFT_NAME(findFileOrKeep(relative_path:silentMode:));

class func findFileOrKeep(relative_path: String, silentMode: Bool) -> String

+ (NSString*)findFileOrKeep:(NSString*)relative_path NS_SWIFT_NAME(findFileOrKeep(relative_path:));

class func findFileOrKeep(relative_path: String) -> String

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.

+ (BOOL)checkRange:(nonnull Mat *)a
             quiet:(BOOL)quiet
            minVal:(double)minVal
            maxVal:(double)maxVal;

class func checkRange(a: Mat, quiet: Bool, minVal: Double, maxVal: Double) -> Bool

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.

+ (BOOL)checkRange:(nonnull Mat *)a quiet:(BOOL)quiet minVal:(double)minVal;

class func checkRange(a: Mat, quiet: Bool, minVal: Double) -> Bool

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.

+ (BOOL)checkRange:(nonnull Mat *)a quiet:(BOOL)quiet;

class func checkRange(a: Mat, quiet: Bool) -> Bool

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.

+ (BOOL)checkRange:(nonnull Mat *)a;

class func checkRange(a: Mat) -> Bool

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

+ (BOOL)eigen:(nonnull Mat *)src
     eigenvalues:(nonnull Mat *)eigenvalues
    eigenvectors:(nonnull Mat *)eigenvectors;

class func eigen(src: Mat, eigenvalues: Mat, eigenvectors: Mat) -> Bool

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

+ (BOOL)eigen:(nonnull Mat *)src eigenvalues:(nonnull Mat *)eigenvalues;

class func eigen(src: Mat, eigenvalues: Mat) -> Bool

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

If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or

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

+ (BOOL)solve:(nonnull Mat *)src1
         src2:(nonnull Mat *)src2
          dst:(nonnull Mat *)dst
        flags:(int)flags;

class func solve(src1: Mat, src2: Mat, dst: Mat, flags: Int32) -> Bool

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

If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or

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

+ (BOOL)solve:(nonnull Mat *)src1
         src2:(nonnull Mat *)src2
          dst:(nonnull Mat *)dst;

class func solve(src1: Mat, src2: Mat, dst: Mat) -> Bool

proxy for hal::Cholesky

+ (BOOL)useIPP;

class func useIPP() -> Bool

+ (BOOL)useIPP_NotExact NS_SWIFT_NAME(useIPP_NotExact());

class func useIPP_NotExact() -> Bool

Calculates the Mahalanobis distance between two vectors.

The function cv::Mahalanobis calculates and returns the weighted distance between two vectors:

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

+ (double)Mahalanobis:(nonnull Mat *)v1
                   v2:(nonnull Mat *)v2
               icovar:(nonnull Mat *)icovar;

class func Mahalanobis(v1: Mat, v2: Mat, icovar: Mat) -> Double

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:

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.

+ (double)PSNR:(nonnull Mat *)src1 src2:(nonnull Mat *)src2 R:(double)R;

class func PSNR(src1: Mat, src2: Mat, R: Double) -> Double

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:

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.

+ (double)PSNR:(nonnull Mat *)src1 src2:(nonnull Mat *)src2;

class func PSNR(src1: Mat, src2: Mat) -> Double

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.

+ (double)determinant:(nonnull Mat *)mtx;

class func determinant(mtx: Mat) -> Double

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();

+ (double)getTickFrequency;

class func getTickFrequency() -> Double

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.

+ (double)invert:(nonnull Mat *)src dst:(nonnull Mat *)dst flags:(int)flags;

class func invert(src: Mat, dst: Mat, flags: Int32) -> Double

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.

+ (double)invert:(nonnull Mat *)src dst:(nonnull Mat *)dst;

class func invert(src: Mat, dst: Mat) -> Double

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,

contains a 0-based cluster index for the sample stored in the row of the samples matrix.

@note

• (Python) An example on K-means clustering can be found at opencv_source_code/samples/python/kmeans.py
• Mat points(count, 2, CV_32F);
• Mat points(count, 1, CV_32FC2);
• Mat points(1, count, CV_32FC2);
• std::vector<cv::Point2f> points(sampleCount);

+ (double)kmeans:(nonnull Mat *)data
               K:(int)K
      bestLabels:(nonnull Mat *)bestLabels
        criteria:(nonnull TermCriteria *)criteria
        attempts:(int)attempts
           flags:(int)flags
         centers:(nonnull Mat *)centers;

class func kmeans(data: Mat, K: Int32, bestLabels: Mat, criteria: TermCriteria, attempts: Int32, flags: Int32, centers: Mat) -> Double

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,

contains a 0-based cluster index for the sample stored in the row of the samples matrix.

@note

• (Python) An example on K-means clustering can be found at opencv_source_code/samples/python/kmeans.py
• Mat points(count, 2, CV_32F);
• Mat points(count, 1, CV_32FC2);
• Mat points(1, count, CV_32FC2);
• std::vector<cv::Point2f> points(sampleCount);

+ (double)kmeans:(nonnull Mat *)data
               K:(int)K
      bestLabels:(nonnull Mat *)bestLabels
        criteria:(nonnull TermCriteria *)criteria
        attempts:(int)attempts
           flags:(int)flags;

class func kmeans(data: Mat, K: Int32, bestLabels: Mat, criteria: TermCriteria, attempts: Int32, flags: Int32) -> Double

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.

+ (double)norm:(nonnull Mat *)src1
          src2:(nonnull Mat *)src2
      normType:(NormTypes)normType
          mask:(nonnull Mat *)mask;

class func norm(src1: Mat, src2: Mat, normType: NormTypes, mask: Mat) -> Double

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.

+ (double)norm:(nonnull Mat *)src1
          src2:(nonnull Mat *)src2
      normType:(NormTypes)normType;

class func norm(src1: Mat, src2: Mat, normType: NormTypes) -> Double

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.

+ (double)norm:(nonnull Mat *)src1 src2:(nonnull Mat *)src2;

class func norm(src1: Mat, src2: Mat) -> Double

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

. The and norm for the sample value is calculated as follows and for the calculation is The following graphic shows all values for the three norm functions and . It is notable that the norm forms the upper and the norm forms the lower border for the example function .

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.

+ (double)norm:(nonnull Mat *)src1
      normType:(NormTypes)normType
          mask:(nonnull Mat *)mask;

class func norm(src1: Mat, normType: NormTypes, mask: Mat) -> Double

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

. The and norm for the sample value is calculated as follows and for the calculation is The following graphic shows all values for the three norm functions and . It is notable that the norm forms the upper and the norm forms the lower border for the example function .

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.

+ (double)norm:(nonnull Mat *)src1 normType:(NormTypes)normType;

class func norm(src1: Mat, normType: NormTypes) -> Double

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

. The and norm for the sample value is calculated as follows and for the calculation is The following graphic shows all values for the three norm functions and . It is notable that the norm forms the upper and the norm forms the lower border for the example function .

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.

+ (double)norm:(nonnull Mat *)src1;

class func norm(src1: Mat) -> Double

Finds the real or complex roots of a polynomial equation.

The function cv::solvePoly finds real and complex roots of a polynomial equation:

+ (double)solvePoly:(nonnull Mat *)coeffs
              roots:(nonnull Mat *)roots
           maxIters:(int)maxIters;

class func solvePoly(coeffs: Mat, roots: Mat, maxIters: Int32) -> Double

Finds the real or complex roots of a polynomial equation.

The function cv::solvePoly finds real and complex roots of a polynomial equation:

+ (double)solvePoly:(nonnull Mat *)coeffs roots:(nonnull Mat *)roots;

class func solvePoly(coeffs: Mat, roots: Mat) -> Double

Computes the cube root of an argument.

The function cubeRoot computes

. Negative arguments are handled correctly. NaN and Inf are not handled. The accuracy approaches the maximum possible accuracy for single-precision data.

+ (float)cubeRoot:(float)val;

class func cubeRoot(val: Float) -> Float

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.

+ (float)fastAtan2:(float)y x:(float)x;

class func fastAtan2(y: Float, x: Float) -> Float

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.

+ (int)borderInterpolate:(int)p len:(int)len borderType:(BorderTypes)borderType;

class func borderInterpolate(p: Int32, len: Int32, borderType: BorderTypes) -> Int32

Counts non-zero array elements.

The function returns the number of non-zero elements in src :

+ (int)countNonZero:(nonnull Mat *)src;

class func countNonZero(src: Mat) -> Int32

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.

+ (int)getNumThreads;

class func getNumThreads() -> Int32

Returns the number of logical CPUs available for the process.

+ (int)getNumberOfCPUs;

class func getNumberOfCPUs() -> Int32

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.

+ (int)getOptimalDFTSize:(int)vecsize;

class func getOptimalDFTSize(vecsize: Int32) -> Int32

Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.

@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.

+ (int)getThreadNum;

class func getThreadNum() -> Int32

Returns major library version

+ (int)getVersionMajor;

class func getVersionMajor() -> Int32

Returns minor library version

+ (int)getVersionMinor;

class func getVersionMinor() -> Int32

Returns revision field of the library version

+ (int)getVersionRevision;

class func getVersionRevision() -> Int32

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.

+ (int)solveCubic:(nonnull Mat *)coeffs roots:(nonnull Mat *)roots;

class func solveCubic(coeffs: Mat, roots: Mat) -> Int32

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.

+ (long)getCPUTickCount;

class func getCPUTickCount() -> Int

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.

+ (long)getTickCount;

class func getTickCount() -> Int

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?

+ (nonnull NSString *)getCPUFeaturesLine;

class func getCPUFeaturesLine() -> String

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:

where

+ (void)LUT:(nonnull Mat *)src lut:(nonnull Mat *)lut dst:(nonnull Mat *)dst;

class func LUT(src: Mat, lut: Mat, dst: Mat)

wrap PCA::backProject

+ (void)PCABackProject:(nonnull Mat *)data
                  mean:(nonnull Mat *)mean
          eigenvectors:(nonnull Mat *)eigenvectors
                result:(nonnull Mat *)result;

class func PCABackProject(data: Mat, mean: Mat, eigenvectors: Mat, result: Mat)

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

+ (void)PCACompute2:(nonnull Mat *)data
                mean:(nonnull Mat *)mean
        eigenvectors:(nonnull Mat *)eigenvectors
         eigenvalues:(nonnull Mat *)eigenvalues
    retainedVariance:(double)retainedVariance;

class func PCACompute(data: Mat, mean: Mat, eigenvectors: Mat, eigenvalues: Mat, retainedVariance: Double)

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

+ (void)PCACompute2:(nonnull Mat *)data
               mean:(nonnull Mat *)mean
       eigenvectors:(nonnull Mat *)eigenvectors
        eigenvalues:(nonnull Mat *)eigenvalues
      maxComponents:(int)maxComponents;

class func PCACompute(data: Mat, mean: Mat, eigenvectors: Mat, eigenvalues: Mat, maxComponents: Int32)

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

+ (void)PCACompute2:(nonnull Mat *)data
               mean:(nonnull Mat *)mean
       eigenvectors:(nonnull Mat *)eigenvectors
        eigenvalues:(nonnull Mat *)eigenvalues;

class func PCACompute(data: Mat, mean: Mat, eigenvectors: Mat, eigenvalues: Mat)

wrap PCA::operator()

+ (void)PCACompute:(nonnull Mat *)data
                mean:(nonnull Mat *)mean
        eigenvectors:(nonnull Mat *)eigenvectors
    retainedVariance:(double)retainedVariance;

class func PCACompute(data: Mat, mean: Mat, eigenvectors: Mat, retainedVariance: Double)

wrap PCA::operator()

+ (void)PCACompute:(nonnull Mat *)data
              mean:(nonnull Mat *)mean
      eigenvectors:(nonnull Mat *)eigenvectors
     maxComponents:(int)maxComponents;

class func PCACompute(data: Mat, mean: Mat, eigenvectors: Mat, maxComponents: Int32)

wrap PCA::operator()

+ (void)PCACompute:(nonnull Mat *)data
              mean:(nonnull Mat *)mean
      eigenvectors:(nonnull Mat *)eigenvectors;

class func PCACompute(data: Mat, mean: Mat, eigenvectors: Mat)

wrap PCA::project

+ (void)PCAProject:(nonnull Mat *)data
              mean:(nonnull Mat *)mean
      eigenvectors:(nonnull Mat *)eigenvectors
            result:(nonnull Mat *)result;

class func PCAProject(data: Mat, mean: Mat, eigenvectors: Mat, result: Mat)

wrap SVD::backSubst

+ (void)SVBackSubst:(nonnull Mat *)w
                  u:(nonnull Mat *)u
                 vt:(nonnull Mat *)vt
                rhs:(nonnull Mat *)rhs
                dst:(nonnull Mat *)dst;

class func SVBackSubst(w: Mat, u: Mat, vt: Mat, rhs: Mat, dst: Mat)

wrap SVD::compute

+ (void)SVDecomp:(nonnull Mat *)src
               w:(nonnull Mat *)w
               u:(nonnull Mat *)u
              vt:(nonnull Mat *)vt
           flags:(int)flags;

class func SVDecomp(src: Mat, w: Mat, u: Mat, vt: Mat, flags: Int32)

wrap SVD::compute

+ (void)SVDecomp:(nonnull Mat *)src
               w:(nonnull Mat *)w
               u:(nonnull Mat *)u
              vt:(nonnull Mat *)vt;

class func SVDecomp(src: Mat, w: Mat, u: Mat, vt: Mat)

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:

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: 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: where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

+ (void)absdiff:(nonnull Mat *)src1
           src2:(nonnull Mat *)src2
            dst:(nonnull Mat *)dst;

class func absdiff(src1: Mat, src2: Mat, dst: Mat)

+ (void)absdiff:(Mat*)src1 srcScalar:(Scalar*)srcScalar dst:(Mat*)dst NS_SWIFT_NAME(absdiff(src1:srcScalar:dst:));

class func absdiff(src1: Mat, srcScalar: Scalar, dst: Mat)

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.

+ (void)add:(nonnull Mat *)src1
       src2:(nonnull Mat *)src2
        dst:(nonnull Mat *)dst
       mask:(nonnull Mat *)mask
      dtype:(int)dtype;

class func add(src1: Mat, src2: Mat, dst: Mat, mask: Mat, dtype: Int32)

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.

+ (void)add:(nonnull Mat *)src1
       src2:(nonnull Mat *)src2
        dst:(nonnull Mat *)dst
       mask:(nonnull Mat *)mask;

class func add(src1: Mat, src2: Mat, dst: Mat, mask: Mat)

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.

+ (void)add:(nonnull Mat *)src1 src2:(nonnull Mat *)src2 dst:(nonnull Mat *)dst;

class func add(src1: Mat, src2: Mat, dst: Mat)

+ (void)add:(Mat*)src1 srcScalar:(Scalar*)srcScalar dst:(Mat*)dst mask:(Mat*)mask dtype:(int)dtype NS_SWIFT_NAME(add(src1:srcScalar:dst:mask:dtype:));

class func add(src1: Mat, srcScalar: Scalar, dst: Mat, mask: Mat, dtype: Int32)

+ (void)add:(Mat*)src1 srcScalar:(Scalar*)srcScalar dst:(Mat*)dst mask:(Mat*)mask NS_SWIFT_NAME(add(src1:srcScalar:dst:mask:));

class func add(src1: Mat, srcScalar: Scalar, dst: Mat, mask: Mat)

+ (void)add:(Mat*)src1 srcScalar:(Scalar*)srcScalar dst:(Mat*)dst NS_SWIFT_NAME(add(src1:srcScalar:dst:));

class func add(src1: Mat, srcScalar: Scalar, dst: Mat)

Calculates the weighted sum of two arrays.

The function addWeighted calculates the weighted sum of two arrays as follows:

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;

+ (void)addWeighted:(nonnull Mat *)src1
              alpha:(double)alpha
               src2:(nonnull Mat *)src2
               beta:(double)beta
              gamma:(double)gamma
                dst:(nonnull Mat *)dst
              dtype:(int)dtype;

class func addWeighted(src1: Mat, alpha: Double, src2: Mat, beta: Double, gamma: Double, dst: Mat, dtype: Int32)

Calculates the weighted sum of two arrays.

The function addWeighted calculates the weighted sum of two arrays as follows:

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;

+ (void)addWeighted:(nonnull Mat *)src1
              alpha:(double)alpha
               src2:(nonnull Mat *)src2
               beta:(double)beta
              gamma:(double)gamma
                dst:(nonnull Mat *)dst;

class func addWeighted(src1: Mat, alpha: Double, src2: Mat, beta: Double, gamma: Double, dst: Mat)

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document

+ (void)batchDistance:(nonnull Mat *)src1
                 src2:(nonnull Mat *)src2
                 dist:(nonnull Mat *)dist
                dtype:(int)dtype
                 nidx:(nonnull Mat *)nidx
             normType:(NormTypes)normType
                    K:(int)K
                 mask:(nonnull Mat *)mask
               update:(int)update
           crosscheck:(BOOL)crosscheck;

class func batchDistance(src1: Mat, src2: Mat, dist: Mat, dtype: Int32, nidx: Mat, normType: NormTypes, K: Int32, mask: Mat, update: Int32, crosscheck: Bool)

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document

+ (void)batchDistance:(nonnull Mat *)src1
                 src2:(nonnull Mat *)src2
                 dist:(nonnull Mat *)dist
                dtype:(int)dtype
                 nidx:(nonnull Mat *)nidx
             normType:(NormTypes)normType
                    K:(int)K
                 mask:(nonnull Mat *)mask
               update:(int)update;

class func batchDistance(src1: Mat, src2: Mat, dist: Mat, dtype: Int32, nidx: Mat, normType: NormTypes, K: Int32, mask: Mat, update: Int32)

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document

+ (void)batchDistance:(nonnull Mat *)src1
                 src2:(nonnull Mat *)src2
                 dist:(nonnull Mat *)dist
                dtype:(int)dtype
                 nidx:(nonnull Mat *)nidx
             normType:(NormTypes)normType
                    K:(int)K
                 mask:(nonnull Mat *)mask;

class func batchDistance(src1: Mat, src2: Mat, dist: Mat, dtype: Int32, nidx: Mat, normType: NormTypes, K: Int32, mask: Mat)

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document

+ (void)batchDistance:(nonnull Mat *)src1
                 src2:(nonnull Mat *)src2
                 dist:(nonnull Mat *)dist
                dtype:(int)dtype
                 nidx:(nonnull Mat *)nidx
             normType:(NormTypes)normType
                    K:(int)K;

class func batchDistance(src1: Mat, src2: Mat, dist: Mat, dtype: Int32, nidx: Mat, normType: NormTypes, K: Int32)

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document

+ (void)batchDistance:(nonnull Mat *)src1
                 src2:(nonnull Mat *)src2
                 dist:(nonnull Mat *)dist
                dtype:(int)dtype
                 nidx:(nonnull Mat *)nidx
             normType:(NormTypes)normType;

class func batchDistance(src1: Mat, src2: Mat, dist: Mat, dtype: Int32, nidx: Mat, normType: NormTypes)

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search TODO: document

+ (void)batchDistance:(nonnull Mat *)src1
                 src2:(nonnull Mat *)src2
                 dist:(nonnull Mat *)dist
                dtype:(int)dtype
                 nidx:(nonnull Mat *)nidx;

class func batchDistance(src1: Mat, src2: Mat, dist: Mat, dtype: Int32, nidx: Mat)

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.

The function cv::bitwise_and calculates the per-element bit-wise logical conjunction for: Two arrays when src1 and src2 have the same size:

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

+ (void)bitwise_and:(nonnull Mat *)src1
               src2:(nonnull Mat *)src2
                dst:(nonnull Mat *)dst
               mask:(nonnull Mat *)mask;

class func bitwise_and(src1: Mat, src2: Mat, dst: Mat, mask: Mat)