core library

Classes

CvObject<T extends NativeType>
CvStruct<T extends Struct>
CvVec<T extends Struct>
DMatch
Float16List
ICvStruct<T extends Struct>
KeyPoint
Mat
Moments
struct returned by cv::moments
Point
Point2d
Point2f
Point3f
Point3i
Rect
Rect2f
Rng
RotatedRect
Scalar
Size
Size2f
SVD
SVDCompute decomposes matrix and stores the results to user-provided matrices
TermCriteria
TermCriteria is the criteria for iterative algorithms.
UMat
https://docs.opencv.org/4.x/d7/d45/classcv_1_1UMat.html#a25ac687266568c8b024debd187c15b9b
Vec<N extends Struct, T>
Vec2b
uchar
Vec2d
double
Vec2f
float
Vec2i
int
Vec2s
short
Vec2w
ushort
Vec3b
uchar
Vec3d
double
Vec3f
float
Vec3i
int
Vec3s
short
Vec3w
ushort
Vec4b
uchar
Vec4d
double
Vec4f
float
Vec4i
int
Vec4s
short
Vec4w
ushort
Vec6d
double
Vec6f
float
Vec6i
int
Vec8i
int
VecChar
VecCharIterator
VecDMatch
VecDMatchIterator
VecF16
VecF16Iterator
VecF32
VecF32Iterator
VecF64
VecF64Iterator
VecI16
VecI16Iterator
VecI32
VecI32Iterator
VecIterator<T>
VecKeyPoint
VecKeyPointIterator
VecMat
VecMatIterator
VecPoint
VecPoint2f
VecPoint2fIterator
VecPoint3f
VecPoint3fIterator
VecPoint3i
VecPoint3iIterator
VecPointIterator
VecRect
VecRect2f
VecRect2fIterator
VecRectIterator
VecU16
VecU16Iterator
VecUChar
VecUCharIterator
VecUnmodifible<N extends Struct, T>
VecVec4f
VecVec4fIterator
VecVec4i
VecVec4iIterator
VecVec6f
VecVec6fIterator
VecVecChar
VecVecCharIterator
VecVecDMatch
VecVecDMatchIterator
VecVecPoint
VecVecPoint2f
VecVecPoint2fIterator
VecVecPoint3f
VecVecPoint3fIterator
VecVecPointIterator

Extension Types

ErrorCode
Float16P
MatType

Constants

CV_2PI → const double
CV_CN_MAX → const int
CV_CN_SHIFT → const int
CV_DEPTH_MAX → const int
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_MAT_CN_MASK → const int
CV_MAT_CONT_FLAG → const int
CV_MAT_CONT_FLAG_SHIFT → const int
CV_MAT_TYPE_MASK → const int
CV_MAX_DIM → const int
CV_PI → const double
CV_SUBMAT_FLAG → const int
CV_SUBMAT_FLAG_SHIFT → const int
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))

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.
CV_IS_MAT_CONT(int flags) → bool
CV_IS_SUBMAT(int flags) → bool
CV_MAT_CN(int flags) → int
CV_MAT_TYPE(int flags) → int
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.
defaultLogCallback(LogLevel logLevel, String message) → void
defaultLogCallbackEx(LogLevel logLevel, String tag, String file, int line, String func, String message) → void
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() → LogLevel
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.
replaceWriteLogMessage({LogCallbackFunction? callback}) → void
replaceWriteLogMessageEx({LogCallbackExFunction? callback}) → void
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(LogLevel 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.
writeLogMessage(LogLevel logLevel, String message) → void
writeLogMessageEx(LogLevel logLevel, String message, {String? tag, String? file, int? line, String? func}) → void
Writes a log message.

Exceptions / Errors

CvdException
CvException