core library

Extension Types

ErrorCode
Float16P
MatType

Constants

CV_2PI → const double
CV_F32_MAX → const double
CV_F64_MAX → const double
CV_I16_MAX → const int
CV_I16_MIN → const int
CV_I32_MAX → const int
CV_I32_MIN → const int
CV_I8_MAX → const int
CV_I8_MIN → const int
CV_LOG2 → const double
CV_PI → const double
CV_U16_MAX → const int
CV_U16_MIN → const int
CV_U32_MAX → const int
CV_U32_MIN → const int
CV_U8_MAX → const int
CV_U8_MIN → const int
cvRunAsync → const Future<T> Function<T>(Pointer<CvStatus> func(CvCallback_0 callback), void onComplete(Completer<T> completer))
LOG_LEVEL_DEBUG → const int
LOG_LEVEL_ERROR → const int
LOG_LEVEL_FATAL → const int
LOG_LEVEL_INFO → const int
LOG_LEVEL_SILENT → const int
Constants for log levels
LOG_LEVEL_VERBOSE → const int
LOG_LEVEL_WARNING → const int

Functions

absDiff(Mat src1, Mat src2, {Mat? dst}) → Mat
AbsDiff calculates the per-element absolute difference between two arrays or between an array and a scalar.
absDiffAsync(Mat src1, Mat src2, {Mat? dst}) → Future<Mat>
AbsDiff calculates the per-element absolute difference between two arrays or between an array and a scalar.
add(Mat src1, Mat src2, {Mat? dst, int dtype = -1, Mat? mask}) → Mat
Add calculates the per-element sum of two arrays or an array and a scalar.
addAsync(Mat src1, Mat src2, {Mat? dst, int dtype = -1, Mat? mask}) → Future<Mat>
Add calculates the per-element sum of two arrays or an array and a scalar.
addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, {OutputArray? dst, int dtype = -1}) → Mat
AddWeighted calculates the weighted sum of two arrays.
addWeightedAsync(InputArray src1, double alpha, InputArray src2, double beta, double gamma, {OutputArray? dst, int dtype = -1}) → Future<Mat>
AddWeighted calculates the weighted sum of two arrays.
batchDistance(InputArray src1, InputArray src2, int dtype, {OutputArray? dist, OutputArray? nidx, int normType = NORM_L2, int K = 0, InputArray? mask, int update = 0, bool crosscheck = false}) → (Mat, Mat)
BatchDistance is a naive nearest neighbor finder.
batchDistanceAsync(InputArray src1, InputArray src2, int dtype, {OutputArray? dist, OutputArray? nidx, int normType = NORM_L2, int K = 0, InputArray? mask, int update = 0, bool crosscheck = false}) → Future<(Mat, Mat)>
BatchDistance is a naive nearest neighbor finder.
bitwiseAND(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask}) → Mat
BitwiseAnd 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.
bitwiseANDAsync(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask}) → Future<Mat>
BitwiseAnd 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.
bitwiseNOT(InputArray src, {OutputArray? dst, InputArray? mask}) → Mat
BitwiseNot inverts every bit of an array.
bitwiseNOTAsync(InputArray src, {OutputArray? dst, InputArray? mask}) → Future<Mat>
BitwiseNot inverts every bit of an array.
bitwiseOR(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask}) → Mat
BitwiseOr calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
bitwiseORAsync(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask}) → Future<Mat>
BitwiseOr calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
bitwiseXOR(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask}) → Mat
BitwiseXor calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
bitwiseXORAsync(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask}) → Future<Mat>
BitwiseXor calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
borderInterpolate(int p, int len, int borderType) → int
BorderInterpolate computes the source location of an extrapolated pixel.
borderInterpolateAsync(int p, int len, int borderType) → Future<int>
BorderInterpolate computes the source location of an extrapolated pixel.
calcCovarMatrix(InputArray samples, InputOutputArray mean, int flags, {OutputArray? covar, int ctype = MatType.CV_64F}) → (Mat, Mat)
CalcCovarMatrix calculates the covariance matrix of a set of vectors.
calcCovarMatrixAsync(InputArray samples, InputOutputArray mean, int flags, {OutputArray? covar, int ctype = MatType.CV_64F}) → Future<(Mat, Mat)>
CalcCovarMatrix calculates the covariance matrix of a set of vectors.
cartToPolar(InputArray x, InputArray y, {OutputArray? magnitude, OutputArray? angle, bool angleInDegrees = false}) → (Mat, Mat)
CartToPolar calculates the magnitude and angle of 2D vectors.
cartToPolarAsync(InputArray x, InputArray y, {OutputArray? magnitude, OutputArray? angle, bool angleInDegrees = false}) → Future<(Mat, Mat)>
CartToPolar calculates the magnitude and angle of 2D vectors.
checkRange(InputArray a, {bool quiet = true, double minVal = -CV_F64_MAX, double maxVal = CV_F64_MAX}) → (bool, Point)
CheckRange checks every element of an input array for invalid values.
checkRangeAsync(InputArray a, {bool quiet = true, double minVal = -CV_F64_MAX, double maxVal = CV_F64_MAX}) → Future<(bool, Point)>
CheckRange checks every element of an input array for invalid values.
compare(InputArray src1, InputArray src2, int cmpop, {OutputArray? dst}) → Mat
Compare performs the per-element comparison of two arrays or an array and scalar value.
compareAsync(InputArray src1, InputArray src2, int cmpop, {OutputArray? dst}) → Future<Mat>
Compare performs the per-element comparison of two arrays or an array and scalar value.
completeSymm(InputOutputArray m, {bool lowerToUpper = false}) → Mat
CompleteSymm copies the lower or the upper half of a square matrix to its another half.
completeSymmAsync(InputOutputArray m, {bool lowerToUpper = false}) → Future<Mat>
CompleteSymm copies the lower or the upper half of a square matrix to its another half.
convertScaleAbs(InputArray src, {OutputArray? dst, double alpha = 1, double beta = 0}) → Mat
ConvertScaleAbs scales, calculates absolute values, and converts the result to 8-bit.
convertScaleAbsAsync(InputArray src, {OutputArray? dst, double alpha = 1, double beta = 0}) → Future<Mat>
ConvertScaleAbs scales, calculates absolute values, and converts the result to 8-bit.
copyMakeBorder(InputArray src, int top, int bottom, int left, int right, int borderType, {OutputArray? dst, Scalar? value}) → Mat
CopyMakeBorder forms a border around an image (applies padding).
copyMakeBorderAsync(InputArray src, int top, int bottom, int left, int right, int borderType, {OutputArray? dst, Scalar? value}) → Future<Mat>
CopyMakeBorder forms a border around an image (applies padding).
copyTo(InputArray src, InputArray dst, {InputArray? mask}) → Mat
CopyTo
copyToAsync(InputArray src, InputArray dst, {InputArray? mask}) → Future<Mat>
CopyTo
countNonZero(Mat src) → int
CountNonZero counts non-zero array elements.
cvAssert(bool condition, [String? msg]) → void
cvRun(Pointer<CvStatus> func()) → void
cvRunArena<R>(R computation(Arena arena), [Allocator wrappedAllocator = calloc, bool keep = false]) → R
cvRunAsync0<T>(Pointer<CvStatus> func(CvCallback_0 callback), void onComplete(Completer<T> completer)) → Future<T>
cvRunAsync1<T>(Pointer<CvStatus> func(CvCallback_1 callback), void onComplete(Completer<T> completer, VoidPtr p)) → Future<T>
cvRunAsync2<T>(Pointer<CvStatus> func(CvCallback_2 callback), void onComplete(Completer<T> completer, VoidPtr p, VoidPtr p1)) → Future<T>
cvRunAsync3<T>(Pointer<CvStatus> func(CvCallback_3 callback), void onComplete(Completer<T> completer, VoidPtr p, VoidPtr p1, VoidPtr p2)) → Future<T>
cvRunAsync4<T>(Pointer<CvStatus> func(CvCallback_4 callback), void onComplete(Completer<T> completer, VoidPtr p, VoidPtr p1, VoidPtr p2, VoidPtr p3)) → Future<T>
cvRunAsync5<T>(Pointer<CvStatus> func(CvCallback_5 callback), void onComplete(Completer<T> completer, VoidPtr p, VoidPtr p1, VoidPtr p2, VoidPtr p3, VoidPtr p4)) → Future<T>
dct(InputArray src, {OutputArray? dst, int flags = 0}) → Mat
DCT performs a forward or inverse discrete Cosine transform of 1D or 2D array.
dctAsync(InputArray src, {OutputArray? dst, int flags = 0}) → Future<Mat>
DCT performs a forward or inverse discrete Cosine transform of 1D or 2D array.
determinant(InputArray mtx) → double
Determinant returns the determinant of a square floating-point matrix.
determinantAsync(InputArray mtx) → Future<double>
Determinant returns the determinant of a square floating-point matrix.
dft(InputArray src, {OutputArray? dst, int flags = 0, int nonzeroRows = 0}) → Mat
DFT performs a forward or inverse Discrete Fourier Transform (DFT) of a 1D or 2D floating-point array.
dftAsync(InputArray src, {OutputArray? dst, int flags = 0, int nonzeroRows = 0}) → Future<Mat>
DFT performs a forward or inverse Discrete Fourier Transform (DFT) of a 1D or 2D floating-point array.
divide(InputArray src1, InputArray src2, {OutputArray? dst, double scale = 1, int dtype = -1}) → Mat
Divide performs the per-element division on two arrays or an array and a scalar.
divideAsync(InputArray src1, InputArray src2, {OutputArray? dst, double scale = 1, int dtype = -1}) → Future<Mat>
Divide performs the per-element division on two arrays or an array and a scalar.
eigen(InputArray src, {OutputArray? eigenvalues, OutputArray? eigenvectors}) → (bool, Mat, Mat)
Eigen calculates eigenvalues and eigenvectors of a symmetric matrix.
eigenAsync(InputArray src, {OutputArray? eigenvalues, OutputArray? eigenvectors}) → Future<(bool, Mat, Mat)>
Eigen calculates eigenvalues and eigenvectors of a symmetric matrix.
eigenNonSymmetric(InputArray src, {OutputArray? eigenvalues, OutputArray? eigenvectors}) → (Mat, Mat)
EigenNonSymmetric calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
eigenNonSymmetricAsync(InputArray src, {OutputArray? eigenvalues, OutputArray? eigenvectors}) → Future<(Mat, Mat)>
EigenNonSymmetric calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
exp(InputArray src, {OutputArray? dst}) → Mat
Exp calculates the exponent of every array element.
expAsync(InputArray src, {OutputArray? dst}) → Future<Mat>
Exp calculates the exponent of every array element.
extractChannel(InputArray src, int coi, {OutputArray? dst}) → Mat
ExtractChannel extracts a single channel from src (coi is 0-based index).
extractChannelAsync(InputArray src, int coi, {OutputArray? dst}) → Future<Mat>
ExtractChannel extracts a single channel from src (coi is 0-based index).
findNonZero(InputArray src, {OutputArray? idx}) → Mat
FindNonZero returns the list of locations of non-zero pixels.
findNonZeroAsync(InputArray src, {OutputArray? idx}) → Future<Mat>
FindNonZero returns the list of locations of non-zero pixels.
flip(InputArray src, int flipCode, {OutputArray? dst}) → Mat
Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1).
flipAsync(InputArray src, int flipCode, {OutputArray? dst}) → Future<Mat>
Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1).
flipND(InputArray src, int axis, {OutputArray? dst}) → Mat
flipNDAsync(InputArray src, int axis, {OutputArray? dst}) → Future<Mat>
float16(int w) → double
float16Inv(double x) → int
gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, {OutputArray? dst, int flags = 0}) → Mat
Gemm performs generalized matrix multiplication.
gemmAsync(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, {OutputArray? dst, int flags = 0}) → Future<Mat>
Gemm performs generalized matrix multiplication.
getBuildInformation() → String
Returns full configuration time cmake output.
getLogLevel() → int
Gets the global logging level.
getNumThreads() → int
Get the number of threads for OpenCV.
getOptimalDFTSize(int vecsize) → int
GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size for a given vector size.
getOptimalDFTSizeAsync(int vecsize) → Future<int>
GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size for a given vector size.
getTickCount() → int
GetTickCount returns the number of ticks.
getTickFrequency() → double
GetTickFrequency returns the number of ticks per second.
hasNonZero(InputArray src) → bool
Checks for the presence of at least one non-zero array element.
hconcat(InputArray src1, InputArray src2, {OutputArray? dst}) → Mat
Hconcat applies horizontal concatenation to given matrices.
hconcatAsync(InputArray src1, InputArray src2, {OutputArray? dst}) → Future<Mat>
Hconcat applies horizontal concatenation to given matrices.
idct(InputArray src, {OutputArray? dst, int flags = 0}) → Mat
IDCT calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
idctAsync(InputArray src, {OutputArray? dst, int flags = 0}) → Future<Mat>
IDCT calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
idft(InputArray src, {OutputArray? dst, int flags = 0, int nonzeroRows = 0}) → Mat
IDFT calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
idftAsync(InputArray src, {OutputArray? dst, int flags = 0, int nonzeroRows = 0}) → Future<Mat>
IDFT calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
inRange(InputArray src, InputArray lowerb, InputArray upperb, {OutputArray? dst}) → Mat
InRange checks if array elements lie between the elements of two Mat arrays.
inRangeAsync(InputArray src, InputArray lowerb, InputArray upperb, {OutputArray? dst}) → Future<Mat>
InRange checks if array elements lie between the elements of two Mat arrays.
inRangebyScalar(InputArray src, Scalar lowerb, Scalar upperb, {OutputArray? dst}) → Mat
InRangeWithScalar checks if array elements lie between the elements of two Scalars
inRangebyScalarAsync(InputArray src, Scalar lowerb, Scalar upperb, {OutputArray? dst}) → Future<Mat>
InRangeWithScalar checks if array elements lie between the elements of two Scalars
insertChannel(InputArray src, InputOutputArray dst, int coi) → Mat
InsertChannel inserts a single channel to dst (coi is 0-based index) (it replaces channel i with another in dst).
insertChannelAsync(InputArray src, InputOutputArray dst, int coi) → Future<Mat>
InsertChannel inserts a single channel to dst (coi is 0-based index) (it replaces channel i with another in dst).
invert(InputArray src, {OutputArray? dst, int flags = DECOMP_LU}) → (double, Mat)
Invert finds the inverse or pseudo-inverse of a matrix.
invertAsync(InputArray src, {OutputArray? dst, int flags = DECOMP_LU}) → Future<(double, Mat)>
Invert finds the inverse or pseudo-inverse of a matrix.
kmeans(InputArray data, int K, InputOutputArray bestLabels, (int, int, double) criteria, int attempts, int flags, {OutputArray? centers}) → (double, Mat, Mat)
KMeans finds centers of clusters and groups input samples around the clusters.
kmeansAsync(InputArray data, int K, InputOutputArray bestLabels, (int, int, double) criteria, int attempts, int flags, {OutputArray? centers}) → Future<(double, Mat, Mat)>
KMeans finds centers of clusters and groups input samples around the clusters.
kmeansByPoints(VecPoint2f pts, int K, InputOutputArray bestLabels, (int, int, double) criteria, int attempts, int flags, {OutputArray? centers}) → (double, Mat, Mat)
KMeansPoints finds centers of clusters and groups input samples around the clusters.
kmeansByPointsAsync(VecPoint2f pts, int K, InputOutputArray bestLabels, (int, int, double) criteria, int attempts, int flags, {OutputArray? centers}) → Future<(double, Mat, Mat)>
KMeansPoints finds centers of clusters and groups input samples around the clusters.
log(InputArray src, {OutputArray? dst}) → Mat
Log calculates the natural logarithm of every array element.
logAsync(InputArray src, {OutputArray? dst}) → Future<Mat>
Log calculates the natural logarithm of every array element.
LUT(InputArray src, InputArray lut, {OutputArray? dst}) → Mat
Performs a look-up table transform of an array. Support CV_8U, CV_8S, CV_16U, CV_16S
LUTAsync(InputArray src, InputArray lut, {OutputArray? dst}) → Future<Mat>
Performs a look-up table transform of an array. Support CV_8U, CV_8S, CV_16U, CV_16S
magnitude(InputArray x, InputArray y, {OutputArray? magnitude}) → Mat
Magnitude calculates the magnitude of 2D vectors.
magnitudeAsync(InputArray x, InputArray y, {OutputArray? magnitude}) → Future<Mat>
Magnitude calculates the magnitude of 2D vectors.
max(InputArray src1, InputArray src2, {OutputArray? dst}) → Mat
Max calculates per-element maximum of two arrays or an array and a scalar.
maxAsync(InputArray src1, InputArray src2, {OutputArray? dst}) → Future<Mat>
Max calculates per-element maximum of two arrays or an array and a scalar.
mean(InputArray src, {InputArray? mask}) → Scalar
mean
meanStdDev(InputArray src, {InputArray? mask}) → (Scalar, Scalar)
MeanStdDev calculates a mean and standard deviation of array elements.
meanStdDevAsync(InputArray src, {InputArray? mask}) → Future<(Scalar, Scalar)>
MeanStdDev calculates a mean and standard deviation of array elements.
merge(VecMat mv, {OutputArray? dst}) → Mat
Merge creates one multi-channel array out of several single-channel ones.
mergeAsync(VecMat mv, {OutputArray? dst}) → Future<Mat>
Merge creates one multi-channel array out of several single-channel ones.
min(InputArray src1, InputArray src2, {OutputArray? dst}) → Mat
Min calculates per-element minimum of two arrays or an array and a scalar.
minAsync(InputArray src1, InputArray src2, {OutputArray? dst}) → Future<Mat>
Min calculates per-element minimum of two arrays or an array and a scalar.
minMaxIdx(InputArray src, {InputArray? mask}) → (double, double, int, int)
MinMaxIdx finds the global minimum and maximum in an array.
minMaxIdxAsync(InputArray src, {InputArray? mask}) → Future<(double, double, int, int)>
MinMaxIdx finds the global minimum and maximum in an array.
minMaxLoc(InputArray src, {InputArray? mask}) → (double, double, Point, Point)
MinMaxLoc finds the global minimum and maximum in an array.
minMaxLocAsync(InputArray src, {InputArray? mask}) → Future<(double, double, Point, Point)>
MinMaxLoc finds the global minimum and maximum in an array.
mixChannels(VecMat src, VecMat dst, VecI32 fromTo) → VecMat
Copies specified channels from input arrays to the specified channels of output arrays.
mixChannelsAsync(VecMat src, VecMat dst, VecI32 fromTo) → Future<VecMat>
Copies specified channels from input arrays to the specified channels of output arrays.
mulSpectrums(InputArray a, InputArray b, int flags, {OutputArray? c, bool conjB = false}) → Mat
Mulspectrums performs the per-element multiplication of two Fourier spectrums.
mulSpectrumsAsync(InputArray a, InputArray b, int flags, {OutputArray? c, bool conjB = false}) → Future<Mat>
Mulspectrums performs the per-element multiplication of two Fourier spectrums.
multiply(InputArray src1, InputArray src2, {OutputArray? dst, double scale = 1, int dtype = -1}) → Mat
Multiply calculates the per-element scaled product of two arrays. Both input arrays must be of the same size and the same type.
multiplyAsync(InputArray src1, InputArray src2, {OutputArray? dst, double scale = 1, int dtype = -1}) → Future<Mat>
Multiply calculates the per-element scaled product of two arrays. Both input arrays must be of the same size and the same type.
mulTransposed(InputArray src, OutputArray dst, bool aTa, {InputArray? delta, double scale = 1, int dtype = -1}) → Mat
mulTransposed
mulTransposedAsync(InputArray src, OutputArray dst, bool aTa, {InputArray? delta, double scale = 1, int dtype = -1}) → Future<Mat>
mulTransposed
norm(InputArray src1, {int normType = NORM_L2, InputArray? mask}) → double
Norm calculates the absolute norm of an array.
norm1(InputArray src1, InputArray src2, {int normType = NORM_L2, InputArray? mask}) → double
Norm calculates the absolute difference/relative norm of two arrays.
norm1Async(InputArray src1, InputArray src2, {int normType = NORM_L2, InputArray? mask}) → Future<double>
Norm calculates the absolute difference/relative norm of two arrays.
normalize(InputArray src, InputOutputArray dst, {double alpha = 1, double beta = 0, int normType = NORM_L2, int dtype = -1, InputArray? mask}) → Mat
Normalize normalizes the norm or value range of an array.
normalizeAsync(InputArray src, InputOutputArray dst, {double alpha = 1, double beta = 0, int normType = NORM_L2, int dtype = -1, InputArray? mask}) → Future<Mat>
Normalize normalizes the norm or value range of an array.
normAsync(InputArray src1, {int normType = NORM_L2, InputArray? mask}) → Future<double>
Norm calculates the absolute norm of an array.
OcvFinalizer<T extends NativeType>(NativeFinalizerFunctionT<T> func) → NativeFinalizer
openCvVersion() → String
get version
patchNaNs(InputArray a, double val) → Mat
patchNaNs
PCABackProject(InputArray data, InputArray mean, InputArray eigenvectors, {OutputArray? dst}) → Mat
https://docs.opencv.org/4.x/d2/de8/group__core__array.html#gab26049f30ee8e94f7d69d82c124faafc
PCABackProjectAsync(InputArray data, InputArray mean, InputArray eigenvectors, {OutputArray? dst}) → Future<Mat>
PCACompute(InputArray data, InputOutputArray mean, {OutputArray? eigenvectors, OutputArray? eigenvalues, int maxComponents = 0}) → (Mat, Mat, Mat)
PCACompute performs PCA.
PCACompute1(InputArray data, InputOutputArray mean, double retainedVariance, {OutputArray? eigenvectors, OutputArray? eigenvalues}) → (Mat, Mat, Mat)
PCACompute1Async(InputArray data, InputOutputArray mean, double retainedVariance, {OutputArray? eigenvectors, OutputArray? eigenvalues}) → Future<(Mat, Mat, Mat)>
PCAComputeAsync(InputArray data, InputOutputArray mean, {OutputArray? eigenvectors, OutputArray? eigenvalues, int maxComponents = 0}) → Future<(Mat, Mat, Mat)>
PCACompute performs PCA.
PCAProject(Mat data, Mat mean, Mat eigenvectors, {OutputArray? result}) → (Mat, Mat)
PCAProjectAsync(Mat data, Mat mean, Mat eigenvectors, {OutputArray? result}) → Future<(Mat, Mat)>
perspectiveTransform(InputArray src, InputArray m, {OutputArray? dst}) → Mat
PerspectiveTransform performs the perspective matrix transformation of vectors.
perspectiveTransformAsync(InputArray src, InputArray m, {OutputArray? dst}) → Future<Mat>
PerspectiveTransform performs the perspective matrix transformation of vectors.
phase(InputArray x, InputArray y, {OutputArray? angle, bool angleInDegrees = false}) → Mat
Phase calculates the rotation angle of 2D vectors.
phaseAsync(InputArray x, InputArray y, {OutputArray? angle, bool angleInDegrees = false}) → Future<Mat>
Phase calculates the rotation angle of 2D vectors.
polarToCart(InputArray magnitude, InputArray angle, {OutputArray? x, OutputArray? y, bool angleInDegrees = false}) → (Mat, Mat)
PolatToCart calculates x and y coordinates of 2D vectors from their magnitude and angle.
polarToCartAsync(InputArray magnitude, InputArray angle, {OutputArray? x, OutputArray? y, bool angleInDegrees = false}) → Future<(Mat, Mat)>
PolatToCart calculates x and y coordinates of 2D vectors from their magnitude and angle.
pow(InputArray src, double power, {OutputArray? dst}) → Mat
Pow raises every array element to a power.
powAsync(InputArray src, double power, {OutputArray? dst}) → Future<Mat>
Pow raises every array element to a power.
PSNR(InputArray src1, InputArray src2, {double R = 255.0}) → double
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
PSNRAsync(InputArray src1, InputArray src2, {double R = 255.0}) → Future<double>
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
randn(InputOutputArray dst, Scalar mean, Scalar stddev) → Mat
RandN Fills the array with normally distributed random numbers.
randnAsync(InputOutputArray dst, Scalar mean, Scalar stddev) → Future<Mat>
RandN Fills the array with normally distributed random numbers.
randShuffle(InputOutputArray dst, {double iterFactor = 1, Rng? rng}) → Mat
RandShuffle Shuffles the array elements randomly.
randShuffleAsync(InputOutputArray dst, {double iterFactor = 1, Rng? rng}) → Future<Mat>
RandShuffle Shuffles the array elements randomly.
randu(InputOutputArray dst, Scalar low, Scalar high) → Mat
RandU Generates a single uniformly-distributed random number or an array of random numbers.
randuAsync(InputOutputArray dst, Scalar low, Scalar high) → Future<Mat>
RandU Generates a single uniformly-distributed random number or an array of random numbers.
reduce(InputArray src, int dim, int rtype, {OutputArray? dst, int dtype = -1}) → Mat
Reduce reduces a matrix to a vector.
reduceArgMax(InputArray src, int axis, {OutputArray? dst, bool lastIndex = false}) → Mat
Finds indices of max elements along provided axis.
reduceArgMaxAsync(InputArray src, int axis, {OutputArray? dst, bool lastIndex = false}) → Future<Mat>
Finds indices of max elements along provided axis.
reduceArgMin(InputArray src, int axis, {OutputArray? dst, bool lastIndex = false}) → Mat
Finds indices of min elements along provided axis.
reduceArgMinAsync(InputArray src, int axis, {OutputArray? dst, bool lastIndex = false}) → Future<Mat>
Finds indices of min elements along provided axis.
reduceAsync(InputArray src, int dim, int rtype, {OutputArray? dst, int dtype = -1}) → Future<Mat>
Reduce reduces a matrix to a vector.
repeat(InputArray src, int ny, int nx, {OutputArray? dst}) → Mat
Repeat fills the output array with repeated copies of the input array.
repeatAsync(InputArray src, int ny, int nx, {OutputArray? dst}) → Future<Mat>
Repeat fills the output array with repeated copies of the input array.
rotate(InputArray src, int rotateCode, {OutputArray? dst}) → Mat
Rotate rotates a 2D array in multiples of 90 degrees
rotateAsync(InputArray src, int rotateCode, {OutputArray? dst}) → Future<Mat>
Rotate rotates a 2D array in multiples of 90 degrees
scaleAdd(InputArray src1, double alpha, InputArray src2, {OutputArray? dst}) → Mat
Calculates the sum of a scaled array and another array.
scaleAddAsync(InputArray src1, double alpha, InputArray src2, {OutputArray? dst}) → Future<Mat>
Calculates the sum of a scaled array and another array.
setIdentity(InputOutputArray mtx, {Scalar? s}) → Mat
SetIdentity initializes a scaled identity matrix. For further details, please see:
setIdentityAsync(InputOutputArray mtx, {Scalar? s}) → Future<Mat>
SetIdentity initializes a scaled identity matrix. For further details, please see:
setLogLevel(int logLevel) → void
Sets the global logging level.
setNumThreads(int n) → void
Set the number of threads for OpenCV.
solve(InputArray src1, InputArray src2, {OutputArray? dst, int flags = DECOMP_LU}) → (bool, Mat)
Solve solves one or more linear systems or least-squares problems.
solveAsync(InputArray src1, InputArray src2, {OutputArray? dst, int flags = DECOMP_LU}) → Future<(bool, Mat)>
Solve solves one or more linear systems or least-squares problems.
solveCubic(InputArray coeffs, {OutputArray? roots}) → (int, Mat)
SolveCubic finds the real roots of a cubic equation.
solveCubicAsync(InputArray coeffs, {OutputArray? roots}) → Future<(int, Mat)>
SolveCubic finds the real roots of a cubic equation.
solvePoly(InputArray coeffs, {OutputArray? roots, int maxIters = 300}) → (double, Mat)
SolvePoly finds the real or complex roots of a polynomial equation.
solvePolyAsync(InputArray coeffs, {OutputArray? roots, int maxIters = 300}) → Future<(double, Mat)>
SolvePoly finds the real or complex roots of a polynomial equation.
sort(InputArray src, int flags, {OutputArray? dst}) → Mat
Sort sorts each row or each column of a matrix.
sortAsync(InputArray src, int flags, {OutputArray? dst}) → Future<Mat>
Sort sorts each row or each column of a matrix.
sortIdx(InputArray src, int flags, {OutputArray? dst}) → Mat
SortIdx sorts each row or each column of a matrix. Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array
sortIdxAsync(InputArray src, int flags, {OutputArray? dst}) → Future<Mat>
SortIdx sorts each row or each column of a matrix. Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array
split(InputArray m) → VecMat
Split creates an array of single channel images from a multi-channel image Created images should be closed manualy to avoid memory leaks.
splitAsync(InputArray m) → Future<VecMat>
Split creates an array of single channel images from a multi-channel image Created images should be closed manualy to avoid memory leaks.
sqrt(Mat src, {Mat? dst}) → Mat
Calculates a square root of array elements.
sqrtAsync(Mat src, {Mat? dst}) → Future<Mat>
Calculates a square root of array elements.
subtract(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask, int dtype = -1}) → Mat
Subtract calculates the per-element subtraction of two arrays or an array and a scalar.
subtractAsync(InputArray src1, InputArray src2, {OutputArray? dst, InputArray? mask, int dtype = -1}) → Future<Mat>
Subtract calculates the per-element subtraction of two arrays or an array and a scalar.
sum(Mat src) → Scalar
Calculates the sum of array elements.
sumAsync(Mat src) → Future<Scalar>
Calculates the sum of array elements.
SVBackSubst(InputArray w, InputArray u, InputArray vh, InputArray rhs, {OutputArray? dst}) → Mat
SVBackSubst
SVDecomp(InputArray src, {OutputArray? w, OutputArray? u, OutputArray? vt, int flags = 0}) → (Mat, Mat, Mat)
SVDecomp
theRNG() → Rng
TheRNG Returns the default random number generator.
throwIfFailed(Pointer<CvStatus> s) → void
trace(InputArray mtx) → Scalar
Trace returns the trace of a matrix.
traceAsync(InputArray mtx) → Future<Scalar>
Trace returns the trace of a matrix.
transform(InputArray src, InputArray m, {OutputArray? dst}) → Mat
Transform performs the matrix transformation of every array element.
transformAsync(InputArray src, InputArray m, {OutputArray? dst}) → Future<Mat>
Transform performs the matrix transformation of every array element.
transpose(InputArray src, {OutputArray? dst}) → Mat
Transpose transposes a matrix.
transposeAsync(InputArray src, {OutputArray? dst}) → Future<Mat>
Transpose transposes a matrix.
transposeND(InputArray src, List<int> order, {OutputArray? dst}) → Mat
Transpose for n-dimensional matrices.
transposeNDAsync(InputArray src, List<int> order, {OutputArray? dst}) → Future<Mat>
Transpose for n-dimensional matrices.
vconcat(InputArray src1, InputArray src2, {OutputArray? dst}) → Mat
Vconcat applies vertical concatenation to given matrices.
vconcatAsync(InputArray src1, InputArray src2, {OutputArray? dst}) → Future<Mat>
Vconcat applies vertical concatenation to given matrices.

Exceptions / Errors

CvdException
CvException