diff --git a/ffigen.yaml b/ffigen.yaml index 50e74e63..0fc4ad90 100644 --- a/ffigen.yaml +++ b/ffigen.yaml @@ -17,6 +17,7 @@ headers: - src/calib3d/calib3d.h - src/calib3d/calib3d_async.h - src/core/core.h + - src/core/core_async.h - src/core/exception.h - src/core/svd.h - src/core/svd_async.h @@ -51,6 +52,7 @@ headers: - src/calib3d/calib3d.h - src/calib3d/calib3d_async.h - src/core/core.h + - src/core/core_async.h - src/core/exception.h - src/core/svd.h - src/core/svd_async.h diff --git a/lib/opencv_dart.dart b/lib/opencv_dart.dart index 12133f60..2de504ac 100644 --- a/lib/opencv_dart.dart +++ b/lib/opencv_dart.dart @@ -13,17 +13,20 @@ export 'src/core/asyncarray.dart'; export 'src/core/base.dart'; export 'src/core/contours.dart'; export 'src/core/core.dart'; +export 'src/core/core_async.dart'; export 'src/core/cv_vec.dart'; export 'src/core/dmatch.dart'; export 'src/core/error_code.dart'; export 'src/core/exception.dart'; export 'src/core/keypoint.dart'; export 'src/core/mat.dart'; +export 'src/core/mat_async.dart'; export 'src/core/mat_type.dart'; export 'src/core/moments.dart'; export 'src/core/point.dart'; export 'src/core/rect.dart'; export 'src/core/rng.dart'; +export 'src/core/rng_async.dart'; export 'src/core/scalar.dart'; export 'src/core/size.dart'; export 'src/core/vec.dart'; diff --git a/lib/src/core/core.dart b/lib/src/core/core.dart index 45e46e90..c6059703 100644 --- a/lib/src/core/core.dart +++ b/lib/src/core/core.dart @@ -26,12 +26,6 @@ String openCvVersion() { return s; } -Future openCvVersionAsync() async => cvRunAsync(CFFI.openCVVersion_Async, (c, p) { - final s = p.cast>().value.toDartString(); - calloc.free(p); - c.complete(s); - }); - /// 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. @@ -43,12 +37,6 @@ String getBuildInformation() { return s; } -Future getBuildInformationAsync() async => cvRunAsync(CFFI.getBuildInfo_Async, (c, p) { - final s = p.cast>().value.toDartString(); - calloc.free(p); - c.complete(s); - }); - /// AbsDiff calculates the per-element absolute difference between two arrays /// or between an array and a scalar. /// diff --git a/lib/src/core/core_async.dart b/lib/src/core/core_async.dart new file mode 100644 index 00000000..0588c3c5 --- /dev/null +++ b/lib/src/core/core_async.dart @@ -0,0 +1,1029 @@ +// ignore_for_file: non_constant_identifier_names + +library cv; + +import 'dart:ffi' as ffi; + +import 'package:ffi/ffi.dart'; + +import '../constants.g.dart'; +import '../opencv.g.dart' as cvg; +import 'base.dart'; +import 'mat.dart'; +import 'mat_type.dart'; +import 'point.dart'; +import 'rng.dart'; +import 'scalar.dart'; +import 'termcriteria.dart'; +import 'vec.dart'; + +/// get version +Future openCvVersionAsync() async => cvRunAsync(CFFI.openCVVersion_Async, (c, p) { + final s = p.cast>().value.toDartString(); + calloc.free(p); + c.complete(s); + }); + +/// 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. +Future getBuildInformationAsync() async => cvRunAsync(CFFI.getBuildInfo_Async, (c, p) { + final s = p.cast>().value.toDartString(); + calloc.free(p); + c.complete(s); + }); + +/// AbsDiff calculates the per-element absolute difference between two arrays +/// or between an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6fef31bc8c4071cbc114a758a2b79c14 +Future absDiffAsync(Mat src1, Mat src2) async => cvRunAsync( + (callback) => CFFI.core_AbsDiff_Async(src1.ref, src2.ref, callback), + matCompleter, + ); + +/// Add calculates the per-element sum of two arrays or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga10ac1bfb180e2cfda1701d06c24fdbd6 +Future addAsync(Mat src1, Mat src2, {Mat? mask, int dtype = -1}) async => cvRunAsync( + (callback) => CFFI.core_Add_Async(src1.ref, src2.ref, mask?.ref ?? Mat.empty().ref, dtype, callback), + matCompleter, + ); + +/// AddWeighted calculates the weighted sum of two arrays. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gafafb2513349db3bcff51f54ee5592a19 +Future addWeightedAsync( + InputArray src1, + double alpha, + InputArray src2, + double beta, + double gamma, { + int dtype = -1, +}) async => + cvRunAsync( + (callback) => CFFI.core_AddWeighted_Async(src1.ref, alpha, src2.ref, beta, gamma, dtype, callback), + matCompleter, + ); + +/// 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. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga60b4d04b251ba5eb1392c34425497e14 +Future bitwiseANDAsync( + InputArray src1, + InputArray src2, { + InputArray? mask, +}) async => + cvRunAsync( + (callback) => mask == null + ? CFFI.core_BitwiseAnd_Async(src1.ref, src2.ref, callback) + : CFFI.core_BitwiseAndWithMask_Async(src1.ref, src2.ref, mask.ref, callback), + matCompleter, + ); + +/// BitwiseNot inverts every bit of an array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga0002cf8b418479f4cb49a75442baee2f +Future bitwiseNOTAsync(InputArray src, {InputArray? mask}) async => cvRunAsync( + (callback) => mask == null + ? CFFI.core_BitwiseNot_Async(src.ref, callback) + : CFFI.core_BitwiseNotWithMask_Async(src.ref, mask.ref, callback), + matCompleter, + ); + +/// BitwiseOr calculates the per-element bit-wise disjunction of two arrays +/// or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gab85523db362a4e26ff0c703793a719b4 +Future bitwiseORAsync(InputArray src1, InputArray src2, {InputArray? mask}) async => cvRunAsync( + (callback) => mask == null + ? CFFI.core_BitwiseOr_Async(src1.ref, src2.ref, callback) + : CFFI.core_BitwiseOrWithMask_Async(src1.ref, src2.ref, mask.ref, callback), + matCompleter, + ); + +/// BitwiseXor calculates the per-element bit-wise "exclusive or" operation +/// on two arrays or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga84b2d8188ce506593dcc3f8cd00e8e2c +Future bitwiseXORAsync(InputArray src1, InputArray src2, {InputArray? mask}) async => cvRunAsync( + (callback) => mask == null + ? CFFI.core_BitwiseXor_Async(src1.ref, src2.ref, callback) + : CFFI.core_BitwiseXorWithMask_Async(src1.ref, src2.ref, mask.ref, callback), + matCompleter, + ); + +/// BatchDistance is a naive nearest neighbor finder. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4ba778a1c57f83233b1d851c83f5a622 +Future<(Mat dist, Mat nidx)> batchDistanceAsync( + InputArray src1, + InputArray src2, + int dtype, { + int normType = NORM_L2, + int K = 0, + InputArray? mask, + int update = 0, + bool crosscheck = false, +}) async => + cvRunAsync2<(Mat, Mat)>( + (callback) => CFFI.core_BatchDistance_Async( + src1.ref, + src2.ref, + dtype, + normType, + K, + mask?.ref ?? Mat.empty().ref, + update, + crosscheck, + callback, + ), + matCompleter2, + ); + +/// BorderInterpolate computes the source location of an extrapolated pixel. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga247f571aa6244827d3d798f13892da58 +Future borderInterpolateAsync(int p, int len, int borderType) async => cvRunAsync( + (callback) => CFFI.core_BorderInterpolate_Async(p, len, borderType, callback), + intCompleter, + ); + +/// CalcCovarMatrix calculates the covariance matrix of a set of vectors. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga017122d912af19d7d0d2cccc2d63819f +Future<(Mat covar, Mat mean)> calcCovarMatrixAsync( + InputArray samples, + InputOutputArray mean, + int flags, { + int ctype = MatType.CV_64F, +}) async => + cvRunAsync<(Mat, Mat)>( + (callback) => CFFI.core_CalcCovarMatrix_Async( + samples.ref, + mean.ref, + flags, + ctype, + callback, + ), + (c, p) => c.complete((Mat.fromPointer(p.cast()), mean)), + ); + +/// CartToPolar calculates the magnitude and angle of 2D vectors. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gac5f92f48ec32cacf5275969c33ee837d +Future<(Mat magnitude, Mat angle)> cartToPolarAsync( + InputArray x, + InputArray y, { + bool angleInDegrees = false, +}) async => + cvRunAsync2<(Mat, Mat)>( + (callback) => CFFI.core_CartToPolar_Async( + x.ref, + y.ref, + angleInDegrees, + callback, + ), + matCompleter2, + ); + +/// CheckRange checks every element of an input array for invalid values. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga2bd19d89cae59361416736f87e3c7a64 +Future<(bool, Point)> checkRangeAsync( + InputArray a, { + bool quiet = true, + double minVal = -CV_F64_MAX, + double maxVal = CV_F64_MAX, +}) async => + cvRunAsync2((callback) => CFFI.core_CheckRange_Async(a.ref, quiet, minVal, maxVal, callback), + (completer, p, p1) { + final rval = p.cast().value; + calloc.free(p); + completer.complete((rval, Point.fromPointer(p1.cast()))); + }); + +/// Compare performs the per-element comparison of two arrays +/// or an array and scalar value. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga303cfb72acf8cbb36d884650c09a3a97 +Future compareAsync(InputArray src1, InputArray src2, int cmpop) async => + cvRunAsync((callback) => CFFI.core_Compare_Async(src1.ref, src2.ref, cmpop, callback), matCompleter); + +/// CountNonZero counts non-zero array elements. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa4b89393263bb4d604e0fe5986723914 +Future countNonZeroAsync(Mat src) async => + cvRunAsync((callback) => CFFI.core_CountNonZero_Async(src.ref, callback), intCompleter); + +/// CompleteSymm copies the lower or the upper half of a square matrix to its another half. +/// +/// For further details, please see: +/// https://docs.opencv.org/4.x/d2/de8/group__core__array.html#ga6847337c0c55769e115a70e0f011b5ca +Future completeSymmAsync(InputOutputArray m, {bool lowerToUpper = false}) async => cvRunAsync0( + (callback) => CFFI.core_CompleteSymm_Async(m.ref, lowerToUpper, callback), + (c) => c.complete(m), + ); + +/// ConvertScaleAbs scales, calculates absolute values, and converts the result to 8-bit. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3460e9c9f37b563ab9dd550c4d8c4e7d +Future convertScaleAbsAsync( + InputArray src, { + double alpha = 1, + double beta = 0, +}) async => + cvRunAsync((callback) => CFFI.core_ConvertScaleAbs_Async(src.ref, alpha, beta, callback), matCompleter); + +/// CopyMakeBorder forms a border around an image (applies padding). +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga2ac1049c2c3dd25c2b41bffe17658a36 +Future copyMakeBorderAsync( + InputArray src, + int top, + int bottom, + int left, + int right, + int borderType, { + Scalar? value, +}) async => + cvRunAsync( + (callback) => CFFI.core_CopyMakeBorder_Async( + src.ref, + top, + bottom, + left, + right, + borderType, + value?.ref ?? Scalar.default_().ref, + callback, + ), + matCompleter, + ); + +/// DCT performs a forward or inverse discrete Cosine transform of 1D or 2D array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga85aad4d668c01fbd64825f589e3696d4 +Future dctAsync(InputArray src, {int flags = 0}) async => + cvRunAsync((callback) => CFFI.core_DCT_Async(src.ref, flags, callback), matCompleter); + +/// Determinant returns the determinant of a square floating-point matrix. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf802bd9ca3e07b8b6170645ef0611d0c +Future determinantAsync(InputArray mtx) async => + cvRunAsync((callback) => CFFI.core_Determinant_Async(mtx.ref, callback), doubleCompleter); + +/// DFT performs a forward or inverse Discrete Fourier Transform (DFT) +/// of a 1D or 2D floating-point array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gadd6cf9baf2b8b704a11b5f04aaf4f39d +Future dftAsync( + InputArray src, { + int flags = 0, + int nonzeroRows = 0, +}) async => + cvRunAsync((callback) => CFFI.core_DFT_Async(src.ref, flags, nonzeroRows, callback), matCompleter); + +/// Divide performs the per-element division +/// on two arrays or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6db555d30115642fedae0cda05604874 +Future divideAsync( + InputArray src1, + InputArray src2, { + double scale = 1, + int dtype = -1, +}) async => + cvRunAsync( + (callback) => CFFI.core_Divide_Async(src1.ref, src2.ref, scale, dtype, callback), + matCompleter, + ); + +/// Eigen calculates eigenvalues and eigenvectors of a symmetric matrix. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9fa0d58657f60eaa6c71f6fbb40456e3 +Future<(bool ret, Mat eigenvalues, Mat eigenvectors)> eigenAsync(InputArray src) async => + cvRunAsync3((callback) => CFFI.core_Eigen_Async(src.ref, callback), (completer, p, p1, p2) { + final rval = p.cast().value; + calloc.free(p); + completer.complete((rval, Mat.fromPointer(p1.cast()), Mat.fromPointer(p2.cast()))); + }); + +/// EigenNonSymmetric calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only). +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf51987e03cac8d171fbd2b327cf966f6 +Future<(Mat eigenvalues, Mat eigenvectors)> eigenNonSymmetricAsync(InputArray src) async => cvRunAsync2( + (callback) => CFFI.core_EigenNonSymmetric_Async(src.ref, callback), + matCompleter2, + ); + +Future<(Mat mean, Mat result)> PCABackProjectAsync(Mat src, Mat mean, Mat eigenVectors) async => cvRunAsync( + (callback) => CFFI.core_PCABackProject_Async(src.ref, mean.ref, eigenVectors.ref, callback), + (completer, p) => completer.complete((mean, Mat.fromPointer(p.cast()))), + ); + +/// PCACompute performs PCA. +/// +/// The computed eigenvalues are sorted from the largest to the smallest and the corresponding +/// eigenvectors are stored as eigenvectors rows. +/// +/// Note: Calling with maxComponents == 0 (opencv default) will cause all components to be retained. +/// +/// For further details, please see: +/// https://docs.opencv.org/4.x/d2/de8/group__core__array.html#ga27a565b31d820b05dcbcd47112176b6e +Future<(Mat mean, Mat eigenvalues, Mat eigenvectors)> PCAComputeAsync( + InputArray data, + InputOutputArray mean, { + int maxComponents = 0, +}) async => + cvRunAsync2((callback) => CFFI.core_PCACompute_Async(data.ref, mean.ref, maxComponents, callback), + (completer, p, p1) { + completer.complete( + ( + mean, + Mat.fromPointer(p.cast()), + Mat.fromPointer(p1.cast()), + ), + ); + }); + +Future<(Mat mean, Mat eigenvectors)> PCACompute1Async( + InputArray data, + InputOutputArray mean, { + int maxComponents = 0, +}) async => + cvRunAsync( + (callback) => CFFI.core_PCACompute_1_Async(data.ref, mean.ref, maxComponents, callback), + (completer, p) => completer.complete((mean, Mat.fromPointer(p.cast()))), + ); + +Future<(Mat mean, Mat eigenvectors)> PCACompute2Async( + InputArray data, + InputOutputArray mean, { + double retainedVariance = 0, +}) async => + cvRunAsync( + (callback) => CFFI.core_PCACompute_3_Async(data.ref, mean.ref, retainedVariance, callback), + (completer, p) => completer.complete((mean, Mat.fromPointer(p.cast()))), + ); + +Future<(Mat mean, Mat eigenvalues, Mat eigenvectors)> PCACompute3Async( + InputArray data, + InputOutputArray mean, { + double retainedVariance = 0, +}) async => + cvRunAsync2( + (callback) => CFFI.core_PCACompute_2_Async(data.ref, mean.ref, retainedVariance, callback), + (completer, p, p1) => + completer.complete((mean, Mat.fromPointer(p.cast()), Mat.fromPointer(p1.cast()))), + ); + +Future<(Mat mean, Mat result)> PCAProjectAsync(InputArray src, InputArray mean, InputArray eigenVectors) => + cvRunAsync((callback) => CFFI.core_PCAProject_Async(src.ref, mean.ref, eigenVectors.ref, callback), + (completer, p) { + completer.complete((mean, Mat.fromPointer(p.cast()))); + }); + +/// Exp calculates the exponent of every array element. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3e10108e2162c338f1b848af619f39e5 +Future expAsync(InputArray src) async => + cvRunAsync((callback) => CFFI.core_Exp_Async(src.ref, callback), matCompleter); + +/// ExtractChannel extracts a single channel from src (coi is 0-based index). +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gacc6158574aa1f0281878c955bcf35642 +Future extractChannelAsync(InputArray src, int coi) async => + cvRunAsync((callback) => CFFI.core_ExtractChannel_Async(src.ref, coi, callback), matCompleter); + +/// FindNonZero returns the list of locations of non-zero pixels. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaed7df59a3539b4cc0fe5c9c8d7586190 +Future findNonZeroAsync(InputArray src) async => + cvRunAsync((callback) => CFFI.core_FindNonZero_Async(src.ref, callback), matCompleter); + +/// Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1). +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaca7be533e3dac7feb70fc60635adf441 +Future flipAsync(InputArray src, int flipCode) async => + cvRunAsync((callback) => CFFI.core_Flip_Async(src.ref, flipCode, callback), matCompleter); + +/// Gemm performs generalized matrix multiplication. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gacb6e64071dffe36434e1e7ee79e7cb35 +Future gemmAsync( + InputArray src1, + InputArray src2, + double alpha, + InputArray src3, + double beta, { + int flags = 0, +}) async => + cvRunAsync( + (callback) => CFFI.core_Gemm_Async(src1.ref, src2.ref, alpha, src3.ref, beta, flags, callback), + matCompleter, + ); + +/// GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size +/// for a given vector size. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6577a2e59968936ae02eb2edde5de299 +Future getOptimalDFTSizeAsync(int vecsize) async => + cvRunAsync((callback) => CFFI.core_GetOptimalDFTSize_Async(vecsize, callback), intCompleter); + +/// Hconcat applies horizontal concatenation to given matrices. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaab5ceee39e0580f879df645a872c6bf7 +Future hconcatAsync(InputArray src1, InputArray src2) async => + cvRunAsync((callback) => CFFI.core_Hconcat_Async(src1.ref, src2.ref, callback), matCompleter); + +/// Vconcat applies vertical concatenation to given matrices. +/// +/// For further details, please see: +/// https://docs.opencv.org/4.x/d2/de8/group__core__array.html#gaad07cede730cdde64b90e987aad179b8 +Future vconcatAsync(InputArray src1, InputArray src2) async => + cvRunAsync((callback) => CFFI.core_Vconcat_Async(src1.ref, src2.ref, callback), matCompleter); + +/// Rotate rotates a 2D array in multiples of 90 degrees +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4ad01c0978b0ce64baa246811deeac24 +Future rotateAsync(InputArray src, int rotateCode) async => + cvRunAsync((callback) => CFFI.core_Rotate_Async(src.ref, rotateCode, callback), matCompleter); + +/// IDCT calculates the inverse Discrete Cosine Transform of a 1D or 2D array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga77b168d84e564c50228b69730a227ef2 +Future idctAsync( + InputArray src, { + int flags = 0, +}) async => + cvRunAsync((callback) => CFFI.core_Idct_Async(src.ref, flags, callback), matCompleter); + +/// IDFT calculates the inverse Discrete Fourier Transform of a 1D or 2D array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa708aa2d2e57a508f968eb0f69aa5ff1 +Future idftAsync( + InputArray src, { + int flags = 0, + int nonzeroRows = 0, +}) async => + cvRunAsync((callback) => CFFI.core_Idft_Async(src.ref, flags, nonzeroRows, callback), matCompleter); + +/// InRange checks if array elements lie between the elements of two Mat arrays. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga48af0ab51e36436c5d04340e036ce981 +Future inRangeAsync( + InputArray src, + InputArray lowerb, + InputArray upperb, +) async => + cvRunAsync( + (callback) => CFFI.core_InRange_Async(src.ref, lowerb.ref, upperb.ref, callback), + matCompleter, + ); + +/// InRangeWithScalar checks if array elements lie between the elements of two Scalars +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga48af0ab51e36436c5d04340e036ce981 +Future inRangebyScalarAsync( + InputArray src, + Scalar lowerb, + Scalar upperb, +) async => + cvRunAsync( + (callback) => CFFI.core_InRangeWithScalar_Async(src.ref, lowerb.ref, upperb.ref, callback), + matCompleter, + ); + +/// InsertChannel inserts a single channel to dst (coi is 0-based index) +/// (it replaces channel i with another in dst). +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga1d4bd886d35b00ec0b764cb4ce6eb515 +Future insertChannelAsync(InputArray src, InputOutputArray dst, int coi) async => cvRunAsync0( + (callback) => CFFI.core_InsertChannel_Async(src.ref, dst.ref, coi, callback), + (c) => c.complete(dst), + ); + +/// Invert finds the inverse or pseudo-inverse of a matrix. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gad278044679d4ecf20f7622cc151aaaa2 +Future<(double rval, Mat dst)> invertAsync( + InputArray src, { + int flags = DECOMP_LU, +}) async => + cvRunAsync2<(double, Mat)>((callback) => CFFI.core_Invert_Async(src.ref, flags, callback), (c, p, p1) { + final rval = p.cast().value; + calloc.free(p); + c.complete((rval, Mat.fromPointer(p1.cast()))); + }); + +/// KMeans finds centers of clusters and groups input samples around the clusters. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d5/d38/group__core__cluster.html#ga9a34dc06c6ec9460e90860f15bcd2f88 +Future<(double rval, Mat bestLabels, Mat centers)> kmeansAsync( + InputArray data, + int K, + InputOutputArray bestLabels, + (int, int, double) criteria, + int attempts, + int flags, +) async => + cvRunAsync2( + (callback) => + CFFI.core_KMeans_Async(data.ref, K, bestLabels.ref, criteria.cvd.ref, attempts, flags, callback), + (completer, p, p1) { + final rval = p.cast().value; + calloc.free(p); + completer.complete((rval, bestLabels, Mat.fromPointer(p1.cast()))); + }); + +/// KMeansPoints finds centers of clusters and groups input samples around the clusters. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d5/d38/group__core__cluster.html#ga9a34dc06c6ec9460e90860f15bcd2f88 +Future<(double rval, Mat bestLabels, Mat centers)> kmeansByPointsAsync( + VecPoint2f pts, + int K, + InputOutputArray bestLabels, + (int, int, double) criteria, + int attempts, + int flags, +) async => + cvRunAsync2( + (callback) => CFFI.core_KMeans_Points_Async( + pts.ref, + K, + bestLabels.ref, + criteria.cvd.ref, + attempts, + flags, + callback, + ), (completer, p, p1) { + final rval = p.cast().value; + calloc.free(p); + completer.complete((rval, bestLabels, Mat.fromPointer(p1.cast()))); + }); + +/// Log calculates the natural logarithm of every array element. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga937ecdce4679a77168730830a955bea7 +Future logAsync(InputArray src) async => + cvRunAsync((callback) => CFFI.core_Log_Async(src.ref, callback), matCompleter); + +/// Performs a look-up table transform of an array. Support CV_8U, CV_8S, CV_16U, CV_16S +/// +/// The function LUT fills the output array with values from the look-up table. Indices of the entries +/// are taken from the input array. That is, the function processes each element of src as follows: +/// +/// $\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}$ +/// +/// where +/// +/// $d = \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}$ +/// +/// [src] input array of 8-bit elements. +/// [lut] look-up table of 256 elements; in case of multi-channel input array, the table should +/// either have a single channel (in this case the same table is used for all channels) or the same +/// number of channels as in the input array. +/// +/// https://docs.opencv.org/4.x/d2/de8/group__core__array.html#gab55b8d062b7f5587720ede032d34156f +Future LUTAsync(InputArray src, InputArray lut) async => + cvRunAsync((callback) => CFFI.core_LUT_Async(src.ref, lut.ref, callback), matCompleter); + +/// Magnitude calculates the magnitude of 2D vectors. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6d3b097586bca4409873d64a90fe64c3 +Future magnitudeAsync(InputArray x, InputArray y) async => + cvRunAsync((callback) => CFFI.core_Magnitude_Async(x.ref, y.ref, callback), matCompleter); + +/// Max calculates per-element maximum of two arrays or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gacc40fa15eac0fb83f8ca70b7cc0b588d +Future maxAsync(InputArray src1, InputArray src2) async => + cvRunAsync((callback) => CFFI.core_Max_Async(src1.ref, src2.ref, callback), matCompleter); + +/// MeanStdDev calculates a mean and standard deviation of array elements. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga846c858f4004d59493d7c6a4354b301d +Future<(Scalar mean, Scalar stddev)> meanStdDevAsync(InputArray src, {InputArray? mask}) async => cvRunAsync2( + (callback) => mask == null + ? CFFI.core_MeanStdDev_Async(src.ref, callback) + : CFFI.core_MeanStdDevWithMask_Async(src.ref, mask.ref, callback), + (c, p, p1) => + c.complete((Scalar.fromPointer(p.cast()), Scalar.fromPointer(p1.cast()))), + ); + +/// Merge creates one multi-channel array out of several single-channel ones. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7d7b4d6c6ee504b30a20b1680029c7b4 +Future mergeAsync(VecMat mv) async => + cvRunAsync((callback) => CFFI.core_Merge_Async(mv.ref, callback), matCompleter); + +/// Min calculates per-element minimum of two arrays or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9af368f182ee76d0463d0d8d5330b764 +Future minAsync(InputArray src1, InputArray src2) async => + cvRunAsync((callback) => CFFI.core_Min_Async(src1.ref, src2.ref, callback), matCompleter); + +/// MinMaxIdx finds the global minimum and maximum in an array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7622c466c628a75d9ed008b42250a73f +Future<(double minVal, double maxVal, int minIdx, int maxIdx)> minMaxIdxAsync( + InputArray src, { + InputArray? mask, +}) async => + cvRunAsync4( + (callback) => mask == null + ? CFFI.core_MinMaxIdx_Async(src.ref, callback) + : CFFI.core_MinMaxIdx_Mask_Async(src.ref, mask.ref, callback), (c, p, p1, p2, p3) { + final minv = p.cast().value; + calloc.free(p); + final maxv = p1.cast().value; + calloc.free(p1); + final mini = p2.cast().value; + calloc.free(p2); + final maxi = p3.cast().value; + calloc.free(p3); + c.complete((minv, maxv, mini, maxi)); + }); + +/// MinMaxLoc finds the global minimum and maximum in an array. +/// +/// For further details, please see: +/// https://docs.opencv.org/trunk/d2/de8/group__core__array.html#gab473bf2eb6d14ff97e89b355dac20707 +Future<(double minVal, double maxVal, Point minLoc, Point maxLoc)> minMaxLocAsync( + InputArray src, { + InputArray? mask, +}) async => + cvRunAsync4( + (callback) => mask == null + ? CFFI.core_MinMaxLoc_Async(src.ref, callback) + : CFFI.core_MinMaxLoc_Mask_Async(src.ref, mask.ref, callback), (c, p, p1, p2, p3) { + final minv = p.cast().value; + calloc.free(p); + final maxv = p1.cast().value; + calloc.free(p1); + c.complete((minv, maxv, Point.fromPointer(p2.cast()), Point.fromPointer(p3.cast()))); + }); + +/// Copies specified channels from input arrays to the specified channels of output arrays. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga51d768c270a1cdd3497255017c4504be +Future mixChannelsAsync(VecMat src, VecMat dst, VecInt fromTo) async => cvRunAsync0( + (callback) => CFFI.core_MixChannels_Async(src.ref, dst.ref, fromTo.ref, callback), + (c) => c.complete(dst), + ); + +/// Mulspectrums performs the per-element multiplication of two Fourier spectrums. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3ab38646463c59bf0ce962a9d51db64f +Future mulSpectrumsAsync( + InputArray a, + InputArray b, + int flags, { + bool conjB = false, +}) async => + cvRunAsync( + (callback) => CFFI.core_MulSpectrums_Async(a.ref, b.ref, flags, conjB, callback), + matCompleter, + ); + +/// Multiply calculates the per-element scaled product of two arrays. +/// Both input arrays must be of the same size and the same type. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga979d898a58d7f61c53003e162e7ad89f +Future multiplyAsync( + InputArray src1, + InputArray src2, { + double scale = 1, + int dtype = -1, +}) async => + cvRunAsync( + (callback) => CFFI.core_MultiplyWithParams_Async(src1.ref, src2.ref, scale, dtype, callback), + matCompleter, + ); + +/// Normalize normalizes the norm or value range of an array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga87eef7ee3970f86906d69a92cbf064bd +Future normalizeAsync( + InputArray src, + InputOutputArray dst, { + double alpha = 1, + double beta = 0, + int normType = NORM_L2, + int dtype = -1, + InputArray? mask, +}) async => + cvRunAsync0( + (callback) => mask == null + ? CFFI.core_Normalize_Async(src.ref, dst.ref, alpha, beta, normType, dtype, callback) + : CFFI.core_Normalize_Mask_Async( + src.ref, + dst.ref, + alpha, + beta, + normType, + dtype, + mask.ref, + callback, + ), + (c) => c.complete(dst), + ); + +/// Norm calculates the absolute norm of an array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7c331fb8dd951707e184ef4e3f21dd33 +Future normAsync( + InputArray src1, { + int normType = NORM_L2, + InputArray? mask, +}) async => + cvRunAsync( + (callback) => mask == null + ? CFFI.core_Norm_Async(src1.ref, normType, callback) + : CFFI.core_Norm_Mask_Async(src1.ref, normType, mask.ref, callback), + doubleCompleter, + ); + +/// Norm calculates the absolute difference/relative norm of two arrays. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7c331fb8dd951707e184ef4e3f21dd33 +Future norm1Async( + InputArray src1, + InputArray src2, { + int normType = NORM_L2, + // InputArray? mask, +}) async => + cvRunAsync( + (callback) => CFFI.core_NormWithMats_Async(src1.ref, src2.ref, normType, callback), + doubleCompleter, + ); + +/// PerspectiveTransform performs the perspective matrix transformation of vectors. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gad327659ac03e5fd6894b90025e6900a7 +Future perspectiveTransformAsync(InputArray src, InputArray m) async => + cvRunAsync((callback) => CFFI.core_PerspectiveTransform_Async(src.ref, m.ref, callback), matCompleter); + +/// Solve solves one or more linear systems or least-squares problems. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga12b43690dbd31fed96f213eefead2373 +Future<(bool ret, Mat dst)> solveAsync( + InputArray src1, + InputArray src2, { + int flags = DECOMP_LU, +}) async => + cvRunAsync2((callback) => CFFI.core_Solve_Async(src1.ref, src2.ref, flags, callback), (c, p, p1) { + final rval = p.cast().value; + calloc.free(p); + c.complete((rval, Mat.fromPointer(p1.cast()))); + }); + +/// SolveCubic finds the real roots of a cubic equation. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga1c3b0b925b085b6e96931ee309e6a1da +Future<(int rval, Mat roots)> solveCubicAsync(InputArray coeffs) async => + cvRunAsync2((callback) => CFFI.core_SolveCubic_Async(coeffs.ref, callback), (c, p, p1) { + final rval = p.cast().value; + calloc.free(p); + c.complete((rval, Mat.fromPointer(p1.cast()))); + }); + +/// SolvePoly finds the real or complex roots of a polynomial equation. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gac2f5e953016fabcdf793d762f4ec5dce +Future<(double rval, Mat roots)> solvePolyAsync( + InputArray coeffs, { + int maxIters = 300, +}) async => + cvRunAsync2((callback) => CFFI.core_SolvePoly_Async(coeffs.ref, maxIters, callback), (c, p, p1) { + final rval = p.cast().value; + calloc.free(p); + c.complete((rval, Mat.fromPointer(p1.cast()))); + }); + +/// Reduce reduces a matrix to a vector. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4b78072a303f29d9031d56e5638da78e +Future reduceAsync(InputArray src, int dim, int rtype, {int dtype = -1}) async => + cvRunAsync((callback) => CFFI.core_Reduce_Async(src.ref, dim, rtype, dtype, callback), matCompleter); + +/// Finds indices of max elements along provided axis. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa87ea34d99bcc5bf9695048355163da0 +Future reduceArgMaxAsync(InputArray src, int axis, {bool lastIndex = false}) async => + cvRunAsync((callback) => CFFI.core_ReduceArgMax_Async(src.ref, axis, lastIndex, callback), matCompleter); + +/// Finds indices of min elements along provided axis. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaeecd548276bfb91b938989e66b722088 +Future reduceArgMinAsync(InputArray src, int axis, {bool lastIndex = false}) async => + cvRunAsync((callback) => CFFI.core_ReduceArgMin_Async(src.ref, axis, lastIndex, callback), matCompleter); + +/// Repeat fills the output array with repeated copies of the input array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga496c3860f3ac44c40b48811333cfda2d +Future repeatAsync(InputArray src, int ny, int nx) async => + cvRunAsync((callback) => CFFI.core_Repeat_Async(src.ref, ny, nx, callback), matCompleter); + +/// Calculates the sum of a scaled array and another array. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9e0845db4135f55dcf20227402f00d98 +Future scaleAddAsync(InputArray src1, double alpha, InputArray src2) async => + cvRunAsync((callback) => CFFI.core_ScaleAdd_Async(src1.ref, alpha, src2.ref, callback), matCompleter); + +/// SetIdentity initializes a scaled identity matrix. +/// For further details, please see: +/// +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga388d7575224a4a277ceb98ccaa327c99 +Future setIdentityAsync(InputOutputArray mtx, {Scalar? s}) async => cvRunAsync0( + (callback) => CFFI.core_SetIdentity_Async(mtx.ref, s?.ref ?? Scalar.all(1).ref, callback), + (c) => c.complete(mtx), + ); + +/// Sort sorts each row or each column of a matrix. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga45dd56da289494ce874be2324856898f +Future sortAsync(InputArray src, int flags) async => + cvRunAsync((callback) => CFFI.core_Sort_Async(src.ref, flags, callback), matCompleter); + +/// 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 +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gadf35157cbf97f3cb85a545380e383506 +Future sortIdxAsync(InputArray src, int flags) async => + cvRunAsync((callback) => CFFI.core_SortIdx_Async(src.ref, flags, callback), matCompleter); + +/// Split creates an array of single channel images from a multi-channel image +/// Created images should be closed manualy to avoid memory leaks. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga0547c7fed86152d7e9d0096029c8518a +Future splitAsync(InputArray m) async => cvRunAsync( + (callback) => CFFI.core_Split_Async(m.ref, callback), + (c, p) => VecMat.fromPointer(p.cast()), + ); + +/// Subtract calculates the per-element subtraction of two arrays or an array and a scalar. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa0f00d98b4b5edeaeb7b8333b2de353b +Future subtractAsync( + InputArray src1, + InputArray src2, { + InputArray? mask, + int dtype = -1, +}) async => + cvRunAsync( + (callback) => + CFFI.core_Subtract_Async(src1.ref, src2.ref, mask?.ref ?? Mat.empty().ref, dtype, callback), + matCompleter, + ); + +/// Trace returns the trace of a matrix. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3419ac19c7dcd2be4bd552a23e147dd8 +Future traceAsync(InputArray mtx) async => + cvRunAsync((callback) => CFFI.core_Trace_Async(mtx.ref, callback), scalarCompleter); + +/// Transform performs the matrix transformation of every array element. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga393164aa54bb9169ce0a8cc44e08ff22 +Future transformAsync(InputArray src, InputArray m) async => + cvRunAsync((callback) => CFFI.core_Transform_Async(src.ref, m.ref, callback), matCompleter); + +/// Transpose transposes a matrix. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga46630ed6c0ea6254a35f447289bd7404 +Future transposeAsync(InputArray src) async => + cvRunAsync((callback) => CFFI.core_Transpose_Async(src.ref, callback), matCompleter); + +/// Pow raises every array element to a power. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf0d056b5bd1dc92500d6f6cf6bac41ef +Future powAsync(InputArray src, double power) async => + cvRunAsync((callback) => CFFI.core_Pow_Async(src.ref, power, callback), matCompleter); + +/// PolatToCart calculates x and y coordinates of 2D vectors from their magnitude and angle. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga581ff9d44201de2dd1b40a50db93d665 +Future<(Mat x, Mat y)> polarToCartAsync( + InputArray magnitude, + InputArray angle, { + bool angleInDegrees = false, +}) async => + cvRunAsync2( + (callback) => CFFI.core_PolarToCart_Async(magnitude.ref, angle.ref, angleInDegrees, callback), + matCompleter2, + ); + +/// Phase calculates the rotation angle of 2D vectors. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9db9ca9b4d81c3bde5677b8f64dc0137 +Future phaseAsync(InputArray x, InputArray y, {bool angleInDegrees = false}) async => + cvRunAsync((callback) => CFFI.core_Phase_Async(x.ref, y.ref, angleInDegrees, callback), matCompleter); + +/// RandN Fills the array with normally distributed random numbers. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaeff1f61e972d133a04ce3a5f81cf6808 +Future randnAsync(InputOutputArray dst, Scalar mean, Scalar stddev) async => cvRunAsync0( + (callback) => CFFI.RandN_Async(dst.ref, mean.ref, stddev.ref, callback), + (c) => c.complete(dst), + ); + +/// RandShuffle Shuffles the array elements randomly. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6a789c8a5cb56c6dd62506179808f763 +Future randShuffleAsync( + InputOutputArray dst, { + double iterFactor = 1, + Rng? rng, +}) async => + cvRunAsync0( + (callback) => rng == null + ? CFFI.RandShuffle_Async(dst.ref, callback) + : CFFI.RandShuffleWithParams_Async(dst.ref, iterFactor, rng.ref, callback), + (c) => c.complete(dst), + ); + +/// RandU Generates a single uniformly-distributed random +/// number or an array of random numbers. +/// +/// For further details, please see: +/// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga1ba1026dca0807b27057ba6a49d258c0 +Future randuAsync(InputOutputArray dst, Scalar low, Scalar high) async => cvRunAsync0( + (callback) => CFFI.RandU_Async(dst.ref, low.ref, high.ref, callback), + (c) => c.complete(dst), + ); diff --git a/lib/src/core/mat_async.dart b/lib/src/core/mat_async.dart new file mode 100644 index 00000000..fa4b6031 --- /dev/null +++ b/lib/src/core/mat_async.dart @@ -0,0 +1,107 @@ +import 'dart:async'; + +import 'package:opencv_dart/opencv_dart.dart'; + +extension MatAsync on Mat { + static Future emptyAsync() async => cvRunAsync(CFFI.Mat_New_Async, matCompleter); + + static Future fromScalarAsync(int rows, int cols, MatType type, Scalar s) async => cvRunAsync( + (callback) => CFFI.Mat_NewFromScalar_Async(s.ref, rows, cols, type.toInt32(), callback), + matCompleter, + ); + + static Future fromVecAsync(Vec vec) async { + if (vec is VecPoint) { + return cvRunAsync((callback) => CFFI.Mat_NewFromVecPoint_Async(vec.ref, callback), matCompleter); + } else if (vec is VecPoint2f) { + return cvRunAsync((callback) => CFFI.Mat_NewFromVecPoint2f_Async(vec.ref, callback), matCompleter); + } else if (vec is VecPoint3f) { + return cvRunAsync((callback) => CFFI.Mat_NewFromVecPoint3f_Async(vec.ref, callback), matCompleter); + } else { + throw UnsupportedError("Unsupported Vec type ${vec.runtimeType}"); + } + } + + static Future createAsync({ + int rows = 0, + int cols = 0, + int r = 0, + int g = 0, + int b = 0, + MatType? type, + }) async => + Mat.fromScalar( + rows, + cols, + type ?? MatType.CV_8UC3, + Scalar(b.toDouble(), g.toDouble(), r.toDouble(), 0), + ); + + static Future eyeAsync(int rows, int cols, MatType type) async => + cvRunAsync((callback) => CFFI.Mat_Eye_Async(rows, cols, type.toInt32(), callback), matCompleter); + + static Future zerosAsync(int rows, int cols, MatType type) async => + cvRunAsync((callback) => CFFI.Mat_Zeros_Async(rows, cols, type.toInt32(), callback), matCompleter); + + static Future onesAsync(int rows, int cols, MatType type) async => + cvRunAsync((callback) => CFFI.Mat_Ones_Async(rows, cols, type.toInt32(), callback), matCompleter); + + Future cloneAsync() async => + cvRunAsync((callback) => CFFI.Mat_Clone_Async(ref, callback), matCompleter); + + Future copyToAsync(Mat dst, {Mat? mask}) async => cvRunAsync0( + (callback) => mask == null + ? CFFI.Mat_CopyTo_Async(ref, dst.ref, callback) + : CFFI.Mat_CopyToWithMask_Async(ref, dst.ref, mask.ref, callback), + voidCompleter, + ); + + Future convertToAsync(MatType type, {double alpha = 1, double beta = 0}) async => cvRunAsync( + (callback) => CFFI.Mat_ConvertToWithParams_Async(ref, type.toInt32(), alpha, beta, callback), + matCompleter, + ); + + Future regionAsync(Rect rect) async => cvRunAsync( + (callback) => CFFI.Mat_Region_Async(ref, rect.ref, callback), + matCompleter, + ); + + Future reshapeAsync(int cn, int rows) async => cvRunAsync( + (callback) => CFFI.Mat_Reshape_Async(ref, cn, rows, callback), + matCompleter, + ); + + Future rotateAsync(int rotationCode) async => cvRunAsync( + (callback) => CFFI.core_Rotate_Async(ref, rotationCode, callback), + matCompleter, + ); + + Future rowRangeAsync(int start, int end) async => cvRunAsync( + (callback) => CFFI.core_rowRange_Async(ref, start, end, callback), + matCompleter, + ); + + Future colRangeAsync(int start, int end) async => cvRunAsync( + (callback) => CFFI.core_colRange_Async(ref, start, end, callback), + matCompleter, + ); + + Future meanAsync({Mat? mask}) async => cvRunAsync( + (callback) => mask == null + ? CFFI.core_Mean_Async(ref, callback) + : CFFI.core_MeanWithMask_Async(ref, mask.ref, callback), + scalarCompleter, + ); + + /// Calculates a square root of array elements. + Future sqrtAsync() async => + cvRunAsync((callback) => CFFI.core_Sqrt_Async(ref, callback), matCompleter); + + /// Sum calculates the per-channel pixel sum of an image. + Future sumAsync() async => + cvRunAsync((callback) => CFFI.core_Sum_Async(ref, callback), scalarCompleter); + + /// PatchNaNs converts NaN's to zeros. + Future patchNaNsAsync({double val = 0.0}) async => + cvRunAsync0((callback) => CFFI.core_PatchNaNs_Async(ref, val, callback), voidCompleter); +} diff --git a/lib/src/core/rng_async.dart b/lib/src/core/rng_async.dart new file mode 100644 index 00000000..2db6e707 --- /dev/null +++ b/lib/src/core/rng_async.dart @@ -0,0 +1,87 @@ +import 'dart:ffi' as ffi; + +import 'package:ffi/ffi.dart'; + +import '../opencv.g.dart' as cvg; +import 'base.dart'; +import 'mat.dart'; +import 'mat_async.dart'; +import 'rng.dart'; + +extension RngAsync on Rng { + static Future createAsync() async => cvRunAsync( + CFFI.Rng_New_Async, + (completer, p) => completer.complete(Rng.fromTheRng(p.cast())), + ); + + static Future fromSeedAsync(int seed) async => cvRunAsync( + (callback) => CFFI.Rng_NewWithState_Async(seed, callback), + (completer, p) => completer.complete(Rng.fromTheRng(p.cast())), + ); + + /// Fills arrays with random numbers. + /// https://docs.opencv.org/4.x/d1/dd6/classcv_1_1RNG.html#ad26f2b09d9868cf108e84c9814aa682d + Future fillAsync( + Mat mat, + int distType, + double a, + double b, { + bool saturateRange = false, + bool inplace = false, + }) async { + if (inplace) { + return cvRunAsync0( + (callback) => CFFI.RNG_Fill_Async(ref, mat.ref, distType, a, b, saturateRange, callback), + (c) => c.complete(mat), + ); + } else { + final m = await mat.cloneAsync(); + return cvRunAsync0( + (callback) => CFFI.RNG_Fill_Async(ref, m.ref, distType, a, b, saturateRange, callback), + (c) => c.complete(m), + ); + } + } + + /// The method transforms the state using the MWC algorithm and returns + /// the next random number from the Gaussian distribution N(0,sigma) . + /// That is, the mean value of the returned random numbers is zero and + /// the standard deviation is the specified sigma . + /// https://docs.opencv.org/4.x/d1/dd6/classcv_1_1RNG.html#a8df8ce4dc7d15916cee743e5a884639d + Future gaussianAsync(double sigma) async => cvRunAsync( + (callback) => CFFI.RNG_Gaussian_Async(ref, sigma, callback), + doubleCompleter, + ); + + /// The method updates the state using the MWC algorithm and returns the next 32-bit random number. + /// https://docs.opencv.org/4.x/d1/dd6/classcv_1_1RNG.html#ad8d035897a5e31e7fc3e1e6c378c32f5 + Future nextAsync() async => cvRunAsync( + (callback) => CFFI.RNG_Next_Async(ref, callback), + (c, p) { + final rval = p.cast().value; + calloc.free(p); + c.complete(rval); + }, + ); + + /// returns uniformly distributed integer random number from [a,b) range + /// The methods transform the state using the MWC algorithm and return the next + /// uniformly-distributed random number of the specified type, deduced from + /// the input parameter type, from the range [a, b) . + /// https://docs.opencv.org/4.x/d1/dd6/classcv_1_1RNG.html#a8325cc562269b47bcac2343639b6fafc + Future uniformAsync(T a, T b) async { + if (T == int) { + final rval = + cvRunAsync((callback) => CFFI.RNG_Uniform_Async(ref, a as int, b as int, callback), intCompleter); + return rval as Future; + } else if (T == double) { + final rval = cvRunAsync( + (callback) => CFFI.RNG_UniformDouble_Async(ref, a as double, b as double, callback), + doubleCompleter, + ); + return rval as Future; + } else { + throw UnsupportedError("Unsupported type $T"); + } + } +} diff --git a/lib/src/opencv.g.dart b/lib/src/opencv.g.dart index ef1d809c..adcd5cab 100644 --- a/lib/src/opencv.g.dart +++ b/lib/src/opencv.g.dart @@ -12900,6 +12900,23 @@ class CvNative { late final _Mat_Clone = _Mat_ClonePtr.asFunction< ffi.Pointer Function(Mat, ffi.Pointer)>(); + ffi.Pointer Mat_Clone_Async( + Mat self, + CvCallback_1 callback, + ) { + return _Mat_Clone_Async( + self, + callback, + ); + } + + late final _Mat_Clone_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'Mat_Clone_Async'); + late final _Mat_Clone_Async = _Mat_Clone_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, CvCallback_1)>(); + void Mat_Close( MatPtr m, ) { @@ -13059,6 +13076,50 @@ class CvNative { late final _Mat_ConvertToWithParams = _Mat_ConvertToWithParamsPtr.asFunction< ffi.Pointer Function(Mat, Mat, int, double, double)>(); + ffi.Pointer Mat_ConvertToWithParams_Async( + Mat self, + int type, + double alpha, + double beta, + CvCallback_1 callback, + ) { + return _Mat_ConvertToWithParams_Async( + self, + type, + alpha, + beta, + callback, + ); + } + + late final _Mat_ConvertToWithParams_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Int, ffi.Float, ffi.Float, + CvCallback_1)>>('Mat_ConvertToWithParams_Async'); + late final _Mat_ConvertToWithParams_Async = + _Mat_ConvertToWithParams_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, int, double, double, CvCallback_1)>(); + + ffi.Pointer Mat_ConvertTo_Async( + Mat self, + int type, + CvCallback_1 callback, + ) { + return _Mat_ConvertTo_Async( + self, + type, + callback, + ); + } + + late final _Mat_ConvertTo_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('Mat_ConvertTo_Async'); + late final _Mat_ConvertTo_Async = _Mat_ConvertTo_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, CvCallback_1)>(); + ffi.Pointer Mat_CopyMakeBorder( Mat src, Mat dst, @@ -13123,6 +13184,47 @@ class CvNative { late final _Mat_CopyToWithMask = _Mat_CopyToWithMaskPtr.asFunction< ffi.Pointer Function(Mat, Mat, Mat)>(); + ffi.Pointer Mat_CopyToWithMask_Async( + Mat self, + Mat dst, + Mat mask, + CvCallback_0 callback, + ) { + return _Mat_CopyToWithMask_Async( + self, + dst, + mask, + callback, + ); + } + + late final _Mat_CopyToWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_0)>>('Mat_CopyToWithMask_Async'); + late final _Mat_CopyToWithMask_Async = + _Mat_CopyToWithMask_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_0)>(); + + ffi.Pointer Mat_CopyTo_Async( + Mat self, + Mat dst, + CvCallback_0 callback, + ) { + return _Mat_CopyTo_Async( + self, + dst, + callback, + ); + } + + late final _Mat_CopyTo_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_0)>>('Mat_CopyTo_Async'); + late final _Mat_CopyTo_Async = _Mat_CopyTo_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, CvCallback_0)>(); + ffi.Pointer Mat_CountNonZero( Mat src, ffi.Pointer rval, @@ -13436,6 +13538,27 @@ class CvNative { late final _Mat_ExtractChannel = _Mat_ExtractChannelPtr.asFunction< ffi.Pointer Function(Mat, Mat, int)>(); + ffi.Pointer Mat_Eye_Async( + int rows, + int cols, + int type, + CvCallback_1 callback, + ) { + return _Mat_Eye_Async( + rows, + cols, + type, + callback, + ); + } + + late final _Mat_Eye_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Int, ffi.Int, ffi.Int, CvCallback_1)>>('Mat_Eye_Async'); + late final _Mat_Eye_Async = _Mat_Eye_AsyncPtr.asFunction< + ffi.Pointer Function(int, int, int, CvCallback_1)>(); + ffi.Pointer Mat_FindNonZero( Mat src, Mat idx, @@ -14952,6 +15075,37 @@ class CvNative { ffi.Pointer Function( int, int, int, ffi.Pointer, int, ffi.Pointer)>(); + ffi.Pointer Mat_NewFromBytes_Async( + int rows, + int cols, + int type, + ffi.Pointer buf, + int step, + CvCallback_1 callback, + ) { + return _Mat_NewFromBytes_Async( + rows, + cols, + type, + buf, + step, + callback, + ); + } + + late final _Mat_NewFromBytes_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Int, + ffi.Int, + ffi.Int, + ffi.Pointer, + ffi.Int, + CvCallback_1)>>('Mat_NewFromBytes_Async'); + late final _Mat_NewFromBytes_Async = _Mat_NewFromBytes_AsyncPtr.asFunction< + ffi.Pointer Function( + int, int, int, ffi.Pointer, int, CvCallback_1)>(); + ffi.Pointer Mat_NewFromScalar( Scalar ar, int type, @@ -14971,6 +15125,29 @@ class CvNative { late final _Mat_NewFromScalar = _Mat_NewFromScalarPtr.asFunction< ffi.Pointer Function(Scalar, int, ffi.Pointer)>(); + ffi.Pointer Mat_NewFromScalar_Async( + Scalar s, + int rows, + int cols, + int type, + CvCallback_1 callback, + ) { + return _Mat_NewFromScalar_Async( + s, + rows, + cols, + type, + callback, + ); + } + + late final _Mat_NewFromScalar_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Scalar, ffi.Int, ffi.Int, ffi.Int, + CvCallback_1)>>('Mat_NewFromScalar_Async'); + late final _Mat_NewFromScalar_Async = _Mat_NewFromScalar_AsyncPtr.asFunction< + ffi.Pointer Function(Scalar, int, int, int, CvCallback_1)>(); + ffi.Pointer Mat_NewFromVecPoint( VecPoint vec, ffi.Pointer rval, @@ -15005,6 +15182,23 @@ class CvNative { late final _Mat_NewFromVecPoint2f = _Mat_NewFromVecPoint2fPtr.asFunction< ffi.Pointer Function(VecPoint2f, ffi.Pointer)>(); + ffi.Pointer Mat_NewFromVecPoint2f_Async( + VecPoint2f vec, + CvCallback_1 callback, + ) { + return _Mat_NewFromVecPoint2f_Async( + vec, + callback, + ); + } + + late final _Mat_NewFromVecPoint2f_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + VecPoint2f, CvCallback_1)>>('Mat_NewFromVecPoint2f_Async'); + late final _Mat_NewFromVecPoint2f_Async = _Mat_NewFromVecPoint2f_AsyncPtr + .asFunction Function(VecPoint2f, CvCallback_1)>(); + ffi.Pointer Mat_NewFromVecPoint3f( VecPoint3f vec, ffi.Pointer rval, @@ -15022,6 +15216,40 @@ class CvNative { late final _Mat_NewFromVecPoint3f = _Mat_NewFromVecPoint3fPtr.asFunction< ffi.Pointer Function(VecPoint3f, ffi.Pointer)>(); + ffi.Pointer Mat_NewFromVecPoint3f_Async( + VecPoint3f vec, + CvCallback_1 callback, + ) { + return _Mat_NewFromVecPoint3f_Async( + vec, + callback, + ); + } + + late final _Mat_NewFromVecPoint3f_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + VecPoint3f, CvCallback_1)>>('Mat_NewFromVecPoint3f_Async'); + late final _Mat_NewFromVecPoint3f_Async = _Mat_NewFromVecPoint3f_AsyncPtr + .asFunction Function(VecPoint3f, CvCallback_1)>(); + + ffi.Pointer Mat_NewFromVecPoint_Async( + VecPoint vec, + CvCallback_1 callback, + ) { + return _Mat_NewFromVecPoint_Async( + vec, + callback, + ); + } + + late final _Mat_NewFromVecPoint_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + VecPoint, CvCallback_1)>>('Mat_NewFromVecPoint_Async'); + late final _Mat_NewFromVecPoint_Async = _Mat_NewFromVecPoint_AsyncPtr + .asFunction Function(VecPoint, CvCallback_1)>(); + ffi.Pointer Mat_NewWithSize( int rows, int cols, @@ -15068,6 +15296,27 @@ class CvNative { ffi.Pointer Function( Scalar, int, int, int, ffi.Pointer)>(); + ffi.Pointer Mat_NewWithSize_Async( + int rows, + int cols, + int type, + CvCallback_1 callback, + ) { + return _Mat_NewWithSize_Async( + rows, + cols, + type, + callback, + ); + } + + late final _Mat_NewWithSize_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Int, ffi.Int, ffi.Int, + CvCallback_1)>>('Mat_NewWithSize_Async'); + late final _Mat_NewWithSize_Async = _Mat_NewWithSize_AsyncPtr.asFunction< + ffi.Pointer Function(int, int, int, CvCallback_1)>(); + ffi.Pointer Mat_NewWithSizes( VecInt sizes, int type, @@ -15110,6 +15359,28 @@ class CvNative { ffi.Pointer Function( VecInt, int, VecChar, ffi.Pointer)>(); + ffi.Pointer Mat_NewWithSizesFromBytes_Async( + VecInt sizes, + int type, + VecChar buf, + CvCallback_1 callback, + ) { + return _Mat_NewWithSizesFromBytes_Async( + sizes, + type, + buf, + callback, + ); + } + + late final _Mat_NewWithSizesFromBytes_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(VecInt, ffi.Int, VecChar, + CvCallback_1)>>('Mat_NewWithSizesFromBytes_Async'); + late final _Mat_NewWithSizesFromBytes_Async = + _Mat_NewWithSizesFromBytes_AsyncPtr.asFunction< + ffi.Pointer Function(VecInt, int, VecChar, CvCallback_1)>(); + ffi.Pointer Mat_NewWithSizesFromScalar( VecInt sizes, int type, @@ -15133,6 +15404,61 @@ class CvNative { ffi.Pointer Function( VecInt, int, Scalar, ffi.Pointer)>(); + ffi.Pointer Mat_NewWithSizesScalar_Async( + VecInt sizes, + int type, + Scalar s, + CvCallback_1 callback, + ) { + return _Mat_NewWithSizesScalar_Async( + sizes, + type, + s, + callback, + ); + } + + late final _Mat_NewWithSizesScalar_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(VecInt, ffi.Int, Scalar, + CvCallback_1)>>('Mat_NewWithSizesScalar_Async'); + late final _Mat_NewWithSizesScalar_Async = + _Mat_NewWithSizesScalar_AsyncPtr.asFunction< + ffi.Pointer Function(VecInt, int, Scalar, CvCallback_1)>(); + + ffi.Pointer Mat_NewWithSizes_Async( + VecInt sizes, + int type, + CvCallback_1 callback, + ) { + return _Mat_NewWithSizes_Async( + sizes, + type, + callback, + ); + } + + late final _Mat_NewWithSizes_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + VecInt, ffi.Int, CvCallback_1)>>('Mat_NewWithSizes_Async'); + late final _Mat_NewWithSizes_Async = _Mat_NewWithSizes_AsyncPtr.asFunction< + ffi.Pointer Function(VecInt, int, CvCallback_1)>(); + + ffi.Pointer Mat_New_Async( + CvCallback_1 callback, + ) { + return _Mat_New_Async( + callback, + ); + } + + late final _Mat_New_AsyncPtr = + _lookup Function(CvCallback_1)>>( + 'Mat_New_Async'); + late final _Mat_New_Async = _Mat_New_AsyncPtr.asFunction< + ffi.Pointer Function(CvCallback_1)>(); + ffi.Pointer Mat_Normalize( Mat src, Mat dst, @@ -15156,6 +15482,27 @@ class CvNative { late final _Mat_Normalize = _Mat_NormalizePtr.asFunction< ffi.Pointer Function(Mat, Mat, double, double, int)>(); + ffi.Pointer Mat_Ones_Async( + int rows, + int cols, + int type, + CvCallback_1 callback, + ) { + return _Mat_Ones_Async( + rows, + cols, + type, + callback, + ); + } + + late final _Mat_Ones_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Int, ffi.Int, ffi.Int, CvCallback_1)>>('Mat_Ones_Async'); + late final _Mat_Ones_Async = _Mat_Ones_AsyncPtr.asFunction< + ffi.Pointer Function(int, int, int, CvCallback_1)>(); + ffi.Pointer Mat_PCACompute( Mat src, Mat mean, @@ -15821,6 +16168,25 @@ class CvNative { late final _Mat_Region = _Mat_RegionPtr.asFunction< ffi.Pointer Function(Mat, Rect, ffi.Pointer)>(); + ffi.Pointer Mat_Region_Async( + Mat self, + Rect r, + CvCallback_1 callback, + ) { + return _Mat_Region_Async( + self, + r, + callback, + ); + } + + late final _Mat_Region_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Rect, CvCallback_1)>>('Mat_Region_Async'); + late final _Mat_Region_Async = _Mat_Region_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Rect, CvCallback_1)>(); + ffi.Pointer Mat_Release( ffi.Pointer m, ) { @@ -15877,9 +16243,30 @@ class CvNative { late final _Mat_Reshape = _Mat_ReshapePtr.asFunction< ffi.Pointer Function(Mat, int, int, ffi.Pointer)>(); - ffi.Pointer Mat_Rows( - Mat m, - ffi.Pointer rval, + ffi.Pointer Mat_Reshape_Async( + Mat self, + int cn, + int rows, + CvCallback_1 callback, + ) { + return _Mat_Reshape_Async( + self, + cn, + rows, + callback, + ); + } + + late final _Mat_Reshape_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, ffi.Int, CvCallback_1)>>('Mat_Reshape_Async'); + late final _Mat_Reshape_Async = _Mat_Reshape_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, CvCallback_1)>(); + + ffi.Pointer Mat_Rows( + Mat m, + ffi.Pointer rval, ) { return _Mat_Rows( m, @@ -17031,6 +17418,23 @@ class CvNative { late final _Mat_ToVecChar = _Mat_ToVecCharPtr.asFunction< ffi.Pointer Function(Mat, ffi.Pointer)>(); + ffi.Pointer Mat_ToVecChar_Async( + Mat self, + CvCallback_1 callback, + ) { + return _Mat_ToVecChar_Async( + self, + callback, + ); + } + + late final _Mat_ToVecChar_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'Mat_ToVecChar_Async'); + late final _Mat_ToVecChar_Async = _Mat_ToVecChar_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, CvCallback_1)>(); + ffi.Pointer Mat_ToVecUChar( Mat m, ffi.Pointer rval, @@ -17048,6 +17452,23 @@ class CvNative { late final _Mat_ToVecUChar = _Mat_ToVecUCharPtr.asFunction< ffi.Pointer Function(Mat, ffi.Pointer)>(); + ffi.Pointer Mat_ToVecUChar_Async( + Mat self, + CvCallback_1 callback, + ) { + return _Mat_ToVecUChar_Async( + self, + callback, + ); + } + + late final _Mat_ToVecUChar_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'Mat_ToVecUChar_Async'); + late final _Mat_ToVecUChar_Async = _Mat_ToVecUChar_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, CvCallback_1)>(); + ffi.Pointer Mat_Total( Mat m, ffi.Pointer rval, @@ -17151,6 +17572,27 @@ class CvNative { late final _Mat_Vconcat = _Mat_VconcatPtr.asFunction< ffi.Pointer Function(Mat, Mat, Mat)>(); + ffi.Pointer Mat_Zeros_Async( + int rows, + int cols, + int type, + CvCallback_1 callback, + ) { + return _Mat_Zeros_Async( + rows, + cols, + type, + callback, + ); + } + + late final _Mat_Zeros_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Int, ffi.Int, ffi.Int, CvCallback_1)>>('Mat_Zeros_Async'); + late final _Mat_Zeros_Async = _Mat_Zeros_AsyncPtr.asFunction< + ffi.Pointer Function(int, int, int, CvCallback_1)>(); + ffi.Pointer Mat_colRange( Mat m, int start, @@ -20564,6 +21006,34 @@ class CvNative { late final _RNG_Fill = _RNG_FillPtr.asFunction< ffi.Pointer Function(RNG, Mat, int, double, double, bool)>(); + ffi.Pointer RNG_Fill_Async( + RNG rng, + Mat mat, + int distType, + double a, + double b, + bool saturateRange, + CvCallback_0 callback, + ) { + return _RNG_Fill_Async( + rng, + mat, + distType, + a, + b, + saturateRange, + callback, + ); + } + + late final _RNG_Fill_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(RNG, Mat, ffi.Int, ffi.Double, + ffi.Double, ffi.Bool, CvCallback_0)>>('RNG_Fill_Async'); + late final _RNG_Fill_Async = _RNG_Fill_AsyncPtr.asFunction< + ffi.Pointer Function( + RNG, Mat, int, double, double, bool, CvCallback_0)>(); + ffi.Pointer RNG_Gaussian( RNG rng, double sigma, @@ -20583,6 +21053,25 @@ class CvNative { late final _RNG_Gaussian = _RNG_GaussianPtr.asFunction< ffi.Pointer Function(RNG, double, ffi.Pointer)>(); + ffi.Pointer RNG_Gaussian_Async( + RNG rng, + double sigma, + CvCallback_1 callback, + ) { + return _RNG_Gaussian_Async( + rng, + sigma, + callback, + ); + } + + late final _RNG_Gaussian_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + RNG, ffi.Double, CvCallback_1)>>('RNG_Gaussian_Async'); + late final _RNG_Gaussian_Async = _RNG_Gaussian_AsyncPtr.asFunction< + ffi.Pointer Function(RNG, double, CvCallback_1)>(); + ffi.Pointer RNG_Next( RNG rng, ffi.Pointer rval, @@ -20600,6 +21089,22 @@ class CvNative { late final _RNG_Next = _RNG_NextPtr.asFunction< ffi.Pointer Function(RNG, ffi.Pointer)>(); + ffi.Pointer RNG_Next_Async( + RNG rng, + CvCallback_1 callback, + ) { + return _RNG_Next_Async( + rng, + callback, + ); + } + + late final _RNG_Next_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(RNG, CvCallback_1)>>('RNG_Next_Async'); + late final _RNG_Next_Async = _RNG_Next_AsyncPtr.asFunction< + ffi.Pointer Function(RNG, CvCallback_1)>(); + ffi.Pointer RNG_Uniform( RNG rng, int a, @@ -20643,6 +21148,48 @@ class CvNative { ffi.Pointer Function( RNG, double, double, ffi.Pointer)>(); + ffi.Pointer RNG_UniformDouble_Async( + RNG rng, + double a, + double b, + CvCallback_1 callback, + ) { + return _RNG_UniformDouble_Async( + rng, + a, + b, + callback, + ); + } + + late final _RNG_UniformDouble_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(RNG, ffi.Double, ffi.Double, + CvCallback_1)>>('RNG_UniformDouble_Async'); + late final _RNG_UniformDouble_Async = _RNG_UniformDouble_AsyncPtr.asFunction< + ffi.Pointer Function(RNG, double, double, CvCallback_1)>(); + + ffi.Pointer RNG_Uniform_Async( + RNG rng, + int a, + int b, + CvCallback_1 callback, + ) { + return _RNG_Uniform_Async( + rng, + a, + b, + callback, + ); + } + + late final _RNG_Uniform_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + RNG, ffi.Int, ffi.Int, CvCallback_1)>>('RNG_Uniform_Async'); + late final _RNG_Uniform_Async = _RNG_Uniform_AsyncPtr.asFunction< + ffi.Pointer Function(RNG, int, int, CvCallback_1)>(); + ffi.Pointer RandN( Mat mat, Scalar mean, @@ -20661,6 +21208,27 @@ class CvNative { late final _RandN = _RandNPtr.asFunction< ffi.Pointer Function(Mat, Scalar, Scalar)>(); + ffi.Pointer RandN_Async( + Mat mat, + Scalar mean, + Scalar stddev, + CvCallback_0 callback, + ) { + return _RandN_Async( + mat, + mean, + stddev, + callback, + ); + } + + late final _RandN_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Scalar, Scalar, CvCallback_0)>>('RandN_Async'); + late final _RandN_Async = _RandN_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Scalar, Scalar, CvCallback_0)>(); + ffi.Pointer RandShuffle( Mat mat, ) { @@ -20694,6 +21262,45 @@ class CvNative { late final _RandShuffleWithParams = _RandShuffleWithParamsPtr.asFunction< ffi.Pointer Function(Mat, double, RNG)>(); + ffi.Pointer RandShuffleWithParams_Async( + Mat mat, + double iterFactor, + RNG rng, + CvCallback_0 callback, + ) { + return _RandShuffleWithParams_Async( + mat, + iterFactor, + rng, + callback, + ); + } + + late final _RandShuffleWithParams_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Double, RNG, + CvCallback_0)>>('RandShuffleWithParams_Async'); + late final _RandShuffleWithParams_Async = + _RandShuffleWithParams_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, double, RNG, CvCallback_0)>(); + + ffi.Pointer RandShuffle_Async( + Mat mat, + CvCallback_0 callback, + ) { + return _RandShuffle_Async( + mat, + callback, + ); + } + + late final _RandShuffle_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_0)>>( + 'RandShuffle_Async'); + late final _RandShuffle_Async = _RandShuffle_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, CvCallback_0)>(); + ffi.Pointer RandU( Mat mat, Scalar low, @@ -20712,6 +21319,27 @@ class CvNative { late final _RandU = _RandUPtr.asFunction< ffi.Pointer Function(Mat, Scalar, Scalar)>(); + ffi.Pointer RandU_Async( + Mat mat, + Scalar low, + Scalar high, + CvCallback_0 callback, + ) { + return _RandU_Async( + mat, + low, + high, + callback, + ); + } + + late final _RandU_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Scalar, Scalar, CvCallback_0)>>('RandU_Async'); + late final _RandU_Async = _RandU_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Scalar, Scalar, CvCallback_0)>(); + ffi.Pointer Rectangle( Mat img, Rect rect, @@ -20959,6 +21587,37 @@ class CvNative { late final _Rng_NewWithState = _Rng_NewWithStatePtr.asFunction< ffi.Pointer Function(int, ffi.Pointer)>(); + ffi.Pointer Rng_NewWithState_Async( + int state, + CvCallback_1 callback, + ) { + return _Rng_NewWithState_Async( + state, + callback, + ); + } + + late final _Rng_NewWithState_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Uint64, CvCallback_1)>>('Rng_NewWithState_Async'); + late final _Rng_NewWithState_Async = _Rng_NewWithState_AsyncPtr.asFunction< + ffi.Pointer Function(int, CvCallback_1)>(); + + ffi.Pointer Rng_New_Async( + CvCallback_1 callback, + ) { + return _Rng_New_Async( + callback, + ); + } + + late final _Rng_New_AsyncPtr = + _lookup Function(CvCallback_1)>>( + 'Rng_New_Async'); + late final _Rng_New_Async = _Rng_New_AsyncPtr.asFunction< + ffi.Pointer Function(CvCallback_1)>(); + ffi.Pointer Rotate( Mat src, Mat dst, @@ -28024,6 +28683,2052 @@ class CvNative { late final _colorMomentHashCompute = _colorMomentHashComputePtr .asFunction Function(Mat, Mat)>(); + ffi.Pointer core_AbsDiff_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_AbsDiff_Async( + src1, + src2, + callback, + ); + } + + late final _core_AbsDiff_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_AbsDiff_Async'); + late final _core_AbsDiff_Async = _core_AbsDiff_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_AddWeighted_Async( + Mat src1, + double alpha, + Mat src2, + double beta, + double gamma, + int dtype, + CvCallback_1 callback, + ) { + return _core_AddWeighted_Async( + src1, + alpha, + src2, + beta, + gamma, + dtype, + callback, + ); + } + + late final _core_AddWeighted_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Double, Mat, ffi.Double, + ffi.Double, ffi.Int, CvCallback_1)>>('core_AddWeighted_Async'); + late final _core_AddWeighted_Async = _core_AddWeighted_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, double, Mat, double, double, int, CvCallback_1)>(); + + ffi.Pointer core_Add_Async( + Mat src1, + Mat src2, + Mat mask, + int dtype, + CvCallback_1 callback, + ) { + return _core_Add_Async( + src1, + src2, + mask, + dtype, + callback, + ); + } + + late final _core_Add_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, ffi.Int, CvCallback_1)>>('core_Add_Async'); + late final _core_Add_Async = _core_Add_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, int, CvCallback_1)>(); + + ffi.Pointer core_BatchDistance_Async( + Mat src1, + Mat src2, + int dtype, + int normType, + int K, + Mat mask, + int update, + bool crosscheck, + CvCallback_2 callback, + ) { + return _core_BatchDistance_Async( + src1, + src2, + dtype, + normType, + K, + mask, + update, + crosscheck, + callback, + ); + } + + late final _core_BatchDistance_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, + Mat, + ffi.Int, + ffi.Int, + ffi.Int, + Mat, + ffi.Int, + ffi.Bool, + CvCallback_2)>>('core_BatchDistance_Async'); + late final _core_BatchDistance_Async = + _core_BatchDistance_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, Mat, int, int, int, Mat, int, bool, CvCallback_2)>(); + + ffi.Pointer core_BitwiseAndWithMask_Async( + Mat src1, + Mat src2, + Mat mask, + CvCallback_1 callback, + ) { + return _core_BitwiseAndWithMask_Async( + src1, + src2, + mask, + callback, + ); + } + + late final _core_BitwiseAndWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_1)>>('core_BitwiseAndWithMask_Async'); + late final _core_BitwiseAndWithMask_Async = + _core_BitwiseAndWithMask_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseAnd_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_BitwiseAnd_Async( + src1, + src2, + callback, + ); + } + + late final _core_BitwiseAnd_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_BitwiseAnd_Async'); + late final _core_BitwiseAnd_Async = _core_BitwiseAnd_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseNotWithMask_Async( + Mat src1, + Mat mask, + CvCallback_1 callback, + ) { + return _core_BitwiseNotWithMask_Async( + src1, + mask, + callback, + ); + } + + late final _core_BitwiseNotWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_BitwiseNotWithMask_Async'); + late final _core_BitwiseNotWithMask_Async = _core_BitwiseNotWithMask_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseNot_Async( + Mat src1, + CvCallback_1 callback, + ) { + return _core_BitwiseNot_Async( + src1, + callback, + ); + } + + late final _core_BitwiseNot_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_BitwiseNot_Async'); + late final _core_BitwiseNot_Async = _core_BitwiseNot_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseOrWithMask_Async( + Mat src1, + Mat src2, + Mat mask, + CvCallback_1 callback, + ) { + return _core_BitwiseOrWithMask_Async( + src1, + src2, + mask, + callback, + ); + } + + late final _core_BitwiseOrWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_1)>>('core_BitwiseOrWithMask_Async'); + late final _core_BitwiseOrWithMask_Async = + _core_BitwiseOrWithMask_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseOr_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_BitwiseOr_Async( + src1, + src2, + callback, + ); + } + + late final _core_BitwiseOr_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_BitwiseOr_Async'); + late final _core_BitwiseOr_Async = _core_BitwiseOr_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseXorWithMask_Async( + Mat src1, + Mat src2, + Mat mask, + CvCallback_1 callback, + ) { + return _core_BitwiseXorWithMask_Async( + src1, + src2, + mask, + callback, + ); + } + + late final _core_BitwiseXorWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_1)>>('core_BitwiseXorWithMask_Async'); + late final _core_BitwiseXorWithMask_Async = + _core_BitwiseXorWithMask_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BitwiseXor_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_BitwiseXor_Async( + src1, + src2, + callback, + ); + } + + late final _core_BitwiseXor_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_BitwiseXor_Async'); + late final _core_BitwiseXor_Async = _core_BitwiseXor_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_BorderInterpolate_Async( + int p, + int len, + int borderType, + CvCallback_1 callback, + ) { + return _core_BorderInterpolate_Async( + p, + len, + borderType, + callback, + ); + } + + late final _core_BorderInterpolate_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Int, ffi.Int, ffi.Int, + CvCallback_1)>>('core_BorderInterpolate_Async'); + late final _core_BorderInterpolate_Async = + _core_BorderInterpolate_AsyncPtr.asFunction< + ffi.Pointer Function(int, int, int, CvCallback_1)>(); + + ffi.Pointer core_CalcCovarMatrix_Async( + Mat samples, + Mat mean, + int flags, + int ctype, + CvCallback_1 callback, + ) { + return _core_CalcCovarMatrix_Async( + samples, + mean, + flags, + ctype, + callback, + ); + } + + late final _core_CalcCovarMatrix_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Mat, ffi.Int, ffi.Int, + CvCallback_1)>>('core_CalcCovarMatrix_Async'); + late final _core_CalcCovarMatrix_Async = + _core_CalcCovarMatrix_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, int, CvCallback_1)>(); + + ffi.Pointer core_CartToPolar_Async( + Mat x, + Mat y, + bool angleInDegrees, + CvCallback_2 callback, + ) { + return _core_CartToPolar_Async( + x, + y, + angleInDegrees, + callback, + ); + } + + late final _core_CartToPolar_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Bool, CvCallback_2)>>('core_CartToPolar_Async'); + late final _core_CartToPolar_Async = _core_CartToPolar_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, bool, CvCallback_2)>(); + + ffi.Pointer core_CheckRange_Async( + Mat self, + bool quiet, + double minVal, + double maxVal, + CvCallback_2 callback, + ) { + return _core_CheckRange_Async( + self, + quiet, + minVal, + maxVal, + callback, + ); + } + + late final _core_CheckRange_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Bool, ffi.Double, ffi.Double, + CvCallback_2)>>('core_CheckRange_Async'); + late final _core_CheckRange_Async = _core_CheckRange_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, bool, double, double, CvCallback_2)>(); + + ffi.Pointer core_Compare_Async( + Mat src1, + Mat src2, + int ct, + CvCallback_1 callback, + ) { + return _core_Compare_Async( + src1, + src2, + ct, + callback, + ); + } + + late final _core_Compare_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Int, CvCallback_1)>>('core_Compare_Async'); + late final _core_Compare_Async = _core_Compare_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, CvCallback_1)>(); + + ffi.Pointer core_CompleteSymm_Async( + Mat self, + bool lowerToUpper, + CvCallback_0 callback, + ) { + return _core_CompleteSymm_Async( + self, + lowerToUpper, + callback, + ); + } + + late final _core_CompleteSymm_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Bool, CvCallback_0)>>('core_CompleteSymm_Async'); + late final _core_CompleteSymm_Async = _core_CompleteSymm_AsyncPtr + .asFunction Function(Mat, bool, CvCallback_0)>(); + + ffi.Pointer core_ConvertScaleAbs_Async( + Mat src, + double alpha, + double beta, + CvCallback_1 callback, + ) { + return _core_ConvertScaleAbs_Async( + src, + alpha, + beta, + callback, + ); + } + + late final _core_ConvertScaleAbs_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Double, ffi.Double, + CvCallback_1)>>('core_ConvertScaleAbs_Async'); + late final _core_ConvertScaleAbs_Async = + _core_ConvertScaleAbs_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, double, double, CvCallback_1)>(); + + ffi.Pointer core_CopyMakeBorder_Async( + Mat src, + int top, + int bottom, + int left, + int right, + int borderType, + Scalar value, + CvCallback_1 callback, + ) { + return _core_CopyMakeBorder_Async( + src, + top, + bottom, + left, + right, + borderType, + value, + callback, + ); + } + + late final _core_CopyMakeBorder_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, + ffi.Int, + ffi.Int, + ffi.Int, + ffi.Int, + ffi.Int, + Scalar, + CvCallback_1)>>('core_CopyMakeBorder_Async'); + late final _core_CopyMakeBorder_Async = + _core_CopyMakeBorder_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, int, int, int, int, int, Scalar, CvCallback_1)>(); + + ffi.Pointer core_CountNonZero_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_CountNonZero_Async( + src, + callback, + ); + } + + late final _core_CountNonZero_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_CountNonZero_Async'); + late final _core_CountNonZero_Async = _core_CountNonZero_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_DCT_Async( + Mat src, + int flags, + CvCallback_1 callback, + ) { + return _core_DCT_Async( + src, + flags, + callback, + ); + } + + late final _core_DCT_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_DCT_Async'); + late final _core_DCT_Async = _core_DCT_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_DFT_Async( + Mat self, + int flags, + int nonzeroRows, + CvCallback_1 callback, + ) { + return _core_DFT_Async( + self, + flags, + nonzeroRows, + callback, + ); + } + + late final _core_DFT_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, ffi.Int, CvCallback_1)>>('core_DFT_Async'); + late final _core_DFT_Async = _core_DFT_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, CvCallback_1)>(); + + ffi.Pointer core_Determinant_Async( + Mat self, + CvCallback_1 callback, + ) { + return _core_Determinant_Async( + self, + callback, + ); + } + + late final _core_Determinant_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_Determinant_Async'); + late final _core_Determinant_Async = _core_Determinant_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Divide_Async( + Mat src1, + Mat src2, + double scale, + int dtype, + CvCallback_1 callback, + ) { + return _core_Divide_Async( + src1, + src2, + scale, + dtype, + callback, + ); + } + + late final _core_Divide_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Mat, ffi.Double, ffi.Int, + CvCallback_1)>>('core_Divide_Async'); + late final _core_Divide_Async = _core_Divide_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, double, int, CvCallback_1)>(); + + ffi.Pointer core_EigenNonSymmetric_Async( + Mat src, + CvCallback_2 callback, + ) { + return _core_EigenNonSymmetric_Async( + src, + callback, + ); + } + + late final _core_EigenNonSymmetric_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_2)>>( + 'core_EigenNonSymmetric_Async'); + late final _core_EigenNonSymmetric_Async = _core_EigenNonSymmetric_AsyncPtr + .asFunction Function(Mat, CvCallback_2)>(); + + ffi.Pointer core_Eigen_Async( + Mat src, + CvCallback_3 callback, + ) { + return _core_Eigen_Async( + src, + callback, + ); + } + + late final _core_Eigen_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_3)>>( + 'core_Eigen_Async'); + late final _core_Eigen_Async = _core_Eigen_AsyncPtr + .asFunction Function(Mat, CvCallback_3)>(); + + ffi.Pointer core_Exp_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_Exp_Async( + src, + callback, + ); + } + + late final _core_Exp_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, CvCallback_1)>>('core_Exp_Async'); + late final _core_Exp_Async = _core_Exp_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_ExtractChannel_Async( + Mat src, + int coi, + CvCallback_1 callback, + ) { + return _core_ExtractChannel_Async( + src, + coi, + callback, + ); + } + + late final _core_ExtractChannel_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_ExtractChannel_Async'); + late final _core_ExtractChannel_Async = _core_ExtractChannel_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_FindNonZero_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_FindNonZero_Async( + src, + callback, + ); + } + + late final _core_FindNonZero_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_FindNonZero_Async'); + late final _core_FindNonZero_Async = _core_FindNonZero_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Flip_Async( + Mat src, + int flipCode, + CvCallback_1 callback, + ) { + return _core_Flip_Async( + src, + flipCode, + callback, + ); + } + + late final _core_Flip_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_Flip_Async'); + late final _core_Flip_Async = _core_Flip_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Gemm_Async( + Mat src1, + Mat src2, + double alpha, + Mat src3, + double beta, + int flags, + CvCallback_1 callback, + ) { + return _core_Gemm_Async( + src1, + src2, + alpha, + src3, + beta, + flags, + callback, + ); + } + + late final _core_Gemm_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Mat, ffi.Double, Mat, ffi.Double, + ffi.Int, CvCallback_1)>>('core_Gemm_Async'); + late final _core_Gemm_Async = _core_Gemm_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, Mat, double, Mat, double, int, CvCallback_1)>(); + + ffi.Pointer core_GetOptimalDFTSize_Async( + int vecsize, + CvCallback_1 callback, + ) { + return _core_GetOptimalDFTSize_Async( + vecsize, + callback, + ); + } + + late final _core_GetOptimalDFTSize_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Int, CvCallback_1)>>('core_GetOptimalDFTSize_Async'); + late final _core_GetOptimalDFTSize_Async = _core_GetOptimalDFTSize_AsyncPtr + .asFunction Function(int, CvCallback_1)>(); + + ffi.Pointer core_Hconcat_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_Hconcat_Async( + src1, + src2, + callback, + ); + } + + late final _core_Hconcat_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Hconcat_Async'); + late final _core_Hconcat_Async = _core_Hconcat_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_Idct_Async( + Mat src, + int flags, + CvCallback_1 callback, + ) { + return _core_Idct_Async( + src, + flags, + callback, + ); + } + + late final _core_Idct_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_Idct_Async'); + late final _core_Idct_Async = _core_Idct_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Idft_Async( + Mat src, + int flags, + int nonzeroRows, + CvCallback_1 callback, + ) { + return _core_Idft_Async( + src, + flags, + nonzeroRows, + callback, + ); + } + + late final _core_Idft_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, ffi.Int, CvCallback_1)>>('core_Idft_Async'); + late final _core_Idft_Async = _core_Idft_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, CvCallback_1)>(); + + ffi.Pointer core_InRangeWithScalar_Async( + Mat src, + Scalar lowerb, + Scalar upperb, + CvCallback_1 callback, + ) { + return _core_InRangeWithScalar_Async( + src, + lowerb, + upperb, + callback, + ); + } + + late final _core_InRangeWithScalar_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Scalar, Scalar, + CvCallback_1)>>('core_InRangeWithScalar_Async'); + late final _core_InRangeWithScalar_Async = + _core_InRangeWithScalar_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Scalar, Scalar, CvCallback_1)>(); + + ffi.Pointer core_InRange_Async( + Mat src, + Mat lowerb, + Mat upperb, + CvCallback_1 callback, + ) { + return _core_InRange_Async( + src, + lowerb, + upperb, + callback, + ); + } + + late final _core_InRange_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_1)>>('core_InRange_Async'); + late final _core_InRange_Async = _core_InRange_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_InsertChannel_Async( + Mat src, + Mat dst, + int coi, + CvCallback_0 callback, + ) { + return _core_InsertChannel_Async( + src, + dst, + coi, + callback, + ); + } + + late final _core_InsertChannel_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Int, CvCallback_0)>>('core_InsertChannel_Async'); + late final _core_InsertChannel_Async = + _core_InsertChannel_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, CvCallback_0)>(); + + ffi.Pointer core_Invert_Async( + Mat src, + int flags, + CvCallback_2 callback, + ) { + return _core_Invert_Async( + src, + flags, + callback, + ); + } + + late final _core_Invert_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_2)>>('core_Invert_Async'); + late final _core_Invert_Async = _core_Invert_AsyncPtr + .asFunction Function(Mat, int, CvCallback_2)>(); + + ffi.Pointer core_KMeans_Async( + Mat data, + int k, + Mat bestLabels, + TermCriteria criteria, + int attempts, + int flags, + CvCallback_2 callback, + ) { + return _core_KMeans_Async( + data, + k, + bestLabels, + criteria, + attempts, + flags, + callback, + ); + } + + late final _core_KMeans_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Int, Mat, TermCriteria, + ffi.Int, ffi.Int, CvCallback_2)>>('core_KMeans_Async'); + late final _core_KMeans_Async = _core_KMeans_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, int, Mat, TermCriteria, int, int, CvCallback_2)>(); + + ffi.Pointer core_KMeans_Points_Async( + VecPoint2f pts, + int k, + Mat bestLabels, + TermCriteria criteria, + int attempts, + int flags, + CvCallback_2 callback, + ) { + return _core_KMeans_Points_Async( + pts, + k, + bestLabels, + criteria, + attempts, + flags, + callback, + ); + } + + late final _core_KMeans_Points_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(VecPoint2f, ffi.Int, Mat, TermCriteria, + ffi.Int, ffi.Int, CvCallback_2)>>('core_KMeans_Points_Async'); + late final _core_KMeans_Points_Async = + _core_KMeans_Points_AsyncPtr.asFunction< + ffi.Pointer Function( + VecPoint2f, int, Mat, TermCriteria, int, int, CvCallback_2)>(); + + ffi.Pointer core_LUT_Async( + Mat src, + Mat lut, + CvCallback_1 callback, + ) { + return _core_LUT_Async( + src, + lut, + callback, + ); + } + + late final _core_LUT_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_LUT_Async'); + late final _core_LUT_Async = _core_LUT_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_Log_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_Log_Async( + src, + callback, + ); + } + + late final _core_Log_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, CvCallback_1)>>('core_Log_Async'); + late final _core_Log_Async = _core_Log_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Magnitude_Async( + Mat x, + Mat y, + CvCallback_1 callback, + ) { + return _core_Magnitude_Async( + x, + y, + callback, + ); + } + + late final _core_Magnitude_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Magnitude_Async'); + late final _core_Magnitude_Async = _core_Magnitude_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_Max_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_Max_Async( + src1, + src2, + callback, + ); + } + + late final _core_Max_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Max_Async'); + late final _core_Max_Async = _core_Max_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_MeanStdDevWithMask_Async( + Mat src, + Mat mask, + CvCallback_2 callback, + ) { + return _core_MeanStdDevWithMask_Async( + src, + mask, + callback, + ); + } + + late final _core_MeanStdDevWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_2)>>('core_MeanStdDevWithMask_Async'); + late final _core_MeanStdDevWithMask_Async = _core_MeanStdDevWithMask_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_2)>(); + + ffi.Pointer core_MeanStdDev_Async( + Mat src, + CvCallback_2 callback, + ) { + return _core_MeanStdDev_Async( + src, + callback, + ); + } + + late final _core_MeanStdDev_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_2)>>( + 'core_MeanStdDev_Async'); + late final _core_MeanStdDev_Async = _core_MeanStdDev_AsyncPtr + .asFunction Function(Mat, CvCallback_2)>(); + + ffi.Pointer core_MeanWithMask_Async( + Mat self, + Mat mask, + CvCallback_1 callback, + ) { + return _core_MeanWithMask_Async( + self, + mask, + callback, + ); + } + + late final _core_MeanWithMask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_MeanWithMask_Async'); + late final _core_MeanWithMask_Async = _core_MeanWithMask_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_Mean_Async( + Mat self, + CvCallback_1 callback, + ) { + return _core_Mean_Async( + self, + callback, + ); + } + + late final _core_Mean_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_Mean_Async'); + late final _core_Mean_Async = _core_Mean_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Merge_Async( + VecMat mats, + CvCallback_1 callback, + ) { + return _core_Merge_Async( + mats, + callback, + ); + } + + late final _core_Merge_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + VecMat, CvCallback_1)>>('core_Merge_Async'); + late final _core_Merge_Async = _core_Merge_AsyncPtr + .asFunction Function(VecMat, CvCallback_1)>(); + + ffi.Pointer core_MinMaxIdx_Async( + Mat self, + CvCallback_4 callback, + ) { + return _core_MinMaxIdx_Async( + self, + callback, + ); + } + + late final _core_MinMaxIdx_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_4)>>( + 'core_MinMaxIdx_Async'); + late final _core_MinMaxIdx_Async = _core_MinMaxIdx_AsyncPtr + .asFunction Function(Mat, CvCallback_4)>(); + + ffi.Pointer core_MinMaxIdx_Mask_Async( + Mat self, + Mat mask, + CvCallback_4 callback, + ) { + return _core_MinMaxIdx_Mask_Async( + self, + mask, + callback, + ); + } + + late final _core_MinMaxIdx_Mask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_4)>>('core_MinMaxIdx_Mask_Async'); + late final _core_MinMaxIdx_Mask_Async = _core_MinMaxIdx_Mask_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_4)>(); + + ffi.Pointer core_MinMaxLoc_Async( + Mat self, + CvCallback_4 callback, + ) { + return _core_MinMaxLoc_Async( + self, + callback, + ); + } + + late final _core_MinMaxLoc_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_4)>>( + 'core_MinMaxLoc_Async'); + late final _core_MinMaxLoc_Async = _core_MinMaxLoc_AsyncPtr + .asFunction Function(Mat, CvCallback_4)>(); + + ffi.Pointer core_MinMaxLoc_Mask_Async( + Mat self, + Mat mask, + CvCallback_4 callback, + ) { + return _core_MinMaxLoc_Mask_Async( + self, + mask, + callback, + ); + } + + late final _core_MinMaxLoc_Mask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_4)>>('core_MinMaxLoc_Mask_Async'); + late final _core_MinMaxLoc_Mask_Async = _core_MinMaxLoc_Mask_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_4)>(); + + ffi.Pointer core_Min_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_Min_Async( + src1, + src2, + callback, + ); + } + + late final _core_Min_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Min_Async'); + late final _core_Min_Async = _core_Min_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_MixChannels_Async( + VecMat src, + VecMat dst, + VecInt fromTo, + CvCallback_0 callback, + ) { + return _core_MixChannels_Async( + src, + dst, + fromTo, + callback, + ); + } + + late final _core_MixChannels_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + VecMat, VecMat, VecInt, CvCallback_0)>>('core_MixChannels_Async'); + late final _core_MixChannels_Async = _core_MixChannels_AsyncPtr.asFunction< + ffi.Pointer Function(VecMat, VecMat, VecInt, CvCallback_0)>(); + + ffi.Pointer core_MulSpectrums_Async( + Mat a, + Mat b, + int flags, + bool conjB, + CvCallback_1 callback, + ) { + return _core_MulSpectrums_Async( + a, + b, + flags, + conjB, + callback, + ); + } + + late final _core_MulSpectrums_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Mat, ffi.Int, ffi.Bool, + CvCallback_1)>>('core_MulSpectrums_Async'); + late final _core_MulSpectrums_Async = _core_MulSpectrums_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, bool, CvCallback_1)>(); + + ffi.Pointer core_MultiplyWithParams_Async( + Mat src1, + Mat src2, + double scale, + int dtype, + CvCallback_1 callback, + ) { + return _core_MultiplyWithParams_Async( + src1, + src2, + scale, + dtype, + callback, + ); + } + + late final _core_MultiplyWithParams_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Mat, ffi.Double, ffi.Int, + CvCallback_1)>>('core_MultiplyWithParams_Async'); + late final _core_MultiplyWithParams_Async = + _core_MultiplyWithParams_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, Mat, double, int, CvCallback_1)>(); + + ffi.Pointer core_Multiply_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_Multiply_Async( + src1, + src2, + callback, + ); + } + + late final _core_Multiply_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Multiply_Async'); + late final _core_Multiply_Async = _core_Multiply_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_NormWithMats_Async( + Mat src1, + Mat src2, + int normType, + CvCallback_1 callback, + ) { + return _core_NormWithMats_Async( + src1, + src2, + normType, + callback, + ); + } + + late final _core_NormWithMats_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Int, CvCallback_1)>>('core_NormWithMats_Async'); + late final _core_NormWithMats_Async = _core_NormWithMats_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Norm_Async( + Mat src1, + int normType, + CvCallback_1 callback, + ) { + return _core_Norm_Async( + src1, + normType, + callback, + ); + } + + late final _core_Norm_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_Norm_Async'); + late final _core_Norm_Async = _core_Norm_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Norm_Mask_Async( + Mat src1, + int normType, + Mat mask, + CvCallback_1 callback, + ) { + return _core_Norm_Mask_Async( + src1, + normType, + mask, + callback, + ); + } + + late final _core_Norm_Mask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, Mat, CvCallback_1)>>('core_Norm_Mask_Async'); + late final _core_Norm_Mask_Async = _core_Norm_Mask_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, Mat, CvCallback_1)>(); + + ffi.Pointer core_Normalize_Async( + Mat src, + Mat dst, + double alpha, + double beta, + int typ, + int dtype, + CvCallback_0 callback, + ) { + return _core_Normalize_Async( + src, + dst, + alpha, + beta, + typ, + dtype, + callback, + ); + } + + late final _core_Normalize_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, Mat, ffi.Double, ffi.Double, + ffi.Int, ffi.Int, CvCallback_0)>>('core_Normalize_Async'); + late final _core_Normalize_Async = _core_Normalize_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, Mat, double, double, int, int, CvCallback_0)>(); + + ffi.Pointer core_Normalize_Mask_Async( + Mat src, + Mat dst, + double alpha, + double beta, + int typ, + int dtype, + Mat mask, + CvCallback_0 callback, + ) { + return _core_Normalize_Mask_Async( + src, + dst, + alpha, + beta, + typ, + dtype, + mask, + callback, + ); + } + + late final _core_Normalize_Mask_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, + Mat, + ffi.Double, + ffi.Double, + ffi.Int, + ffi.Int, + Mat, + CvCallback_0)>>('core_Normalize_Mask_Async'); + late final _core_Normalize_Mask_Async = + _core_Normalize_Mask_AsyncPtr.asFunction< + ffi.Pointer Function( + Mat, Mat, double, double, int, int, Mat, CvCallback_0)>(); + + ffi.Pointer core_PCABackProject_Async( + Mat src, + Mat mean, + Mat eigenvectors, + CvCallback_1 callback, + ) { + return _core_PCABackProject_Async( + src, + mean, + eigenvectors, + callback, + ); + } + + late final _core_PCABackProject_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_1)>>('core_PCABackProject_Async'); + late final _core_PCABackProject_Async = + _core_PCABackProject_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_PCACompute_1_Async( + Mat src, + Mat mean, + int maxComponents, + CvCallback_1 callback, + ) { + return _core_PCACompute_1_Async( + src, + mean, + maxComponents, + callback, + ); + } + + late final _core_PCACompute_1_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Int, CvCallback_1)>>('core_PCACompute_1_Async'); + late final _core_PCACompute_1_Async = _core_PCACompute_1_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, CvCallback_1)>(); + + ffi.Pointer core_PCACompute_2_Async( + Mat src, + Mat mean, + double retainedVariance, + CvCallback_2 callback, + ) { + return _core_PCACompute_2_Async( + src, + mean, + retainedVariance, + callback, + ); + } + + late final _core_PCACompute_2_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Double, CvCallback_2)>>('core_PCACompute_2_Async'); + late final _core_PCACompute_2_Async = _core_PCACompute_2_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, double, CvCallback_2)>(); + + ffi.Pointer core_PCACompute_3_Async( + Mat src, + Mat mean, + double retainedVariance, + CvCallback_1 callback, + ) { + return _core_PCACompute_3_Async( + src, + mean, + retainedVariance, + callback, + ); + } + + late final _core_PCACompute_3_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Double, CvCallback_1)>>('core_PCACompute_3_Async'); + late final _core_PCACompute_3_Async = _core_PCACompute_3_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, double, CvCallback_1)>(); + + ffi.Pointer core_PCACompute_Async( + Mat src, + Mat mean, + int maxComponents, + CvCallback_2 callback, + ) { + return _core_PCACompute_Async( + src, + mean, + maxComponents, + callback, + ); + } + + late final _core_PCACompute_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Int, CvCallback_2)>>('core_PCACompute_Async'); + late final _core_PCACompute_Async = _core_PCACompute_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, CvCallback_2)>(); + + ffi.Pointer core_PCAProject_Async( + Mat src, + Mat mean, + Mat eigenvectors, + CvCallback_1 callback, + ) { + return _core_PCAProject_Async( + src, + mean, + eigenvectors, + callback, + ); + } + + late final _core_PCAProject_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, CvCallback_1)>>('core_PCAProject_Async'); + late final _core_PCAProject_Async = _core_PCAProject_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_PatchNaNs_Async( + Mat self, + double val, + CvCallback_0 callback, + ) { + return _core_PatchNaNs_Async( + self, + val, + callback, + ); + } + + late final _core_PatchNaNs_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Double, CvCallback_0)>>('core_PatchNaNs_Async'); + late final _core_PatchNaNs_Async = _core_PatchNaNs_AsyncPtr + .asFunction Function(Mat, double, CvCallback_0)>(); + + ffi.Pointer core_PerspectiveTransform_Async( + Mat src, + Mat tm, + CvCallback_1 callback, + ) { + return _core_PerspectiveTransform_Async( + src, + tm, + callback, + ); + } + + late final _core_PerspectiveTransform_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_PerspectiveTransform_Async'); + late final _core_PerspectiveTransform_Async = + _core_PerspectiveTransform_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_Phase_Async( + Mat x, + Mat y, + bool angleInDegrees, + CvCallback_1 callback, + ) { + return _core_Phase_Async( + x, + y, + angleInDegrees, + callback, + ); + } + + late final _core_Phase_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Bool, CvCallback_1)>>('core_Phase_Async'); + late final _core_Phase_Async = _core_Phase_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, bool, CvCallback_1)>(); + + ffi.Pointer core_PolarToCart_Async( + Mat magnitude, + Mat degree, + bool angleInDegrees, + CvCallback_2 callback, + ) { + return _core_PolarToCart_Async( + magnitude, + degree, + angleInDegrees, + callback, + ); + } + + late final _core_PolarToCart_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Bool, CvCallback_2)>>('core_PolarToCart_Async'); + late final _core_PolarToCart_Async = _core_PolarToCart_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, bool, CvCallback_2)>(); + + ffi.Pointer core_Pow_Async( + Mat src, + double power, + CvCallback_1 callback, + ) { + return _core_Pow_Async( + src, + power, + callback, + ); + } + + late final _core_Pow_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Double, CvCallback_1)>>('core_Pow_Async'); + late final _core_Pow_Async = _core_Pow_AsyncPtr + .asFunction Function(Mat, double, CvCallback_1)>(); + + ffi.Pointer core_ReduceArgMax_Async( + Mat src, + int axis, + bool lastIndex, + CvCallback_1 callback, + ) { + return _core_ReduceArgMax_Async( + src, + axis, + lastIndex, + callback, + ); + } + + late final _core_ReduceArgMax_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Int, ffi.Bool, + CvCallback_1)>>('core_ReduceArgMax_Async'); + late final _core_ReduceArgMax_Async = _core_ReduceArgMax_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, bool, CvCallback_1)>(); + + ffi.Pointer core_ReduceArgMin_Async( + Mat src, + int axis, + bool lastIndex, + CvCallback_1 callback, + ) { + return _core_ReduceArgMin_Async( + src, + axis, + lastIndex, + callback, + ); + } + + late final _core_ReduceArgMin_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Int, ffi.Bool, + CvCallback_1)>>('core_ReduceArgMin_Async'); + late final _core_ReduceArgMin_Async = _core_ReduceArgMin_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, bool, CvCallback_1)>(); + + ffi.Pointer core_Reduce_Async( + Mat src, + int dim, + int rType, + int dType, + CvCallback_1 callback, + ) { + return _core_Reduce_Async( + src, + dim, + rType, + dType, + callback, + ); + } + + late final _core_Reduce_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, ffi.Int, ffi.Int, ffi.Int, + CvCallback_1)>>('core_Reduce_Async'); + late final _core_Reduce_Async = _core_Reduce_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, int, CvCallback_1)>(); + + ffi.Pointer core_Repeat_Async( + Mat src, + int nY, + int nX, + CvCallback_1 callback, + ) { + return _core_Repeat_Async( + src, + nY, + nX, + callback, + ); + } + + late final _core_Repeat_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, ffi.Int, CvCallback_1)>>('core_Repeat_Async'); + late final _core_Repeat_Async = _core_Repeat_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, CvCallback_1)>(); + + ffi.Pointer core_Rotate_Async( + Mat src, + int rotateCode, + CvCallback_1 callback, + ) { + return _core_Rotate_Async( + src, + rotateCode, + callback, + ); + } + + late final _core_Rotate_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_Rotate_Async'); + late final _core_Rotate_Async = _core_Rotate_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_ScaleAdd_Async( + Mat src1, + double alpha, + Mat src2, + CvCallback_1 callback, + ) { + return _core_ScaleAdd_Async( + src1, + alpha, + src2, + callback, + ); + } + + late final _core_ScaleAdd_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Double, Mat, CvCallback_1)>>('core_ScaleAdd_Async'); + late final _core_ScaleAdd_Async = _core_ScaleAdd_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, double, Mat, CvCallback_1)>(); + + ffi.Pointer core_SetIdentity_Async( + Mat src, + Scalar scalar, + CvCallback_0 callback, + ) { + return _core_SetIdentity_Async( + src, + scalar, + callback, + ); + } + + late final _core_SetIdentity_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Scalar, CvCallback_0)>>('core_SetIdentity_Async'); + late final _core_SetIdentity_Async = _core_SetIdentity_AsyncPtr + .asFunction Function(Mat, Scalar, CvCallback_0)>(); + + ffi.Pointer core_SolveCubic_Async( + Mat coeffs, + CvCallback_2 callback, + ) { + return _core_SolveCubic_Async( + coeffs, + callback, + ); + } + + late final _core_SolveCubic_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_2)>>( + 'core_SolveCubic_Async'); + late final _core_SolveCubic_Async = _core_SolveCubic_AsyncPtr + .asFunction Function(Mat, CvCallback_2)>(); + + ffi.Pointer core_SolvePoly_Async( + Mat coeffs, + int maxIters, + CvCallback_2 callback, + ) { + return _core_SolvePoly_Async( + coeffs, + maxIters, + callback, + ); + } + + late final _core_SolvePoly_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_2)>>('core_SolvePoly_Async'); + late final _core_SolvePoly_Async = _core_SolvePoly_AsyncPtr + .asFunction Function(Mat, int, CvCallback_2)>(); + + ffi.Pointer core_Solve_Async( + Mat src1, + Mat src2, + int flags, + CvCallback_2 callback, + ) { + return _core_Solve_Async( + src1, + src2, + flags, + callback, + ); + } + + late final _core_Solve_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, ffi.Int, CvCallback_2)>>('core_Solve_Async'); + late final _core_Solve_Async = _core_Solve_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, int, CvCallback_2)>(); + + ffi.Pointer core_SortIdx_Async( + Mat src, + int flags, + CvCallback_1 callback, + ) { + return _core_SortIdx_Async( + src, + flags, + callback, + ); + } + + late final _core_SortIdx_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_SortIdx_Async'); + late final _core_SortIdx_Async = _core_SortIdx_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Sort_Async( + Mat src, + int flags, + CvCallback_1 callback, + ) { + return _core_Sort_Async( + src, + flags, + callback, + ); + } + + late final _core_Sort_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, CvCallback_1)>>('core_Sort_Async'); + late final _core_Sort_Async = _core_Sort_AsyncPtr + .asFunction Function(Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Split_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_Split_Async( + src, + callback, + ); + } + + late final _core_Split_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_Split_Async'); + late final _core_Split_Async = _core_Split_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Sqrt_Async( + Mat self, + CvCallback_1 callback, + ) { + return _core_Sqrt_Async( + self, + callback, + ); + } + + late final _core_Sqrt_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_Sqrt_Async'); + late final _core_Sqrt_Async = _core_Sqrt_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Subtract_Async( + Mat src1, + Mat src2, + Mat mask, + int dtype, + CvCallback_1 callback, + ) { + return _core_Subtract_Async( + src1, + src2, + mask, + dtype, + callback, + ); + } + + late final _core_Subtract_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, Mat, ffi.Int, CvCallback_1)>>('core_Subtract_Async'); + late final _core_Subtract_Async = _core_Subtract_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, Mat, Mat, int, CvCallback_1)>(); + + ffi.Pointer core_Sum_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_Sum_Async( + src, + callback, + ); + } + + late final _core_Sum_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, CvCallback_1)>>('core_Sum_Async'); + late final _core_Sum_Async = _core_Sum_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_T_Async( + Mat x, + CvCallback_1 callback, + ) { + return _core_T_Async( + x, + callback, + ); + } + + late final _core_T_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(Mat, CvCallback_1)>>('core_T_Async'); + late final _core_T_Async = _core_T_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Trace_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_Trace_Async( + src, + callback, + ); + } + + late final _core_Trace_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_Trace_Async'); + late final _core_Trace_Async = _core_Trace_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Transform_Async( + Mat src, + Mat tm, + CvCallback_1 callback, + ) { + return _core_Transform_Async( + src, + tm, + callback, + ); + } + + late final _core_Transform_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Transform_Async'); + late final _core_Transform_Async = _core_Transform_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_Transpose_Async( + Mat src, + CvCallback_1 callback, + ) { + return _core_Transpose_Async( + src, + callback, + ); + } + + late final _core_Transpose_AsyncPtr = _lookup< + ffi + .NativeFunction Function(Mat, CvCallback_1)>>( + 'core_Transpose_Async'); + late final _core_Transpose_Async = _core_Transpose_AsyncPtr + .asFunction Function(Mat, CvCallback_1)>(); + + ffi.Pointer core_Vconcat_Async( + Mat src1, + Mat src2, + CvCallback_1 callback, + ) { + return _core_Vconcat_Async( + src1, + src2, + callback, + ); + } + + late final _core_Vconcat_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, Mat, CvCallback_1)>>('core_Vconcat_Async'); + late final _core_Vconcat_Async = _core_Vconcat_AsyncPtr + .asFunction Function(Mat, Mat, CvCallback_1)>(); + + ffi.Pointer core_colRange_Async( + Mat self, + int start, + int end, + CvCallback_1 callback, + ) { + return _core_colRange_Async( + self, + start, + end, + callback, + ); + } + + late final _core_colRange_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, ffi.Int, CvCallback_1)>>('core_colRange_Async'); + late final _core_colRange_Async = _core_colRange_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, CvCallback_1)>(); + + ffi.Pointer core_rowRange_Async( + Mat self, + int start, + int end, + CvCallback_1 callback, + ) { + return _core_rowRange_Async( + self, + start, + end, + callback, + ); + } + + late final _core_rowRange_AsyncPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + Mat, ffi.Int, ffi.Int, CvCallback_1)>>('core_rowRange_Async'); + late final _core_rowRange_Async = _core_rowRange_AsyncPtr.asFunction< + ffi.Pointer Function(Mat, int, int, CvCallback_1)>(); + ffi.Pointer destroyAllWindows() { return _destroyAllWindows(); } diff --git a/src/core/core_async.cpp b/src/core/core_async.cpp index 48f723bf..7bf7ac21 100644 --- a/src/core/core_async.cpp +++ b/src/core/core_async.cpp @@ -1,31 +1,1215 @@ #include "core_async.h" #include "core/types.h" +#include "lut.hpp" +#include "opencv2/core.hpp" +#include "opencv2/core/types.hpp" +#pragma region Mat_Constructors +CvStatus *Mat_New_Async(CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat()}); + END_WRAP +} +CvStatus *Mat_NewWithSize_Async(int rows, int cols, int type, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(rows, cols, type)}); + END_WRAP +} +CvStatus *Mat_NewWithSizes_Async(VecInt sizes, int type, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(*sizes.ptr, type)}); + END_WRAP +} +CvStatus *Mat_NewWithSizesScalar_Async(VecInt sizes, int type, Scalar s, CvCallback_1 callback) { + BEGIN_WRAP + cv::Scalar c = cv::Scalar(s.val1, s.val2, s.val3, s.val4); + callback(new Mat{new cv::Mat(*sizes.ptr, type, c)}); + END_WRAP +} +CvStatus * +Mat_NewWithSizesFromBytes_Async(VecInt sizes, int type, VecChar buf, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(*sizes.ptr, type, buf.ptr)}); + END_WRAP +} +CvStatus * +Mat_NewFromScalar_Async(const Scalar s, int rows, int cols, int type, CvCallback_1 callback) { + BEGIN_WRAP + cv::Scalar c = cv::Scalar(s.val1, s.val2, s.val3, s.val4); + callback(new Mat{new cv::Mat(rows, cols, type, c)}); + END_WRAP +} +CvStatus * +Mat_NewFromBytes_Async(int rows, int cols, int type, void *buf, int step, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(rows, cols, type, buf, step)}); + END_WRAP +} +CvStatus *Mat_NewFromVecPoint_Async(VecPoint vec, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(*vec.ptr)}); + END_WRAP +} +CvStatus *Mat_NewFromVecPoint2f_Async(VecPoint2f vec, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(*vec.ptr)}); + END_WRAP +} +CvStatus *Mat_NewFromVecPoint3f_Async(VecPoint3f vec, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(*vec.ptr)}); + END_WRAP +} -// CvStatus *RotatedRect_Points_Async(RotatedRect rect, CvCallback1 callback) -// { -// BEGIN_WRAP -// auto r = cv::RotatedRect(cv::Point2f(rect.center.x, rect.center.y), -// cv::Size2f(rect.size.width, rect.size.height), rect.angle); -// std::vector pts_; -// r.points(pts_); -// callback(new VecPoint2f{new std::vector(pts_)}); -// END_WRAP -// } -// CvStatus *RotatedRect_BoundingRect_Async(RotatedRect rect, CvCallback1 callback) -// { -// BEGIN_WRAP -// auto r = cv::RotatedRect(cv::Point2f(rect.center.x, rect.center.y), -// cv::Size2f(rect.size.width, rect.size.height), rect.angle); -// auto rr = r.boundingRect(); -// callback(new Rect{rr.x, rr.y, rr.width, rr.height}); -// END_WRAP -// } -// CvStatus *RotatedRect_BoundingRect2f_Async(RotatedRect rect, CvCallback1 callback) -// { -// BEGIN_WRAP -// auto r = cv::RotatedRect(cv::Point2f(rect.center.x, rect.center.y), -// cv::Size2f(rect.size.width, rect.size.height), rect.angle); -// auto rr = r.boundingRect2f(); -// callback(new Rect2f{rr.x, rr.y, rr.width, rr.height}); -// END_WRAP -// } +CvStatus *Mat_Eye_Async(int rows, int cols, int type, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(cv::Mat::eye(rows, cols, type))}); + END_WRAP +} +CvStatus *Mat_Zeros_Async(int rows, int cols, int type, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(cv::Mat::zeros(rows, cols, type))}); + END_WRAP +} +CvStatus *Mat_Ones_Async(int rows, int cols, int type, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(cv::Mat::ones(rows, cols, type))}); + END_WRAP +} + +#pragma endregion + +#pragma region Mat_functions +CvStatus *Mat_Release_Async(MatPtr self, CvCallback_0 callback) { + BEGIN_WRAP + self->ptr->release(); + callback(); + END_WRAP +} +// bool *rval +CvStatus *Mat_Empty_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + callback(new bool(self.ptr->empty())); + END_WRAP +} +CvStatus *Mat_IsContinuous_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + callback(new bool(self.ptr->isContinuous())); + END_WRAP +} +CvStatus *Mat_Clone_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(self.ptr->clone())}); + END_WRAP +} +CvStatus *Mat_CopyTo_Async(Mat self, Mat dst, CvCallback_0 callback) { + BEGIN_WRAP + self.ptr->copyTo(*dst.ptr); + callback(); + END_WRAP +} +CvStatus *Mat_CopyToWithMask_Async(Mat self, Mat dst, Mat mask, CvCallback_0 callback) { + BEGIN_WRAP + self.ptr->copyTo(*dst.ptr, *mask.ptr); + callback(); + END_WRAP +} +CvStatus *Mat_ConvertTo_Async(Mat self, int type, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + self.ptr->convertTo(dst, type); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus * +Mat_ConvertToWithParams_Async(Mat self, int type, float alpha, float beta, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + self.ptr->convertTo(dst, type, alpha, beta); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *Mat_ToVecUChar_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + self.ptr->convertTo(dst, CV_8UC1); + callback(new VecUChar{new std::vector(dst)}); + END_WRAP +} +CvStatus *Mat_ToVecChar_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + self.ptr->convertTo(dst, CV_8SC1); + callback(new VecChar{new std::vector(dst)}); + END_WRAP +} +CvStatus *Mat_Region_Async(Mat self, Rect r, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(*self.ptr, cv::Rect(r.x, r.y, r.width, r.height))}); + END_WRAP +} +CvStatus *Mat_Reshape_Async(Mat self, int cn, int rows, CvCallback_1 callback) { + BEGIN_WRAP + callback(new Mat{new cv::Mat(self.ptr->reshape(cn, rows))}); + END_WRAP +} + +#pragma endregion + +CvStatus *core_PatchNaNs_Async(Mat self, double val, CvCallback_0 callback) { + BEGIN_WRAP + cv::patchNaNs(*self.ptr, val); + callback(); + END_WRAP +} +// Deprecated: +// Use Mat::convertTo with CV_16F instead. +// CvStatus *Mat_ConvertFp16_Async(Mat self, CvCallback_1 callback); +CvStatus *core_Mean_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + cv::Scalar c = cv::mean(*self.ptr); + callback(new Scalar{c.val[0], c.val[1], c.val[2], c.val[3]}); + END_WRAP +} +CvStatus *core_MeanWithMask_Async(Mat self, Mat mask, CvCallback_1 callback) { + BEGIN_WRAP + cv::Scalar c = cv::mean(*self.ptr, *mask.ptr); + callback(new Scalar{c.val[0], c.val[1], c.val[2], c.val[3]}); + END_WRAP +} +CvStatus *core_Sqrt_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::sqrt(*self.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_AbsDiff_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::absdiff(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_Add_Async(Mat src1, Mat src2, Mat mask, int dtype, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::add(*src1.ptr, *src2.ptr, dst, *mask.ptr, dtype); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_AddWeighted_Async( + Mat src1, double alpha, Mat src2, double beta, double gamma, int dtype, CvCallback_1 callback +) { + BEGIN_WRAP + cv::Mat dst; + cv::addWeighted(*src1.ptr, alpha, *src2.ptr, beta, gamma, dst, dtype); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseAnd_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_and(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseAndWithMask_Async(Mat src1, Mat src2, Mat mask, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_and(*src1.ptr, *src2.ptr, dst, *mask.ptr); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseNot_Async(Mat src1, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_not(*src1.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseNotWithMask_Async(Mat src1, Mat mask, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_not(*src1.ptr, dst, *mask.ptr); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseOr_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_or(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseOrWithMask_Async(Mat src1, Mat src2, Mat mask, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_or(*src1.ptr, *src2.ptr, dst, *mask.ptr); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseXor_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_xor(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_BitwiseXorWithMask_Async(Mat src1, Mat src2, Mat mask, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::bitwise_xor(*src1.ptr, *src2.ptr, dst, *mask.ptr); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} +CvStatus *core_Compare_Async(Mat src1, Mat src2, int ct, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::compare(*src1.ptr, *src2.ptr, dst, ct); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_BatchDistance_Async( + Mat src1, + Mat src2, + int dtype, + int normType, + int K, + Mat mask, + int update, + bool crosscheck, + CvCallback_2 callback +) { + BEGIN_WRAP + cv::Mat dist, nidx; + cv::batchDistance( + *src1.ptr, *src2.ptr, dist, dtype, nidx, normType, K, *mask.ptr, update, crosscheck + ); + callback(new Mat{new cv::Mat(dist)}, new Mat{new cv::Mat(nidx)}); + END_WRAP +} + +CvStatus *core_BorderInterpolate_Async(int p, int len, int borderType, CvCallback_1 callback) { + BEGIN_WRAP + callback(new int(cv::borderInterpolate(p, len, borderType))); + END_WRAP +} + +CvStatus * +core_CalcCovarMatrix_Async(Mat samples, Mat mean, int flags, int ctype, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat cov; + cv::calcCovarMatrix(*samples.ptr, cov, *mean.ptr, flags, ctype); + callback(new Mat{new cv::Mat(cov)}); + END_WRAP +} + +CvStatus *core_CartToPolar_Async(Mat x, Mat y, bool angleInDegrees, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat mag, ang; + cv::cartToPolar(*x.ptr, *y.ptr, mag, ang, angleInDegrees); + callback(new Mat{new cv::Mat(mag)}, new Mat{new cv::Mat(ang)}); + END_WRAP +} + +CvStatus * +core_CheckRange_Async(Mat self, bool quiet, double minVal, double maxVal, CvCallback_2 callback) { + BEGIN_WRAP + cv::Point point; + bool rval = cv::checkRange(*self.ptr, quiet, &point, minVal, maxVal); + callback(new bool(rval), new Point{point.x, point.y}); + END_WRAP +} + +CvStatus *core_CompleteSymm_Async(Mat self, bool lowerToUpper, CvCallback_0 callback) { + BEGIN_WRAP + cv::completeSymm(*self.ptr, lowerToUpper); + callback(); + END_WRAP +} + +CvStatus *core_ConvertScaleAbs_Async(Mat src, double alpha, double beta, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::convertScaleAbs(*src.ptr, dst, alpha, beta); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_CopyMakeBorder_Async( + Mat src, + int top, + int bottom, + int left, + int right, + int borderType, + Scalar value, + CvCallback_1 callback +) { + BEGIN_WRAP + cv::Mat dst; + cv::Scalar val = cv::Scalar(value.val1, value.val2, value.val3, value.val4); + cv::copyMakeBorder(*src.ptr, dst, top, bottom, left, right, borderType, val); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_CountNonZero_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + callback(new int(cv::countNonZero(*src.ptr))); + END_WRAP +} + +CvStatus *core_DCT_Async(Mat src, int flags, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::dct(*src.ptr, dst, flags); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Determinant_Async(Mat self, CvCallback_1 callback) { + BEGIN_WRAP + callback(new double(cv::determinant(*self.ptr))); + END_WRAP +} + +CvStatus *core_DFT_Async(Mat self, int flags, int nonzeroRows, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::dft(*self.ptr, dst, flags, nonzeroRows); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Divide_Async(Mat src1, Mat src2, double scale, int dtype, CvCallback_1 callback) { + BEGIN_WRAP + cv::divide(*src1.ptr, *src2.ptr, *src1.ptr); + callback(new Mat{new cv::Mat(*src1.ptr)}); + END_WRAP +} + +// Mat eigenvalues, Mat eigenvectors, bool *rval +CvStatus *core_Eigen_Async(Mat src, CvCallback_3 callback) { + BEGIN_WRAP + cv::Mat eigenvalues, eigenvectors; + bool rval = cv::eigen(*src.ptr, eigenvalues, eigenvectors); + callback(new bool(rval), new Mat{new cv::Mat(eigenvalues)}, new Mat{new cv::Mat(eigenvectors)}); + END_WRAP +} + +CvStatus *core_EigenNonSymmetric_Async(Mat src, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat eigenvalues, eigenvectors; + cv::eigenNonSymmetric(*src.ptr, eigenvalues, eigenvectors); + callback(new Mat{new cv::Mat(eigenvalues)}, new Mat{new cv::Mat(eigenvectors)}); + END_WRAP +} + +CvStatus *core_PCABackProject_Async(Mat src, Mat mean, Mat eigenvectors, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat result; + cv::PCABackProject(*src.ptr, *mean.ptr, *eigenvectors.ptr, result); + callback(new Mat{new cv::Mat(result)}); + END_WRAP +} + +CvStatus * +core_PCACompute_3_Async(Mat src, Mat mean, double retainedVariance, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat eigenvectors; + cv::PCACompute(*src.ptr, *mean.ptr, eigenvectors, retainedVariance); + callback(new Mat{new cv::Mat(eigenvectors)}); + END_WRAP +} + +CvStatus *core_PCACompute_1_Async(Mat src, Mat mean, int maxComponents, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat eigenvectors; + cv::PCACompute(*src.ptr, *mean.ptr, eigenvectors, maxComponents); + callback(new Mat{new cv::Mat(eigenvectors)}); + END_WRAP +} + +CvStatus * +core_PCACompute_2_Async(Mat src, Mat mean, double retainedVariance, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat eigenvectors, eigenValues; + cv::PCACompute(*src.ptr, *mean.ptr, eigenvectors, eigenValues, retainedVariance); + callback(new Mat{new cv::Mat(eigenvectors)}, new Mat{new cv::Mat(eigenValues)}); + END_WRAP +} + +CvStatus *core_PCACompute_Async(Mat src, Mat mean, int maxComponents, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat eigenvectors, eigenValues; + cv::PCACompute(*src.ptr, *mean.ptr, eigenvectors, eigenValues, maxComponents); + callback(new Mat{new cv::Mat(eigenvectors)}, new Mat{new cv::Mat(eigenValues)}); + END_WRAP +} + +CvStatus *core_PCAProject_Async(Mat src, Mat mean, Mat eigenvectors, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat result; + cv::PCAProject(*src.ptr, *mean.ptr, *eigenvectors.ptr, result); + callback(new Mat{new cv::Mat(result)}); + END_WRAP +} + +CvStatus *core_Exp_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::exp(*src.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_ExtractChannel_Async(Mat src, int coi, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::extractChannel(*src.ptr, dst, coi); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_FindNonZero_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat indices; + cv::findNonZero(*src.ptr, indices); + callback(new Mat{new cv::Mat(indices)}); + END_WRAP +} + +CvStatus *core_Flip_Async(Mat src, int flipCode, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::flip(*src.ptr, dst, flipCode); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Gemm_Async( + Mat src1, Mat src2, double alpha, Mat src3, double beta, int flags, CvCallback_1 callback +) { + BEGIN_WRAP + cv::Mat dst; + cv::gemm(*src1.ptr, *src2.ptr, alpha, *src3.ptr, beta, dst, flags); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_GetOptimalDFTSize_Async(int vecsize, CvCallback_1 callback) { + BEGIN_WRAP + callback(new int(cv::getOptimalDFTSize(vecsize))); + END_WRAP +} + +CvStatus *core_Hconcat_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::hconcat(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Vconcat_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::vconcat(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Idct_Async(Mat src, int flags, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::idct(*src.ptr, dst, flags); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Idft_Async(Mat src, int flags, int nonzeroRows, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::idft(*src.ptr, dst, flags, nonzeroRows); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_InRange_Async(Mat src, Mat lowerb, Mat upperb, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::inRange(*src.ptr, *lowerb.ptr, *upperb.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_InRangeWithScalar_Async( + Mat src, const Scalar lowerb, const Scalar upperb, CvCallback_1 callback +) { + BEGIN_WRAP + cv::Mat dst; + cv::Scalar lowb(lowerb.val1, lowerb.val2, lowerb.val3, lowerb.val4); + cv::Scalar upb(upperb.val1, upperb.val2, upperb.val3, upperb.val4); + cv::inRange(*src.ptr, lowb, upb, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_InsertChannel_Async(Mat src, Mat dst, int coi, CvCallback_0 callback) { + BEGIN_WRAP + cv::insertChannel(*src.ptr, *dst.ptr, coi); + callback(); + END_WRAP +} + +CvStatus *core_Invert_Async(Mat src, int flags, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat dst; + double rval = cv::invert(*src.ptr, dst, flags); + callback(new double(rval), new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Log_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::log(*src.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Magnitude_Async(Mat x, Mat y, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::magnitude(*x.ptr, *y.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Max_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::max(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_MeanStdDev_Async(Mat src, CvCallback_2 callback) { + BEGIN_WRAP + cv::Scalar mean, stddev; + cv::meanStdDev(*src.ptr, mean, stddev); + callback( + new Scalar{mean.val[0], mean.val[1], mean.val[2], mean.val[3]}, + new Scalar{stddev.val[0], stddev.val[1], stddev.val[2], stddev.val[3]} + ); + END_WRAP +} + +CvStatus *core_MeanStdDevWithMask_Async(Mat src, Mat mask, CvCallback_2 callback) { + BEGIN_WRAP + cv::Scalar mean, stddev; + cv::meanStdDev(*src.ptr, mean, stddev, *mask.ptr); + callback( + new Scalar{mean.val[0], mean.val[1], mean.val[2], mean.val[3]}, + new Scalar{stddev.val[0], stddev.val[1], stddev.val[2], stddev.val[3]} + ); + END_WRAP +} + +CvStatus *core_Merge_Async(VecMat mats, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::merge(*mats.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Min_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::min(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_MinMaxIdx_Async(Mat self, CvCallback_4 callback) { + BEGIN_WRAP + double minVal, maxVal; + int minLoc, maxLoc; + cv::minMaxIdx(*self.ptr, &minVal, &maxVal, &minLoc, &maxLoc); + callback(new double(minVal), new double(maxVal), new int(minLoc), new int(maxLoc)); + END_WRAP +} + +CvStatus *core_MinMaxIdx_Mask_Async(Mat self, Mat mask, CvCallback_4 callback) { + BEGIN_WRAP + double minVal, maxVal; + int minLoc, maxLoc; + cv::minMaxIdx(*self.ptr, &minVal, &maxVal, &minLoc, &maxLoc, *mask.ptr); + callback(new double(minVal), new double(maxVal), new int(minLoc), new int(maxLoc)); + END_WRAP +} + +CvStatus *core_MinMaxLoc_Async(Mat self, CvCallback_4 callback) { + BEGIN_WRAP + double minVal, maxVal; + cv::Point minLoc, maxLoc; + cv::minMaxLoc(*self.ptr, &minVal, &maxVal, &minLoc, &maxLoc); + callback( + new double(minVal), + new double(maxVal), + new Point{minLoc.x, minLoc.y}, + new Point{maxLoc.x, maxLoc.y} + ); + END_WRAP +} + +CvStatus *core_MinMaxLoc_Mask_Async(Mat self, Mat mask, CvCallback_4 callback) { + BEGIN_WRAP + double minVal, maxVal; + cv::Point minLoc, maxLoc; + cv::minMaxLoc(*self.ptr, &minVal, &maxVal, &minLoc, &maxLoc, *mask.ptr); + callback( + new double(minVal), + new double(maxVal), + new Point{minLoc.x, minLoc.y}, + new Point{maxLoc.x, maxLoc.y} + ); + END_WRAP +} + +CvStatus *core_MixChannels_Async(VecMat src, VecMat dst, VecInt fromTo, CvCallback_0 callback) { + BEGIN_WRAP + cv::mixChannels(*src.ptr, *dst.ptr, *fromTo.ptr); + callback(); + END_WRAP +} + +CvStatus *core_MulSpectrums_Async(Mat a, Mat b, int flags, bool conjB, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::mulSpectrums(*a.ptr, *b.ptr, dst, flags); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Multiply_Async(Mat src1, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::multiply(*src1.ptr, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus * +core_MultiplyWithParams_Async(Mat src1, Mat src2, double scale, int dtype, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::multiply(*src1.ptr, *src2.ptr, dst, scale, dtype); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Normalize_Async( + Mat src, Mat dst, double alpha, double beta, int typ, int dtype, CvCallback_0 callback +) { + BEGIN_WRAP + cv::normalize(*src.ptr, *dst.ptr, alpha, beta, typ, dtype); + callback(); + END_WRAP +} + +CvStatus *core_Normalize_Mask_Async( + Mat src, Mat dst, double alpha, double beta, int typ, int dtype, Mat mask, CvCallback_0 callback +) { + BEGIN_WRAP + cv::normalize(*src.ptr, *dst.ptr, alpha, beta, typ, dtype, *mask.ptr); + callback(); + END_WRAP +} + +CvStatus *core_PerspectiveTransform_Async(Mat src, Mat tm, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::perspectiveTransform(*src.ptr, dst, *tm.ptr); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Solve_Async(Mat src1, Mat src2, int flags, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat dst; + bool rval = cv::solve(*src1.ptr, *src2.ptr, dst, flags); + callback(new bool(rval), new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_SolveCubic_Async(Mat coeffs, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat dst; + int rval = cv::solveCubic(*coeffs.ptr, dst); + callback(new int(rval), new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_SolvePoly_Async(Mat coeffs, int maxIters, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat dst; + double rval = cv::solvePoly(*coeffs.ptr, dst, maxIters); + callback(new double(rval), new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Reduce_Async(Mat src, int dim, int rType, int dType, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::reduce(*src.ptr, dst, dim, rType, dType); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_ReduceArgMax_Async(Mat src, int axis, bool lastIndex, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::reduceArgMax(*src.ptr, dst, axis, lastIndex); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_ReduceArgMin_Async(Mat src, int axis, bool lastIndex, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::reduceArgMin(*src.ptr, dst, axis, lastIndex); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Repeat_Async(Mat src, int nY, int nX, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::repeat(*src.ptr, nY, nX, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_ScaleAdd_Async(Mat src1, double alpha, Mat src2, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::scaleAdd(*src1.ptr, alpha, *src2.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_SetIdentity_Async(Mat src, Scalar scalar, CvCallback_0 callback) { + BEGIN_WRAP + cv::setIdentity(*src.ptr, *new cv::Scalar(scalar.val1, scalar.val2, scalar.val3, scalar.val4)); + callback(); + END_WRAP +} + +CvStatus *core_Sort_Async(Mat src, int flags, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::sort(*src.ptr, dst, flags); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_SortIdx_Async(Mat src, int flags, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::sortIdx(*src.ptr, dst, flags); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Split_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + std::vector dst; + cv::split(*src.ptr, dst); + callback(new VecMat{new std::vector(dst)}); + END_WRAP +} + +CvStatus *core_Subtract_Async(Mat src1, Mat src2, Mat mask, int dtype, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::subtract(*src1.ptr, *src2.ptr, dst, *mask.ptr, dtype); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_T_Async(Mat x, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::transpose(*x.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Trace_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + cv::Scalar dst = cv::trace(*src.ptr); + callback(new Scalar{dst.val[0], dst.val[1], dst.val[2], dst.val[3]}); + END_WRAP +} + +CvStatus *core_Transform_Async(Mat src, Mat tm, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::transform(*src.ptr, dst, *tm.ptr); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Transpose_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::transpose(*src.ptr, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus * +core_PolarToCart_Async(Mat magnitude, Mat degree, bool angleInDegrees, CvCallback_2 callback) { + BEGIN_WRAP + cv::Mat x, y; + cv::polarToCart(*magnitude.ptr, *degree.ptr, x, y, angleInDegrees); + callback(new Mat{new cv::Mat(x)}, new Mat{new cv::Mat(y)}); + END_WRAP +} + +CvStatus *core_Pow_Async(Mat src, double power, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::pow(*src.ptr, power, dst); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Phase_Async(Mat x, Mat y, bool angleInDegrees, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::phase(*x.ptr, *y.ptr, dst, angleInDegrees); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Sum_Async(Mat src, CvCallback_1 callback) { + BEGIN_WRAP + cv::Scalar dst = cv::sum(*src.ptr); + callback(new Scalar{dst.val[0], dst.val[1], dst.val[2], dst.val[3]}); + END_WRAP +} + +CvStatus *core_rowRange_Async(Mat self, int start, int end, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst = self.ptr->rowRange(start, end); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_colRange_Async(Mat self, int start, int end, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst = self.ptr->colRange(start, end); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_LUT_Async(Mat src, Mat lut, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + auto cn = src.ptr->channels(), depth = src.ptr->depth(); + if (depth == CV_8U || depth == CV_8S) { + cv::LUT(*src.ptr, *lut.ptr, dst); + } else { + int lutcn = lut.ptr->channels(), lut_depth = lut.ptr->depth(); + size_t lut_total = lut.ptr->total(), expect_total = 0; + switch (depth) { + case CV_8U: + case CV_8S: expect_total = 256; break; + case CV_16U: + case CV_16S: expect_total = 65536; break; + // TODO: can't create a mat with 4294967296 rows, maybe use vector instead + // case CV_32S: + // expect_total = 4294967296; + // break; + default: + throw cv::Exception( + cv::Error::StsNotImplemented, + "source Mat Type not supported", + __func__, + __FILE__, + __LINE__ + ); + } + + CV_Assert((lutcn == cn || lutcn == 1) && lut_total == expect_total && lut.ptr->isContinuous()); + dst.create(src.ptr->dims, src.ptr->size, CV_MAKETYPE(lut.ptr->depth(), cn)); + + const cv::Mat *arrays[] = {src.ptr, &dst, 0}; + uchar *ptrs[2] = {}; + cv::NAryMatIterator it(arrays, ptrs); + int len = (int)it.size; + + switch (depth) { + case CV_16U: + switch (lut_depth) { + case CV_8U: + cvd::LUT16u_8u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_8S: + cvd::LUT16u_8s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_16U: + cvd::LUT16u_16u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_16S: + cvd::LUT16u_16s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_32S: + cvd::LUT16u_32s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_32F: + cvd::LUT16u_32f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_64F: + cvd::LUT16u_64f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + default: + cv::String err = "lut Mat Type not supported for CV_16U"; + throw cv::Exception(cv::Error::StsNotImplemented, err, __func__, __FILE__, __LINE__); + } + break; + case CV_16S: + switch (lut_depth) { + case CV_8U: + cvd::LUT16s_8u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_8S: + cvd::LUT16s_8s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_16U: + cvd::LUT16s_16u( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_16S: + cvd::LUT16s_16s( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_32S: + cvd::LUT16s_32s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn); + break; + case CV_32F: + cvd::LUT16s_32f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_64F: + cvd::LUT16s_64f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + default: + cv::String err = "lut Mat Type not supported for CV_16S"; + throw cv::Exception(cv::Error::StsNotImplemented, err, __func__, __FILE__, __LINE__); + } + break; + case CV_32S: + switch (lut_depth) { + case CV_32S: + cvd::LUT32s_32s(src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn); + break; + case CV_32F: + cvd::LUT32s_32f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + case CV_64F: + cvd::LUT32s_64f( + src.ptr->ptr(), lut.ptr->ptr(), dst.ptr(), len, cn, lutcn + ); + break; + default: + cv::String err = "lut Mat Type not supported for CV_32S"; + throw cv::Exception(cv::Error::StsNotImplemented, err, __func__, __FILE__, __LINE__); + } + break; + default: + cv::String err = "src Mat Type not supported"; + throw cv::Exception(cv::Error::StsNotImplemented, err, __func__, __FILE__, __LINE__); + } + } + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_KMeans_Async( + Mat data, + int k, + Mat bestLabels, + TermCriteria criteria, + int attempts, + int flags, + CvCallback_2 callback +) { + BEGIN_WRAP + cv::TermCriteria tc = cv::TermCriteria(criteria.type, criteria.maxCount, criteria.epsilon); + cv::Mat centers; + double rval = cv::kmeans(*data.ptr, k, *bestLabels.ptr, tc, attempts, flags, centers); + callback(new double(rval), new Mat{new cv::Mat(centers)}); + END_WRAP +} + +CvStatus *core_KMeans_Points_Async( + VecPoint2f pts, + int k, + Mat bestLabels, + TermCriteria criteria, + int attempts, + int flags, + CvCallback_2 callback +) { + BEGIN_WRAP + cv::TermCriteria tc = cv::TermCriteria(criteria.type, criteria.maxCount, criteria.epsilon); + cv::Mat centers; + double rval = cv::kmeans(*pts.ptr, k, *bestLabels.ptr, tc, attempts, flags, centers); + callback(new double(rval), new Mat{new cv::Mat(centers)}); + END_WRAP +} + +CvStatus *core_Rotate_Async(Mat src, int rotateCode, CvCallback_1 callback) { + BEGIN_WRAP + cv::Mat dst; + cv::rotate(*src.ptr, dst, rotateCode); + callback(new Mat{new cv::Mat(dst)}); + END_WRAP +} + +CvStatus *core_Norm_Async(Mat src1, int normType, CvCallback_1 callback) { + BEGIN_WRAP + double rval = cv::norm(*src1.ptr, normType); + callback(new double(rval)); + END_WRAP +} + +CvStatus *core_Norm_Mask_Async(Mat src1, int normType, Mat mask, CvCallback_1 callback) { + BEGIN_WRAP + double rval = cv::norm(*src1.ptr, normType, *mask.ptr); + callback(new double(rval)); + END_WRAP +} + +CvStatus *core_NormWithMats_Async(Mat src1, Mat src2, int normType, CvCallback_1 callback) { + BEGIN_WRAP + double rval = cv::norm(*src1.ptr, *src2.ptr, normType); + callback(new double(rval)); + END_WRAP +} + +#pragma region RNG + +CvStatus *Rng_New_Async(CvCallback_1 callback) { + BEGIN_WRAP + callback(new RNG{new cv::RNG()}); + END_WRAP +} + +CvStatus *Rng_NewWithState_Async(uint64_t state, CvCallback_1 callback) { + BEGIN_WRAP + callback(new RNG{new cv::RNG(state)}); + END_WRAP +} + +CvStatus *RNG_Fill_Async( + RNG rng, Mat mat, int distType, double a, double b, bool saturateRange, CvCallback_0 callback +) { + BEGIN_WRAP + rng.ptr->fill(*mat.ptr, distType, a, b, saturateRange); + callback(); + END_WRAP +} + +CvStatus *RNG_Gaussian_Async(RNG rng, double sigma, CvCallback_1 callback) { + BEGIN_WRAP + double rval = rng.ptr->gaussian(sigma); + callback(new double(rval)); + END_WRAP +} + +CvStatus *RNG_Uniform_Async(RNG rng, int a, int b, CvCallback_1 callback) { + BEGIN_WRAP + int rval = rng.ptr->uniform(a, b); + callback(new int(rval)); + END_WRAP +} + +CvStatus *RNG_UniformDouble_Async(RNG rng, double a, double b, CvCallback_1 callback) { + BEGIN_WRAP + double rval = rng.ptr->uniform(a, b); + callback(new double(rval)); + END_WRAP +} + +CvStatus *RNG_Next_Async(RNG rng, CvCallback_1 callback) { + BEGIN_WRAP + uint32_t rval = rng.ptr->next(); + callback(new uint32_t(rval)); + END_WRAP +} + +CvStatus *RandN_Async(Mat mat, Scalar mean, Scalar stddev, CvCallback_0 callback) { + BEGIN_WRAP + cv::Scalar mean_ = cv::Scalar(mean.val1, mean.val2, mean.val3, mean.val4); + cv::Scalar stddev_ = cv::Scalar(stddev.val1, stddev.val2, stddev.val3, stddev.val4); + cv::randn(*mat.ptr, mean_, stddev_); + callback(); + END_WRAP +} + +CvStatus *RandShuffle_Async(Mat mat, CvCallback_0 callback) { + BEGIN_WRAP + cv::randShuffle(*mat.ptr); + callback(); + END_WRAP +} + +CvStatus *RandShuffleWithParams_Async(Mat mat, double iterFactor, RNG rng, CvCallback_0 callback) { + BEGIN_WRAP + cv::randShuffle(*mat.ptr, iterFactor, rng.ptr); + callback(); + END_WRAP +} + +CvStatus *RandU_Async(Mat mat, Scalar low, Scalar high, CvCallback_0 callback) { + BEGIN_WRAP + cv::Scalar low_ = cv::Scalar(low.val1, low.val2, low.val3, low.val4); + cv::Scalar high_ = cv::Scalar(high.val1, high.val2, high.val3, high.val4); + cv::randu(*mat.ptr, low_, high_); + callback(); + END_WRAP +} + +#pragma endregion diff --git a/src/core/core_async.h b/src/core/core_async.h index 2a5f1a71..4eeb2ec0 100644 --- a/src/core/core_async.h +++ b/src/core/core_async.h @@ -10,345 +10,381 @@ #ifdef __cplusplus extern "C" { #endif -// CvStatus *RotatedRect_Points_Async(RotatedRect rect, CvCallback1 callback); -// CvStatus *RotatedRect_BoundingRect_Async(RotatedRect rect, CvCallback1 -// callback); CvStatus *RotatedRect_BoundingRect2f_Async(RotatedRect rect, -// CvCallback1 callback); +#pragma region Mat_Constructors CvStatus *Mat_New_Async(CvCallback_1 callback); CvStatus *Mat_NewWithSize_Async(int rows, int cols, int type, CvCallback_1 callback); CvStatus *Mat_NewWithSizes_Async(VecInt sizes, int type, CvCallback_1 callback); -CvStatus * -Mat_NewWithSizesFromScalar_Async(VecInt sizes, int type, Scalar ar, CvCallback_1 callback); +CvStatus *Mat_NewWithSizesScalar_Async(VecInt sizes, int type, Scalar s, CvCallback_1 callback); CvStatus * Mat_NewWithSizesFromBytes_Async(VecInt sizes, int type, VecChar buf, CvCallback_1 callback); -CvStatus *Mat_NewFromScalar_Async(const Scalar ar, int type, CvCallback_1 callback); -CvStatus *Mat_NewWithSizeFromScalar_Async( - const Scalar ar, int rows, int cols, int type, CvCallback_1 callback -); +CvStatus * +Mat_NewFromScalar_Async(const Scalar s, int rows, int cols, int type, CvCallback_1 callback); CvStatus * Mat_NewFromBytes_Async(int rows, int cols, int type, void *buf, int step, CvCallback_1 callback); CvStatus *Mat_NewFromVecPoint_Async(VecPoint vec, CvCallback_1 callback); CvStatus *Mat_NewFromVecPoint2f_Async(VecPoint2f vec, CvCallback_1 callback); CvStatus *Mat_NewFromVecPoint3f_Async(VecPoint3f vec, CvCallback_1 callback); -CvStatus * -Mat_FromPtr_Async(Mat m, int rows, int cols, int type, int prows, int pcols, CvCallback_1 callback); -CvStatus *Mat_FromCMat_Async(Mat m, CvCallback_1 callback); -// functions without return values shouldn't have callbacks? -void Mat_Close_Async(MatPtr m, CvCallback_0 callback); -// TODO -CvStatus *Mat_Release_Async(MatPtr self, CvCallback_0 callback); -CvStatus *Mat_Empty_Async(Mat m, bool *rval); -CvStatus *Mat_IsContinuous_Async(Mat m, bool *rval); -CvStatus *Mat_Clone_Async(Mat m, CvCallback_1 callback); -CvStatus *Mat_CopyTo_Async(Mat m, Mat dst); -CvStatus *Mat_CopyToWithMask_Async(Mat m, Mat dst, Mat mask); -CvStatus *Mat_ConvertTo_Async(Mat m, Mat dst, int type); -CvStatus *Mat_ConvertToWithParams_Async(Mat m, Mat dst, int type, float alpha, float beta); -CvStatus *Mat_ToVecUChar_Async(Mat m, VecUChar *rval); -CvStatus *Mat_ToVecChar_Async(Mat m, VecChar *rval); -CvStatus *Mat_Region_Async(Mat m, Rect r, CvCallback_1 callback); -CvStatus *Mat_Reshape_Async(Mat m, int cn, int rows, CvCallback_1 callback); -CvStatus *Mat_PatchNaNs_Async(Mat m, double val); -CvStatus *Mat_ConvertFp16_Async(Mat m, CvCallback_1 callback); -CvStatus *Mat_Mean_Async(Mat m, Scalar *rval); -CvStatus *Mat_MeanWithMask_Async(Mat m, Mat mask, Scalar *rval); -CvStatus *Mat_Sqrt_Async(Mat m, CvCallback_1 callback); -CvStatus *Mat_Rows_Async(Mat m, int *rval); -CvStatus *Mat_Cols_Async(Mat m, int *rval); -CvStatus *Mat_Channels_Async(Mat m, int *rval); -CvStatus *Mat_Type_Async(Mat m, int *rval); -CvStatus *Mat_Step_Async(Mat m, int *rval); -CvStatus *Mat_Total_Async(Mat m, int *rval); -CvStatus *Mat_Size_Async(Mat m, VecInt *rval); -CvStatus *Mat_ElemSize_Async(Mat m, int *rval); -CvStatus *Mat_Data_Async(Mat m, VecUChar *rval); -CvStatus *Mat_DataPtr_Async(Mat m, uchar **data, int *length); -CvStatus *Eye_Async(int rows, int cols, int type, CvCallback_1 callback); -CvStatus *Zeros_Async(int rows, int cols, int type, CvCallback_1 callback); -CvStatus *Ones_Async(int rows, int cols, int type, CvCallback_1 callback); +CvStatus *Mat_Eye_Async(int rows, int cols, int type, CvCallback_1 callback); +CvStatus *Mat_Zeros_Async(int rows, int cols, int type, CvCallback_1 callback); +CvStatus *Mat_Ones_Async(int rows, int cols, int type, CvCallback_1 callback); -CvStatus *Mat_Ptr_u8_1_Async(Mat m, int i, uchar **rval); -CvStatus *Mat_Ptr_u8_2_Async(Mat m, int i, int j, uchar **rval); -CvStatus *Mat_Ptr_u8_3_Async(Mat m, int i, int j, int k, uchar **rval); -CvStatus *Mat_Ptr_i8_1_Async(Mat m, int i, char **rval); -CvStatus *Mat_Ptr_i8_2_Async(Mat m, int i, int j, char **rval); -CvStatus *Mat_Ptr_i8_3_Async(Mat m, int i, int j, int k, char **rval); -CvStatus *Mat_Ptr_u16_1_Async(Mat m, int i, ushort **rval); -CvStatus *Mat_Ptr_u16_2_Async(Mat m, int i, int j, ushort **rval); -CvStatus *Mat_Ptr_u16_3_Async(Mat m, int i, int j, int k, ushort **rval); -CvStatus *Mat_Ptr_i16_1_Async(Mat m, int i, short **rval); -CvStatus *Mat_Ptr_i16_2_Async(Mat m, int i, int j, short **rval); -CvStatus *Mat_Ptr_i16_3_Async(Mat m, int i, int j, int k, short **rval); -CvStatus *Mat_Ptr_i32_1_Async(Mat m, int i, int **rval); -CvStatus *Mat_Ptr_i32_2_Async(Mat m, int i, int j, int **rval); -CvStatus *Mat_Ptr_i32_3_Async(Mat m, int i, int j, int k, int **rval); -CvStatus *Mat_Ptr_f32_1_Async(Mat m, int i, float **rval); -CvStatus *Mat_Ptr_f32_2_Async(Mat m, int i, int j, float **rval); -CvStatus *Mat_Ptr_f32_3_Async(Mat m, int i, int j, int k, float **rval); -CvStatus *Mat_Ptr_f64_1_Async(Mat m, int i, double **rval); -CvStatus *Mat_Ptr_f64_2_Async(Mat m, int i, int j, double **rval); -CvStatus *Mat_Ptr_f64_3_Async(Mat m, int i, int j, int k, double **rval); +#pragma endregion -#pragma region Mat_getter +#pragma region Mat_functions +// CvStatus *Mat_Release_Async(MatPtr self, CvCallback_0 callback); +// CvStatus *Mat_Empty_Async(Mat self, CvCallback_1 callback); // bool *rval +// CvStatus *Mat_IsContinuous_Async(Mat self, CvCallback_1 callback); // bool *rval +CvStatus *Mat_Clone_Async(Mat self, CvCallback_1 callback); // Mat *dst +CvStatus *Mat_CopyTo_Async(Mat self, Mat dst, CvCallback_0 callback); +CvStatus *Mat_CopyToWithMask_Async(Mat self, Mat dst, Mat mask, CvCallback_0 callback); +CvStatus *Mat_ConvertTo_Async(Mat self, int type, CvCallback_1 callback); // Mat dst +CvStatus *Mat_ConvertToWithParams_Async( + Mat self, int type, float alpha, float beta, CvCallback_1 callback +); // Mat dst +CvStatus *Mat_ToVecUChar_Async(Mat self, CvCallback_1 callback); // VecUChar *rval +CvStatus *Mat_ToVecChar_Async(Mat self, CvCallback_1 callback); // VecChar *rval +CvStatus *Mat_Region_Async(Mat self, Rect r, CvCallback_1 callback); +CvStatus *Mat_Reshape_Async(Mat self, int cn, int rows, CvCallback_1 callback); +#pragma endregion -CvStatus *Mat_GetUChar_Async(Mat m, int row, int col, uint8_t *rval); -CvStatus *Mat_GetUChar3_Async(Mat m, int x, int y, int z, uint8_t *rval); -CvStatus *Mat_GetSChar_Async(Mat m, int row, int col, int8_t *rval); -CvStatus *Mat_GetSChar3_Async(Mat m, int x, int y, int z, int8_t *rval); -CvStatus *Mat_GetUShort_Async(Mat m, int row, int col, uint16_t *rval); -CvStatus *Mat_GetUShort3_Async(Mat m, int x, int y, int z, uint16_t *rval); -CvStatus *Mat_GetShort_Async(Mat m, int row, int col, int16_t *rval); -CvStatus *Mat_GetShort3_Async(Mat m, int x, int y, int z, int16_t *rval); -CvStatus *Mat_GetInt_Async(Mat m, int row, int col, int32_t *rval); -CvStatus *Mat_GetInt3_Async(Mat m, int x, int y, int z, int32_t *rval); -CvStatus *Mat_GetFloat_Async(Mat m, int row, int col, float *rval); -CvStatus *Mat_GetFloat3_Async(Mat m, int x, int y, int z, float *rval); -CvStatus *Mat_GetDouble_Async(Mat m, int row, int col, double *rval); -CvStatus *Mat_GetDouble3_Async(Mat m, int x, int y, int z, double *rval); +// properties, use sync +// CvStatus *Mat_Rows_Async(Mat self, CvCallback_1 callback); // int *rval +// CvStatus *Mat_Cols_Async(Mat self, CvCallback_1 callback); +// CvStatus *Mat_Channels_Async(Mat self, CvCallback_1 callback); +// CvStatus *Mat_Type_Async(Mat self, CvCallback_1 callback); +// CvStatus *Mat_Step_Async(Mat self, int *rval); +// CvStatus *Mat_Total_Async(Mat self, int *rval); +// CvStatus *Mat_Size_Async(Mat self, VecInt *rval); +// CvStatus *Mat_ElemSize_Async(Mat self, int *rval); +// CvStatus *Mat_Data_Async(Mat self, VecUChar *rval); +// CvStatus *Mat_DataPtr_Async(Mat self, uchar **data, int *length); -CvStatus *Mat_GetVec2b_Async(Mat m, int row, int col, Vec2b *rval); -CvStatus *Mat_GetVec3b_Async(Mat m, int row, int col, Vec3b *rval); -CvStatus *Mat_GetVec4b_Async(Mat m, int row, int col, Vec4b *rval); -CvStatus *Mat_GetVec2s_Async(Mat m, int row, int col, Vec2s *rval); -CvStatus *Mat_GetVec3s_Async(Mat m, int row, int col, Vec3s *rval); -CvStatus *Mat_GetVec4s_Async(Mat m, int row, int col, Vec4s *rval); -CvStatus *Mat_GetVec2w_Async(Mat m, int row, int col, Vec2w *rval); -CvStatus *Mat_GetVec3w_Async(Mat m, int row, int col, Vec3w *rval); -CvStatus *Mat_GetVec4w_Async(Mat m, int row, int col, Vec4w *rval); -CvStatus *Mat_GetVec2i_Async(Mat m, int row, int col, Vec2i *rval); -CvStatus *Mat_GetVec3i_Async(Mat m, int row, int col, Vec3i *rval); -CvStatus *Mat_GetVec4i_Async(Mat m, int row, int col, Vec4i *rval); -CvStatus *Mat_GetVec6i_Async(Mat m, int row, int col, Vec6i *rval); -CvStatus *Mat_GetVec8i_Async(Mat m, int row, int col, Vec8i *rval); -CvStatus *Mat_GetVec2f_Async(Mat m, int row, int col, Vec2f *rval); -CvStatus *Mat_GetVec3f_Async(Mat m, int row, int col, Vec3f *rval); -CvStatus *Mat_GetVec4f_Async(Mat m, int row, int col, Vec4f *rval); -CvStatus *Mat_GetVec6f_Async(Mat m, int row, int col, Vec6f *rval); -CvStatus *Mat_GetVec2d_Async(Mat m, int row, int col, Vec2d *rval); -CvStatus *Mat_GetVec3d_Async(Mat m, int row, int col, Vec3d *rval); -CvStatus *Mat_GetVec4d_Async(Mat m, int row, int col, Vec4d *rval); -CvStatus *Mat_GetVec6d_Async(Mat m, int row, int col, Vec6d *rval); +// CvStatus *Mat_Ptr_u8_1_Async(Mat self, int i, uchar **rval); +// CvStatus *Mat_Ptr_u8_2_Async(Mat self, int i, int j, uchar **rval); +// CvStatus *Mat_Ptr_u8_3_Async(Mat self, int i, int j, int k, uchar **rval); +// CvStatus *Mat_Ptr_i8_1_Async(Mat self, int i, char **rval); +// CvStatus *Mat_Ptr_i8_2_Async(Mat self, int i, int j, char **rval); +// CvStatus *Mat_Ptr_i8_3_Async(Mat self, int i, int j, int k, char **rval); +// CvStatus *Mat_Ptr_u16_1_Async(Mat self, int i, ushort **rval); +// CvStatus *Mat_Ptr_u16_2_Async(Mat self, int i, int j, ushort **rval); +// CvStatus *Mat_Ptr_u16_3_Async(Mat self, int i, int j, int k, ushort **rval); +// CvStatus *Mat_Ptr_i16_1_Async(Mat self, int i, short **rval); +// CvStatus *Mat_Ptr_i16_2_Async(Mat self, int i, int j, short **rval); +// CvStatus *Mat_Ptr_i16_3_Async(Mat self, int i, int j, int k, short **rval); +// CvStatus *Mat_Ptr_i32_1_Async(Mat self, int i, int **rval); +// CvStatus *Mat_Ptr_i32_2_Async(Mat self, int i, int j, int **rval); +// CvStatus *Mat_Ptr_i32_3_Async(Mat self, int i, int j, int k, int **rval); +// CvStatus *Mat_Ptr_f32_1_Async(Mat self, int i, float **rval); +// CvStatus *Mat_Ptr_f32_2_Async(Mat self, int i, int j, float **rval); +// CvStatus *Mat_Ptr_f32_3_Async(Mat self, int i, int j, int k, float **rval); +// CvStatus *Mat_Ptr_f64_1_Async(Mat self, int i, double **rval); +// CvStatus *Mat_Ptr_f64_2_Async(Mat self, int i, int j, double **rval); +// CvStatus *Mat_Ptr_f64_3_Async(Mat self, int i, int j, int k, double **rval); -#pragma endregion +// #pragma region Mat_getter -#pragma region Mat_setter +// CvStatus *Mat_GetUChar_Async(Mat self, int row, int col, uint8_t *rval); +// CvStatus *Mat_GetUChar3_Async(Mat self, int x, int y, int z, uint8_t *rval); +// CvStatus *Mat_GetSChar_Async(Mat self, int row, int col, int8_t *rval); +// CvStatus *Mat_GetSChar3_Async(Mat self, int x, int y, int z, int8_t *rval); +// CvStatus *Mat_GetUShort_Async(Mat self, int row, int col, uint16_t *rval); +// CvStatus *Mat_GetUShort3_Async(Mat self, int x, int y, int z, uint16_t *rval); +// CvStatus *Mat_GetShort_Async(Mat self, int row, int col, int16_t *rval); +// CvStatus *Mat_GetShort3_Async(Mat self, int x, int y, int z, int16_t *rval); +// CvStatus *Mat_GetInt_Async(Mat self, int row, int col, int32_t *rval); +// CvStatus *Mat_GetInt3_Async(Mat self, int x, int y, int z, int32_t *rval); +// CvStatus *Mat_GetFloat_Async(Mat self, int row, int col, float *rval); +// CvStatus *Mat_GetFloat3_Async(Mat self, int x, int y, int z, float *rval); +// CvStatus *Mat_GetDouble_Async(Mat self, int row, int col, double *rval); +// CvStatus *Mat_GetDouble3_Async(Mat self, int x, int y, int z, double *rval); -CvStatus *Mat_SetTo_Async(Mat m, Scalar value); -CvStatus *Mat_SetUChar_Async(Mat m, int row, int col, uint8_t val); -CvStatus *Mat_SetUChar3_Async(Mat m, int x, int y, int z, uint8_t val); -CvStatus *Mat_SetSChar_Async(Mat m, int row, int col, int8_t val); -CvStatus *Mat_SetSChar3_Async(Mat m, int x, int y, int z, int8_t val); -CvStatus *Mat_SetShort_Async(Mat m, int row, int col, int16_t val); -CvStatus *Mat_SetShort3_Async(Mat m, int x, int y, int z, int16_t val); -CvStatus *Mat_SetUShort_Async(Mat m, int row, int col, uint16_t val); -CvStatus *Mat_SetUShort3_Async(Mat m, int x, int y, int z, uint16_t val); -CvStatus *Mat_SetInt_Async(Mat m, int row, int col, int32_t val); -CvStatus *Mat_SetInt3_Async(Mat m, int x, int y, int z, int32_t val); -CvStatus *Mat_SetFloat_Async(Mat m, int row, int col, float val); -CvStatus *Mat_SetFloat3_Async(Mat m, int x, int y, int z, float val); -CvStatus *Mat_SetDouble_Async(Mat m, int row, int col, double val); -CvStatus *Mat_SetDouble3_Async(Mat m, int x, int y, int z, double val); +// CvStatus *Mat_GetVec2b_Async(Mat self, int row, int col, Vec2b *rval); +// CvStatus *Mat_GetVec3b_Async(Mat self, int row, int col, Vec3b *rval); +// CvStatus *Mat_GetVec4b_Async(Mat self, int row, int col, Vec4b *rval); +// CvStatus *Mat_GetVec2s_Async(Mat self, int row, int col, Vec2s *rval); +// CvStatus *Mat_GetVec3s_Async(Mat self, int row, int col, Vec3s *rval); +// CvStatus *Mat_GetVec4s_Async(Mat self, int row, int col, Vec4s *rval); +// CvStatus *Mat_GetVec2w_Async(Mat self, int row, int col, Vec2w *rval); +// CvStatus *Mat_GetVec3w_Async(Mat self, int row, int col, Vec3w *rval); +// CvStatus *Mat_GetVec4w_Async(Mat self, int row, int col, Vec4w *rval); +// CvStatus *Mat_GetVec2i_Async(Mat self, int row, int col, Vec2i *rval); +// CvStatus *Mat_GetVec3i_Async(Mat self, int row, int col, Vec3i *rval); +// CvStatus *Mat_GetVec4i_Async(Mat self, int row, int col, Vec4i *rval); +// CvStatus *Mat_GetVec6i_Async(Mat self, int row, int col, Vec6i *rval); +// CvStatus *Mat_GetVec8i_Async(Mat self, int row, int col, Vec8i *rval); +// CvStatus *Mat_GetVec2f_Async(Mat self, int row, int col, Vec2f *rval); +// CvStatus *Mat_GetVec3f_Async(Mat self, int row, int col, Vec3f *rval); +// CvStatus *Mat_GetVec4f_Async(Mat self, int row, int col, Vec4f *rval); +// CvStatus *Mat_GetVec6f_Async(Mat self, int row, int col, Vec6f *rval); +// CvStatus *Mat_GetVec2d_Async(Mat self, int row, int col, Vec2d *rval); +// CvStatus *Mat_GetVec3d_Async(Mat self, int row, int col, Vec3d *rval); +// CvStatus *Mat_GetVec4d_Async(Mat self, int row, int col, Vec4d *rval); +// CvStatus *Mat_GetVec6d_Async(Mat self, int row, int col, Vec6d *rval); -CvStatus *Mat_SetVec2b_Async(Mat m, int row, int col, Vec2b val); -CvStatus *Mat_SetVec3b_Async(Mat m, int row, int col, Vec3b val); -CvStatus *Mat_SetVec4b_Async(Mat m, int row, int col, Vec4b val); -CvStatus *Mat_SetVec2s_Async(Mat m, int row, int col, Vec2s val); -CvStatus *Mat_SetVec3s_Async(Mat m, int row, int col, Vec3s val); -CvStatus *Mat_SetVec4s_Async(Mat m, int row, int col, Vec4s val); -CvStatus *Mat_SetVec2w_Async(Mat m, int row, int col, Vec2w val); -CvStatus *Mat_SetVec3w_Async(Mat m, int row, int col, Vec3w val); -CvStatus *Mat_SetVec4w_Async(Mat m, int row, int col, Vec4w val); -CvStatus *Mat_SetVec2i_Async(Mat m, int row, int col, Vec2i val); -CvStatus *Mat_SetVec3i_Async(Mat m, int row, int col, Vec3i val); -CvStatus *Mat_SetVec4i_Async(Mat m, int row, int col, Vec4i val); -CvStatus *Mat_SetVec6i_Async(Mat m, int row, int col, Vec6i val); -CvStatus *Mat_SetVec8i_Async(Mat m, int row, int col, Vec8i val); -CvStatus *Mat_SetVec2f_Async(Mat m, int row, int col, Vec2f val); -CvStatus *Mat_SetVec3f_Async(Mat m, int row, int col, Vec3f val); -CvStatus *Mat_SetVec4f_Async(Mat m, int row, int col, Vec4f val); -CvStatus *Mat_SetVec6f_Async(Mat m, int row, int col, Vec6f val); -CvStatus *Mat_SetVec2d_Async(Mat m, int row, int col, Vec2d val); -CvStatus *Mat_SetVec3d_Async(Mat m, int row, int col, Vec3d val); -CvStatus *Mat_SetVec4d_Async(Mat m, int row, int col, Vec4d val); -CvStatus *Mat_SetVec6d_Async(Mat m, int row, int col, Vec6d val); +// #pragma endregion -#pragma endregion Mat_setter +// #pragma region Mat_setter + +// CvStatus *Mat_SetTo_Async(Mat self, Scalar value); +// CvStatus *Mat_SetUChar_Async(Mat self, int row, int col, uint8_t val); +// CvStatus *Mat_SetUChar3_Async(Mat self, int x, int y, int z, uint8_t val); +// CvStatus *Mat_SetSChar_Async(Mat self, int row, int col, int8_t val); +// CvStatus *Mat_SetSChar3_Async(Mat self, int x, int y, int z, int8_t val); +// CvStatus *Mat_SetShort_Async(Mat self, int row, int col, int16_t val); +// CvStatus *Mat_SetShort3_Async(Mat self, int x, int y, int z, int16_t val); +// CvStatus *Mat_SetUShort_Async(Mat self, int row, int col, uint16_t val); +// CvStatus *Mat_SetUShort3_Async(Mat self, int x, int y, int z, uint16_t val); +// CvStatus *Mat_SetInt_Async(Mat self, int row, int col, int32_t val); +// CvStatus *Mat_SetInt3_Async(Mat self, int x, int y, int z, int32_t val); +// CvStatus *Mat_SetFloat_Async(Mat self, int row, int col, float val); +// CvStatus *Mat_SetFloat3_Async(Mat self, int x, int y, int z, float val); +// CvStatus *Mat_SetDouble_Async(Mat self, int row, int col, double val); +// CvStatus *Mat_SetDouble3_Async(Mat self, int x, int y, int z, double val); + +// CvStatus *Mat_SetVec2b_Async(Mat self, int row, int col, Vec2b val); +// CvStatus *Mat_SetVec3b_Async(Mat self, int row, int col, Vec3b val); +// CvStatus *Mat_SetVec4b_Async(Mat self, int row, int col, Vec4b val); +// CvStatus *Mat_SetVec2s_Async(Mat self, int row, int col, Vec2s val); +// CvStatus *Mat_SetVec3s_Async(Mat self, int row, int col, Vec3s val); +// CvStatus *Mat_SetVec4s_Async(Mat self, int row, int col, Vec4s val); +// CvStatus *Mat_SetVec2w_Async(Mat self, int row, int col, Vec2w val); +// CvStatus *Mat_SetVec3w_Async(Mat self, int row, int col, Vec3w val); +// CvStatus *Mat_SetVec4w_Async(Mat self, int row, int col, Vec4w val); +// CvStatus *Mat_SetVec2i_Async(Mat self, int row, int col, Vec2i val); +// CvStatus *Mat_SetVec3i_Async(Mat self, int row, int col, Vec3i val); +// CvStatus *Mat_SetVec4i_Async(Mat self, int row, int col, Vec4i val); +// CvStatus *Mat_SetVec6i_Async(Mat self, int row, int col, Vec6i val); +// CvStatus *Mat_SetVec8i_Async(Mat self, int row, int col, Vec8i val); +// CvStatus *Mat_SetVec2f_Async(Mat self, int row, int col, Vec2f val); +// CvStatus *Mat_SetVec3f_Async(Mat self, int row, int col, Vec3f val); +// CvStatus *Mat_SetVec4f_Async(Mat self, int row, int col, Vec4f val); +// CvStatus *Mat_SetVec6f_Async(Mat self, int row, int col, Vec6f val); +// CvStatus *Mat_SetVec2d_Async(Mat self, int row, int col, Vec2d val); +// CvStatus *Mat_SetVec3d_Async(Mat self, int row, int col, Vec3d val); +// CvStatus *Mat_SetVec4d_Async(Mat self, int row, int col, Vec4d val); +// CvStatus *Mat_SetVec6d_Async(Mat self, int row, int col, Vec6d val); + +// #pragma endregion Mat_setter #pragma region Mat_operation -CvStatus *Mat_AddUChar_Async(Mat m, uint8_t val); -CvStatus *Mat_SubtractUChar_Async(Mat m, uint8_t val); -CvStatus *Mat_MultiplyUChar_Async(Mat m, uint8_t val); -CvStatus *Mat_DivideUChar_Async(Mat m, uint8_t val); +// CvStatus *Mat_AddUChar_Async(Mat self, uint8_t val); +// CvStatus *Mat_SubtractUChar_Async(Mat self, uint8_t val); +// CvStatus *Mat_MultiplyUChar_Async(Mat self, uint8_t val); +// CvStatus *Mat_DivideUChar_Async(Mat self, uint8_t val); -CvStatus *Mat_AddSChar_Async(Mat m, int8_t val); -CvStatus *Mat_SubtractSChar_Async(Mat m, int8_t val); -CvStatus *Mat_MultiplySChar_Async(Mat m, int8_t val); -CvStatus *Mat_DivideSChar_Async(Mat m, int8_t val); +// CvStatus *Mat_AddSChar_Async(Mat self, int8_t val); +// CvStatus *Mat_SubtractSChar_Async(Mat self, int8_t val); +// CvStatus *Mat_MultiplySChar_Async(Mat self, int8_t val); +// CvStatus *Mat_DivideSChar_Async(Mat self, int8_t val); -CvStatus *Mat_AddI32_Async(Mat m, int32_t val); -CvStatus *Mat_SubtractI32_Async(Mat m, int32_t val); -CvStatus *Mat_MultiplyI32_Async(Mat m, int32_t val); -CvStatus *Mat_DivideI32_Async(Mat m, int32_t val); +// CvStatus *Mat_AddI32_Async(Mat self, int32_t val); +// CvStatus *Mat_SubtractI32_Async(Mat self, int32_t val); +// CvStatus *Mat_MultiplyI32_Async(Mat self, int32_t val); +// CvStatus *Mat_DivideI32_Async(Mat self, int32_t val); -CvStatus *Mat_AddFloat_Async(Mat m, float_t val); -CvStatus *Mat_SubtractFloat_Async(Mat m, float_t val); -CvStatus *Mat_MultiplyFloat_Async(Mat m, float_t val); -CvStatus *Mat_DivideFloat_Async(Mat m, float_t val); +// CvStatus *Mat_AddFloat_Async(Mat self, float_t val); +// CvStatus *Mat_SubtractFloat_Async(Mat self, float_t val); +// CvStatus *Mat_MultiplyFloat_Async(Mat self, float_t val); +// CvStatus *Mat_DivideFloat_Async(Mat self, float_t val); -CvStatus *Mat_AddF64_Async(Mat m, double_t val); -CvStatus *Mat_SubtractF64_Async(Mat m, double_t val); -CvStatus *Mat_MultiplyF64_Async(Mat m, double_t val); -CvStatus *Mat_DivideF64_Async(Mat m, double_t val); -CvStatus *Mat_MultiplyMatrix_Async(Mat x, Mat y, CvCallback_1 callback); +// CvStatus *Mat_AddF64_Async(Mat self, double_t val); +// CvStatus *Mat_SubtractF64_Async(Mat self, double_t val); +// CvStatus *Mat_MultiplyF64_Async(Mat self, double_t val); +// CvStatus *Mat_DivideF64_Async(Mat self, double_t val); +// CvStatus *Mat_MultiplyMatrix_Async(Mat x, Mat y, CvCallback_1 callback); -CvStatus *Mat_AbsDiff_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_Add_Async(Mat src1, Mat src2, Mat dst); -CvStatus * -Mat_AddWeighted_Async(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst); -CvStatus *Mat_BitwiseAnd_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_BitwiseAndWithMask_Async(Mat src1, Mat src2, Mat dst, Mat mask); -CvStatus *Mat_BitwiseNot_Async(Mat src1, Mat dst); -CvStatus *Mat_BitwiseNotWithMask_Async(Mat src1, Mat dst, Mat mask); -CvStatus *Mat_BitwiseOr_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_BitwiseOrWithMask_Async(Mat src1, Mat src2, Mat dst, Mat mask); -CvStatus *Mat_BitwiseXor_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_BitwiseXorWithMask_Async(Mat src1, Mat src2, Mat dst, Mat mask); -CvStatus *Mat_Compare_Async(Mat src1, Mat src2, Mat dst, int ct); -CvStatus *Mat_BatchDistance_Async( +CvStatus *core_PatchNaNs_Async(Mat self, double val, CvCallback_0 callback); +// Deprecated: +// Use Mat::convertTo with CV_16F instead. +// CvStatus *Mat_ConvertFp16_Async(Mat self, CvCallback_1 callback); +CvStatus *core_Mean_Async(Mat self, CvCallback_1 callback); // Scalar *rval +CvStatus *core_MeanWithMask_Async(Mat self, Mat mask, CvCallback_1 callback); // Scalar *rval +CvStatus *core_Sqrt_Async(Mat self, CvCallback_1 callback); +CvStatus *core_AbsDiff_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_Add_Async(Mat src1, Mat src2, Mat mask, int dtype, CvCallback_1 callback); +CvStatus *core_AddWeighted_Async( + Mat src1, double alpha, Mat src2, double beta, double gamma, int dtype, CvCallback_1 callback +); +CvStatus *core_BitwiseAnd_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_BitwiseAndWithMask_Async(Mat src1, Mat src2, Mat mask, CvCallback_1 callback); +CvStatus *core_BitwiseNot_Async(Mat src1, CvCallback_1 callback); +CvStatus *core_BitwiseNotWithMask_Async(Mat src1, Mat mask, CvCallback_1 callback); +CvStatus *core_BitwiseOr_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_BitwiseOrWithMask_Async(Mat src1, Mat src2, Mat mask, CvCallback_1 callback); +CvStatus *core_BitwiseXor_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_BitwiseXorWithMask_Async(Mat src1, Mat src2, Mat mask, CvCallback_1 callback); +CvStatus *core_Compare_Async(Mat src1, Mat src2, int ct, CvCallback_1 callback); +CvStatus *core_BatchDistance_Async( Mat src1, Mat src2, - Mat dist, int dtype, - Mat nidx, int normType, int K, Mat mask, int update, - bool crosscheck + bool crosscheck, + CvCallback_2 callback +); // Mat dist,Mat nidx, +CvStatus * +core_BorderInterpolate_Async(int p, int len, int borderType, CvCallback_1 callback); // int *rval +CvStatus *core_CalcCovarMatrix_Async( + Mat samples, Mat mean, int flags, int ctype, CvCallback_1 callback +); // Mat covar +CvStatus *core_CartToPolar_Async( + Mat x, Mat y, bool angleInDegrees, CvCallback_2 callback +); // Mat magnitude, Mat angle +CvStatus *core_CheckRange_Async( + Mat self, bool quiet, double minVal, double maxVal, CvCallback_2 callback +); // bool *rval, Point *pos +CvStatus *core_CompleteSymm_Async(Mat self, bool lowerToUpper, CvCallback_0 callback); +CvStatus *core_ConvertScaleAbs_Async(Mat src, double alpha, double beta, CvCallback_1 callback); +CvStatus *core_CopyMakeBorder_Async( + Mat src, + int top, + int bottom, + int left, + int right, + int borderType, + Scalar value, + CvCallback_1 callback ); -CvStatus *Mat_BorderInterpolate_Async(int p, int len, int borderType, int *rval); -CvStatus *Mat_CalcCovarMatrix_Async(Mat samples, Mat covar, Mat mean, int flags, int ctype); -CvStatus *Mat_CartToPolar_Async(Mat x, Mat y, Mat magnitude, Mat angle, bool angleInDegrees); +CvStatus *core_CountNonZero_Async(Mat src, CvCallback_1 callback); // int *rval +CvStatus *core_DCT_Async(Mat src, int flags, CvCallback_1 callback); +CvStatus *core_Determinant_Async(Mat self, CvCallback_1 callback); +CvStatus *core_DFT_Async(Mat self, int flags, int nonzeroRows, CvCallback_1 callback); +CvStatus *core_Divide_Async(Mat src1, Mat src2, double scale, int dtype, CvCallback_1 callback); +CvStatus * +core_Eigen_Async(Mat src, CvCallback_3 callback); // Mat eigenvalues, Mat eigenvectors, bool *rval CvStatus * -Mat_CheckRange_Async(Mat m, bool quiet, Point *pos, double minVal, double maxVal, bool *rval); -CvStatus *Mat_CompleteSymm_Async(Mat m, bool lowerToUpper); -CvStatus *Mat_ConvertScaleAbs_Async(Mat src, Mat dst, double alpha, double beta); -CvStatus *Mat_CopyMakeBorder_Async( - Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value +core_EigenNonSymmetric_Async(Mat src, CvCallback_2 callback); // Mat eigenvalues, Mat eigenvectors + +CvStatus *core_PCABackProject_Async(Mat src, Mat mean, Mat eigenvectors, CvCallback_1 callback); +CvStatus * +core_PCACompute_3_Async(Mat src, Mat mean, double retainedVariance, CvCallback_1 callback); +CvStatus *core_PCACompute_1_Async(Mat src, Mat mean, int maxComponents, CvCallback_1 callback); +CvStatus * +core_PCACompute_2_Async(Mat src, Mat mean, double retainedVariance, CvCallback_2 callback); +CvStatus *core_PCACompute_Async(Mat src, Mat mean, int maxComponents, CvCallback_2 callback); +CvStatus *core_PCAProject_Async(Mat src, Mat mean, Mat eigenvectors, CvCallback_1 callback); + +CvStatus *core_Exp_Async(Mat src, CvCallback_1 callback); +CvStatus *core_ExtractChannel_Async(Mat src, int coi, CvCallback_1 callback); +CvStatus *core_FindNonZero_Async(Mat src, CvCallback_1 callback); +CvStatus *core_Flip_Async(Mat src, int flipCode, CvCallback_1 callback); +CvStatus *core_Gemm_Async( + Mat src1, Mat src2, double alpha, Mat src3, double beta, int flags, CvCallback_1 callback ); -CvStatus *Mat_CountNonZero_Async(Mat src, int *rval); -CvStatus *Mat_DCT_Async(Mat src, Mat dst, int flags); -CvStatus *Mat_Determinant_Async(Mat m, double *rval); -CvStatus *Mat_DFT_Async(Mat m, Mat dst, int flags); -CvStatus *Mat_Divide_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_Eigen_Async(Mat src, Mat eigenvalues, Mat eigenvectors, bool *rval); -CvStatus *Mat_EigenNonSymmetric_Async(Mat src, Mat eigenvalues, Mat eigenvectors); +CvStatus *core_GetOptimalDFTSize_Async(int vecsize, CvCallback_1 callback); +CvStatus *core_Hconcat_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_Vconcat_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_Idct_Async(Mat src, int flags, CvCallback_1 callback); +CvStatus *core_Idft_Async(Mat src, int flags, int nonzeroRows, CvCallback_1 callback); +CvStatus *core_InRange_Async(Mat src, Mat lowerb, Mat upperb, CvCallback_1 callback); +CvStatus *core_InRangeWithScalar_Async( + Mat src, const Scalar lowerb, const Scalar upperb, CvCallback_1 callback +); +CvStatus *core_InsertChannel_Async(Mat src, Mat dst, int coi, CvCallback_0 callback); +CvStatus *core_Invert_Async(Mat src, int flags, CvCallback_2 callback); +CvStatus *core_Log_Async(Mat src, CvCallback_1 callback); +CvStatus *core_Magnitude_Async(Mat x, Mat y, CvCallback_1 callback); +CvStatus *core_Max_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_MeanStdDev_Async(Mat src, CvCallback_2 callback); // Scalar *dstMean, Scalar + // *dstStdDev +CvStatus *core_MeanStdDevWithMask_Async( + Mat src, Mat mask, CvCallback_2 callback +); // Scalar *dstMean, Scalar *dstStdDev +CvStatus *core_Merge_Async(VecMat mats, CvCallback_1 callback); +CvStatus *core_Min_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus *core_MinMaxIdx_Async( + Mat self, CvCallback_4 callback +); // double *minVal, double *maxVal, int *minIdx, int *maxIdx +CvStatus *core_MinMaxIdx_Mask_Async(Mat self, Mat mask, CvCallback_4 callback); +CvStatus *core_MinMaxLoc_Async( + Mat self, CvCallback_4 callback +); // double *minVal, double *maxVal, Point *minLoc, Point *maxLoc +CvStatus *core_MinMaxLoc_Mask_Async(Mat self, Mat mask, CvCallback_4 callback); +CvStatus *core_MixChannels_Async(VecMat src, VecMat dst, VecInt fromTo, CvCallback_0 callback); +CvStatus *core_MulSpectrums_Async(Mat a, Mat b, int flags, bool conjB, CvCallback_1 callback); +CvStatus *core_Multiply_Async(Mat src1, Mat src2, CvCallback_1 callback); +CvStatus * +core_MultiplyWithParams_Async(Mat src1, Mat src2, double scale, int dtype, CvCallback_1 callback); CvStatus * -Mat_PCACompute_Async(Mat src, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents); -CvStatus *Mat_Exp_Async(Mat src, Mat dst); -CvStatus *Mat_ExtractChannel_Async(Mat src, Mat dst, int coi); -CvStatus *Mat_FindNonZero_Async(Mat src, Mat idx); -CvStatus *Mat_Flip_Async(Mat src, Mat dst, int flipCode); +core_Normalize_Async(Mat src, Mat dst, double alpha, double beta, int typ, int dtype, CvCallback_0 callback); +CvStatus *core_Normalize_Mask_Async( + Mat src, Mat dst, double alpha, double beta, int typ, int dtype, Mat mask, CvCallback_0 callback +); +CvStatus *core_PerspectiveTransform_Async(Mat src, Mat tm, CvCallback_1 callback); CvStatus * -Mat_Gemm_Async(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags); -CvStatus *Mat_GetOptimalDFTSize_Async(int vecsize, int *rval); -CvStatus *Mat_Hconcat_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_Vconcat_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_Idct_Async(Mat src, Mat dst, int flags); -CvStatus *Mat_Idft_Async(Mat src, Mat dst, int flags, int nonzeroRows); -CvStatus *Mat_InRange_Async(Mat src, Mat lowerb, Mat upperb, Mat dst); -CvStatus *Mat_InRangeWithScalar_Async(Mat src, const Scalar lowerb, const Scalar upperb, Mat dst); -CvStatus *Mat_InsertChannel_Async(Mat src, Mat dst, int coi); -CvStatus *Mat_Invert_Async(Mat src, Mat dst, int flags, double *rval); -CvStatus *Mat_Log_Async(Mat src, Mat dst); -CvStatus *Mat_Magnitude_Async(Mat x, Mat y, Mat magnitude); -CvStatus *Mat_Max_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_MeanStdDev_Async(Mat src, Scalar *dstMean, Scalar *dstStdDev); -CvStatus *Mat_MeanStdDevWithMask_Async(Mat src, Scalar *dstMean, Scalar *dstStdDev, Mat mask); -CvStatus *Mat_Merge_Async(VecMat mats, Mat dst); -CvStatus *Mat_Min_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_MinMaxIdx_Async(Mat m, double *minVal, double *maxVal, int *minIdx, int *maxIdx); -CvStatus *Mat_MinMaxLoc_Async(Mat m, double *minVal, double *maxVal, Point *minLoc, Point *maxLoc); -CvStatus *Mat_MixChannels_Async(VecMat src, VecMat dst, VecInt fromTo); -CvStatus *Mat_MulSpectrums_Async(Mat a, Mat b, Mat c, int flags); -CvStatus *Mat_Multiply_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_MultiplyWithParams_Async(Mat src1, Mat src2, Mat dst, double scale, int dtype); -CvStatus *Mat_Normalize_Async(Mat src, Mat dst, double alpha, double beta, int typ); -CvStatus *Mat_PerspectiveTransform_Async(Mat src, Mat dst, Mat tm); -CvStatus *Mat_Solve_Async(Mat src1, Mat src2, Mat dst, int flags, bool *rval); -CvStatus *Mat_SolveCubic_Async(Mat coeffs, Mat roots, int *rval); -CvStatus *Mat_SolvePoly_Async(Mat coeffs, Mat roots, int maxIters, double *rval); -CvStatus *Mat_Reduce_Async(Mat src, Mat dst, int dim, int rType, int dType); -CvStatus *Mat_ReduceArgMax_Async(Mat src, Mat dst, int axis, bool lastIndex); -CvStatus *Mat_ReduceArgMin_Async(Mat src, Mat dst, int axis, bool lastIndex); -CvStatus *Mat_Repeat_Async(Mat src, int nY, int nX, Mat dst); -CvStatus *Mat_ScaleAdd_Async(Mat src1, double alpha, Mat src2, Mat dst); -CvStatus *Mat_SetIdentity_Async(Mat src, double scalar); -CvStatus *Mat_Sort_Async(Mat src, Mat dst, int flags); -CvStatus *Mat_SortIdx_Async(Mat src, Mat dst, int flags); -CvStatus *Mat_Split_Async(Mat src, VecMat *rval); -CvStatus *Mat_Subtract_Async(Mat src1, Mat src2, Mat dst); -CvStatus *Mat_T_Async(Mat x, CvCallback_1 callback); -CvStatus *Mat_Trace_Async(Mat src, Scalar *rval); -CvStatus *Mat_Transform_Async(Mat src, Mat dst, Mat tm); -CvStatus *Mat_Transpose_Async(Mat src, Mat dst); -CvStatus *Mat_PolarToCart_Async(Mat magnitude, Mat degree, Mat x, Mat y, bool angleInDegrees); -CvStatus *Mat_Pow_Async(Mat src, double power, Mat dst); -CvStatus *Mat_Phase_Async(Mat x, Mat y, Mat angle, bool angleInDegrees); -CvStatus *Mat_Sum_Async(Mat src, Scalar *rval); -CvStatus *Mat_rowRange_Async(Mat m, int start, int end, CvCallback_1 callback); -CvStatus *Mat_colRange_Async(Mat m, int start, int end, CvCallback_1 callback); -CvStatus *LUT_Async(Mat src, Mat lut, Mat dst); -CvStatus *KMeans_Async( +core_Solve_Async(Mat src1, Mat src2, int flags, CvCallback_2 callback); // bool *rval, Mat dst +CvStatus *core_SolveCubic_Async(Mat coeffs, CvCallback_2 callback); // int *rval, Mat roots +CvStatus * +core_SolvePoly_Async(Mat coeffs, int maxIters, CvCallback_2 callback); // double *rval, Mat roots +CvStatus *core_Reduce_Async(Mat src, int dim, int rType, int dType, CvCallback_1 callback); +CvStatus *core_ReduceArgMax_Async(Mat src, int axis, bool lastIndex, CvCallback_1 callback); +CvStatus *core_ReduceArgMin_Async(Mat src, int axis, bool lastIndex, CvCallback_1 callback); +CvStatus *core_Repeat_Async(Mat src, int nY, int nX, CvCallback_1 callback); +CvStatus *core_ScaleAdd_Async(Mat src1, double alpha, Mat src2, CvCallback_1 callback); +CvStatus *core_SetIdentity_Async(Mat src, Scalar scalar, CvCallback_0 callback); +CvStatus *core_Sort_Async(Mat src, int flags, CvCallback_1 callback); +CvStatus *core_SortIdx_Async(Mat src, int flags, CvCallback_1 callback); +CvStatus *core_Split_Async(Mat src, CvCallback_1 callback); // VecMat *rval +CvStatus *core_Subtract_Async(Mat src1, Mat src2, Mat mask, int dtype, CvCallback_1 callback); +CvStatus *core_T_Async(Mat x, CvCallback_1 callback); +CvStatus *core_Trace_Async(Mat src, CvCallback_1 callback); +CvStatus *core_Transform_Async(Mat src, Mat tm, CvCallback_1 callback); +CvStatus *core_Transpose_Async(Mat src, CvCallback_1 callback); +CvStatus *core_PolarToCart_Async( + Mat magnitude, Mat degree, bool angleInDegrees, CvCallback_2 callback +); // Mat x, Mat y +CvStatus *core_Pow_Async(Mat src, double power, CvCallback_1 callback); +CvStatus *core_Phase_Async(Mat x, Mat y, bool angleInDegrees, CvCallback_1 callback); // Mat angle +CvStatus *core_Sum_Async(Mat src, CvCallback_1 callback); +CvStatus *core_rowRange_Async(Mat self, int start, int end, CvCallback_1 callback); +CvStatus *core_colRange_Async(Mat self, int start, int end, CvCallback_1 callback); + +CvStatus *core_LUT_Async(Mat src, Mat lut, CvCallback_1 callback); +CvStatus *core_KMeans_Async( Mat data, int k, Mat bestLabels, TermCriteria criteria, int attempts, int flags, - Mat centers, - double *rval -); -CvStatus *KMeansPoints_Async( + CvCallback_2 callback +); // double *rval, Mat centers +CvStatus *core_KMeans_Points_Async( VecPoint2f pts, int k, Mat bestLabels, TermCriteria criteria, int attempts, int flags, - Mat centers, - double *rval -); -CvStatus *Rotate_Async(Mat src, Mat dst, int rotateCode); -CvStatus *Norm_Async(Mat src1, int normType, double *rval); -CvStatus *NormWithMats_Async(Mat src1, Mat src2, int normType, double *rval); + CvCallback_2 callback +); // double *rval, Mat centers +CvStatus *core_Rotate_Async(Mat src, int rotateCode, CvCallback_1 callback); +CvStatus *core_Norm_Async(Mat src1, int normType, CvCallback_1 callback); +CvStatus *core_Norm_Mask_Async(Mat src1, int normType, Mat mask, CvCallback_1 callback); +CvStatus *core_NormWithMats_Async(Mat src1, Mat src2, int normType, CvCallback_1 callback); #pragma endregion #pragma region RNG -CvStatus *Rng_New_Async(RNG *rval); -CvStatus *Rng_NewWithState_Async(uint64_t state, RNG *rval); -void Rng_Close_Async(RNGPtr rng); -CvStatus *TheRNG_Async(RNG *rval); -CvStatus *SetRNGSeed_Async(int seed); -CvStatus *RNG_Fill_Async(RNG rng, Mat mat, int distType, double a, double b, bool saturateRange); -CvStatus *RNG_Gaussian_Async(RNG rng, double sigma, double *rval); -CvStatus *RNG_Uniform_Async(RNG rng, int a, int b, int *rval); -CvStatus *RNG_UniformDouble_Async(RNG rng, double a, double b, double *rval); -CvStatus *RNG_Next_Async(RNG rng, uint32_t *rval); -CvStatus *RandN_Async(Mat mat, Scalar mean, Scalar stddev); -CvStatus *RandShuffle_Async(Mat mat); -CvStatus *RandShuffleWithParams_Async(Mat mat, double iterFactor, RNG rng); -CvStatus *RandU_Async(Mat mat, Scalar low, Scalar high); -#pragma endregion +CvStatus *Rng_New_Async(CvCallback_1 callback); +CvStatus *Rng_NewWithState_Async(uint64_t state, CvCallback_1 callback); +CvStatus *RNG_Fill_Async(RNG rng, Mat mat, int distType, double a, double b, bool saturateRange, CvCallback_0 callback); +CvStatus *RNG_Gaussian_Async(RNG rng, double sigma, CvCallback_1 callback); +CvStatus *RNG_Uniform_Async(RNG rng, int a, int b, CvCallback_1 callback); +CvStatus *RNG_UniformDouble_Async(RNG rng, double a, double b, CvCallback_1 callback); +CvStatus *RNG_Next_Async(RNG rng, CvCallback_1 callback); // uint32_t *rval -CvStatus *GetCVTickCount_Async(int64_t *rval); -CvStatus *GetTickFrequency_Async(double *rval); -CvStatus *SetNumThreads_Async(int n); -CvStatus *GetNumThreads_Async(int *rval); +CvStatus *RandN_Async(Mat mat, Scalar mean, Scalar stddev, CvCallback_0 callback); +CvStatus *RandShuffle_Async(Mat mat, CvCallback_0 callback); +CvStatus *RandShuffleWithParams_Async(Mat mat, double iterFactor, RNG rng, CvCallback_0 callback); +CvStatus *RandU_Async(Mat mat, Scalar low, Scalar high, CvCallback_0 callback); +#pragma endregion #ifdef __cplusplus } diff --git a/test/core/core_async_test.dart b/test/core/core_async_test.dart new file mode 100644 index 00000000..a8fbd10b --- /dev/null +++ b/test/core/core_async_test.dart @@ -0,0 +1,691 @@ +// ignore_for_file: avoid_print + +import 'package:opencv_dart/opencv_dart.dart' as cv; +import 'package:test/test.dart'; + +void main() async { + test('openCvVersionAsync', () async { + final version = await cv.openCvVersionAsync(); + expect(version.length, greaterThan(0)); + }); + + test('cv.getBuildInformationAsync', () async { + final info = await cv.getBuildInformationAsync(); + expect(info.length, greaterThan(0)); + }); + + test('cv.absDiffAsync', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC3); + final dst = await cv.absDiffAsync(mat0, mat1); + expect(dst.at(0, 0, 0), equals(1)); + }); + + test('cv.addAsync', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC3); + final dst = await cv.addAsync(mat0, mat1); + expect(dst.at(0, 0, 0), equals(1)); + }); + + test('cv.addWeightedAsync', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(100)); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(50)); + final dst = await cv.addWeightedAsync(mat0, 0.5, mat1, 0.5, 1); + expect(dst.at(0, 0, 0), equals(75 + 1)); + }); + + test('cv.bitwise_and async', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(100)); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(50)); + final dst = await cv.bitwiseANDAsync(mat0, mat1); + expect(dst.at(0, 0, 0), equals(100 & 50)); + }); + + test('cv.bitwise_not async', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(100)); + final dst = await cv.bitwiseNOTAsync(mat0); + expect(dst.at(0, 0, 0), equals(155)); + }); + + test('cv.bitwise_or async', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(100)); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(50)); + final dst = await cv.bitwiseORAsync(mat0, mat1); + expect(dst.at(0, 0, 0), equals(100 | 50)); + }); + + test('cv.bitwise_xor async', () async { + final mat0 = cv.Mat.ones(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(100)); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC3).setTo(cv.Scalar.all(50)); + final dst = await cv.bitwiseXORAsync(mat0, mat1); + expect(dst.at(0, 0, 0), equals(100 ^ 50)); + }); + + test('cv.batchDistance async', () async { + final mat0 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC1); + final mat1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC1); + final mask = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC1); + final (dist, _) = await cv.batchDistanceAsync(mat0, mat1, -1, K: 15, mask: mask); + expect(dist.isEmpty, equals(false)); + }); + + test('cv.borderInterpolate async', () async { + final n = await cv.borderInterpolateAsync(1, 5, cv.BORDER_DEFAULT); + expect(n != 0, equals(true)); + }); + + test('cv.calcCovarMatrix async', () async { + final samples = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + final mean = cv.Mat.empty(); + final (covar, _) = await cv.calcCovarMatrixAsync(samples, mean, cv.COVAR_ROWS); + expect(covar.isEmpty, equals(false)); + }); + + test('cv.cartToPolar async', () async { + final x = cv.Mat.zeros(100, 100, cv.MatType.CV_32FC1); + final y = cv.Mat.zeros(100, 100, cv.MatType.CV_32FC1); + final (magnitude, angle) = await cv.cartToPolarAsync(x, y, angleInDegrees: false); + expect(magnitude.isEmpty || angle.isEmpty, equals(false)); + }); + + test('cv.checkRange async', () async { + final mat1 = cv.Mat.zeros(101, 102, cv.MatType.CV_8UC1); + final (success, pos) = await cv.checkRangeAsync(mat1); + expect(success, equals(true)); + expect(pos, equals(cv.Point(0, 0))); + }); + + test('cv.compare async', () async { + final mat1 = cv.Mat.zeros(101, 102, cv.MatType.CV_8UC1); + final mat2 = cv.Mat.zeros(101, 102, cv.MatType.CV_8UC1); + final dst = await cv.compareAsync(mat1, mat2, cv.CMP_EQ); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.countNonZero async', () async { + final mat1 = cv.Mat.ones(101, 102, cv.MatType.CV_8UC1); + final n = await cv.countNonZeroAsync(mat1); + expect(n, equals(101 * 102)); + }); + + test('cv.completeSymm async', () async { + final mat1 = cv.Mat.randn(100, 100, cv.MatType.CV_32FC1); + await cv.completeSymmAsync(mat1); + expect(mat1.at(99, 0), equals(mat1.at(0, 99))); + }); + + test("cv.convertScaleAbs async", () async { + final src = cv.Mat.create(cols: 100, rows: 100, type: cv.MatType.CV_32FC1); + final dst = await cv.convertScaleAbsAsync(src, alpha: 1, beta: 0); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.copyMakeBorder async', () async { + final src = cv.Mat.randn(100, 100, cv.MatType.CV_32FC1); + final dst = await cv.copyMakeBorderAsync(src, 10, 10, 10, 10, cv.BORDER_REFLECT, value: cv.Scalar.all(0)); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.dct async', () async { + final src = cv.Mat.randn(100, 100, cv.MatType.CV_32FC1); + final dst = await cv.dctAsync(src); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.determinant async', () async { + final src = cv.Mat.zeros(101, 101, cv.MatType.CV_32FC1); + final ret = await cv.determinantAsync(src); + expect(ret, equals(0)); + }); + + test('cv.dft async', () async { + final src = cv.Mat.randn(101, 102, cv.MatType.CV_32FC1); + final m = await cv.getOptimalDFTSizeAsync(101); + final n = await cv.getOptimalDFTSizeAsync(102); + expect(m, equals(108)); + expect(n, equals(108)); + final dst = await cv.dftAsync(src); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.divide async', () async { + final mat1 = cv.Mat.ones(101, 102, cv.MatType.CV_32FC1); + final mat2 = cv.Mat.ones(101, 102, cv.MatType.CV_32FC1); + final dst = await cv.divideAsync(mat1, mat2); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.eigen async', () async { + final src = cv.Mat.randn(10, 10, cv.MatType.CV_32FC1); + final (_, eigenValues, eigenVectors) = await cv.eigenAsync(src); + expect(eigenValues.isEmpty || eigenVectors.isEmpty, equals(false)); + }); + + test('cv.eigenNonSymmetric async', () async { + final src = cv.Mat.randn(10, 10, cv.MatType.CV_32FC1); + final (eigenValues, eigenVectors) = await cv.eigenNonSymmetricAsync(src); + expect(eigenValues.isEmpty || eigenVectors.isEmpty, equals(false)); + }); + + test('cv.PCACompute async', () async { + final src = cv.Mat.randn(10, 10, cv.MatType.CV_32FC1); + final mean = cv.Mat.empty(); + final (_, eigenvectors, eigenvalues) = await cv.PCAComputeAsync( + src, + mean, + maxComponents: 2, + ); + expect(mean.isEmpty || eigenvectors.isEmpty || eigenvalues.isEmpty, equals(false)); + expect(eigenvectors.rows, equals(2)); + }); + + test('cv.exp async', () async { + final src = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + final dst = await cv.expAsync(src); + expect(dst.isEmpty, equals(false)); + expect(dst.at(0, 0), equals(1)); + }); + + test('cv.extractChannel async', () async { + final src = cv.Mat.randn(10, 10, cv.MatType.CV_32FC3); + final dst = await cv.extractChannelAsync(src, 2); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.findNonZero async', () async { + final src = cv.Mat.randu(10, 10, cv.MatType.CV_8UC1); + final dst = await cv.findNonZeroAsync(src); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.flip async', () async { + final src = cv.Mat.randu(10, 10, cv.MatType.CV_8UC1); + final dst = await cv.flipAsync(src, 0); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.gemm async', () async { + final src1 = cv.Mat.randu(3, 4, cv.MatType.CV_32FC1); + final src2 = cv.Mat.randu(4, 3, cv.MatType.CV_32FC1); + final src3 = cv.Mat.empty(); + final dst = await cv.gemmAsync(src1, src2, 1, src3, 0); + expect(dst.isEmpty, equals(false)); + expect(dst.rows, equals(src1.rows)); + }); + + test('cv.hconcat async', () async { + final src = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + final dst = await cv.hconcatAsync(src, src); + expect(dst.isEmpty, equals(false)); + expect(dst.cols, equals(src.cols * 2)); + }); + + test('cv.vconcat async', () async { + final src = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + final dst = await cv.vconcatAsync(src, src); + expect(dst.isEmpty, equals(false)); + expect(dst.rows, equals(src.rows * 2)); + }); + + test('cv.rotate async', () async { + final src = cv.Mat.zeros(10, 20, cv.MatType.CV_8UC1); + final dst = await cv.rotateAsync(src, cv.ROTATE_90_CLOCKWISE); + expect(dst.isEmpty, equals(false)); + expect((dst.rows, dst.cols), (src.cols, src.rows)); + }); + + test('cv.idct async', () async { + final src = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final dst = await cv.idctAsync(src); + expect(dst.isEmpty, equals(false)); + expect(dst.rows, equals(src.rows)); + }); + + test('cv.idft async', () async { + final src = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final dst = await cv.idftAsync(src); + expect(dst.isEmpty, equals(false)); + expect(dst.rows, equals(src.rows)); + }); + + test('cv.inRange async', () async { + final mat1 = cv.Mat.randu(101, 102, cv.MatType.CV_8UC1); + final lb = cv.Mat.fromScalar(1, 1, cv.MatType.CV_8UC1, cv.Scalar(20, 100, 100, 0)); + final ub = cv.Mat.fromScalar(1, 1, cv.MatType.CV_8UC1, cv.Scalar(20, 100, 100, 0)); + final dst = await cv.inRangeAsync(mat1, lb, ub); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.inRangebyScalar async', () async { + final mat1 = cv.Mat.randu(101, 102, cv.MatType.CV_8UC1); + final lb = cv.Scalar(20, 100, 100, 0); + final ub = cv.Scalar(20, 100, 100, 0); + final dst = await cv.inRangebyScalarAsync(mat1, lb, ub); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.insertChannel async', () async { + final src = cv.Mat.randu(4, 4, cv.MatType.CV_8UC1); + final dst = cv.Mat.randu(4, 4, cv.MatType.CV_8UC3); + await cv.insertChannelAsync(src, dst, 1); + expect(dst.channels, equals(3)); + }); + + test('cv.invert async', () async { + final src = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final (_, dst) = await cv.invertAsync(src); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.kmeans async', () async { + final src = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final bestLabels = cv.Mat.empty(); + const criteria = (cv.TERM_COUNT, 10, 1.0); + final (_, _, centers) = await cv.kmeansAsync(src, 2, bestLabels, criteria, 2, cv.KMEANS_RANDOM_CENTERS); + expect(centers.isEmpty, equals(false)); + }); + + test('cv.kmeansByPoints async', () async { + final src = [cv.Point2f(0, 0), cv.Point2f(1, 1)].cvd; + final bestLabels = cv.Mat.empty(); + const criteria = (cv.TERM_COUNT, 10, 1.0); + final (_, _, centers) = + await cv.kmeansByPointsAsync(src, 2, bestLabels, criteria, 2, cv.KMEANS_RANDOM_CENTERS); + expect(centers.isEmpty, equals(false)); + }); + + test('cv.log async', () async { + final src = cv.Mat.randu(4, 3, cv.MatType.CV_32FC1); + final dst = await cv.logAsync(src); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.LUT async', () async { + Future testOneLUT(cv.Mat src, cv.Mat lut) async { + expect(lut.channels == src.channels || lut.channels == 1, true); + expect(lut.isContinus, true); + final sw = Stopwatch(); + sw.start(); + final dst = await cv.LUTAsync(src, lut); + sw.stop(); + // print('${src.type} -> ${lut.type}(${src.rows}x${src.cols}): ${sw.elapsedMilliseconds}ms'); + expect(dst.isEmpty, false); + expect(src.shape, dst.shape); + } + + final depthSrc = [cv.MatType.CV_8U, cv.MatType.CV_8S, cv.MatType.CV_16U, cv.MatType.CV_16S]; + final depthLut = [ + cv.MatType.CV_8U, + cv.MatType.CV_8S, + cv.MatType.CV_16U, + cv.MatType.CV_16S, + cv.MatType.CV_32S, + cv.MatType.CV_32F, + cv.MatType.CV_64F, + ]; + for (final int channel in [1, 2, 3, 4]) { + for (final depth in depthSrc) { + final srcType = cv.MatType.makeType(depth, channel); + final src = cv.Mat.randu(3, 3, srcType, low: cv.Scalar.all(0), high: cv.Scalar.all(255)); + final lutSize = switch (depth) { + cv.MatType.CV_8U || cv.MatType.CV_8S => 256, + cv.MatType.CV_16U || cv.MatType.CV_16S => 65536, + _ => throw Exception("Unsupported type"), + }; + for (final lutDepth in depthLut) { + final lutType = cv.MatType.makeType(lutDepth, channel); + // 0-1: 65536-1-0 2-3: 65536-1-1 3-4: 65536-1-2 + final lutData = switch (lutDepth) { + cv.MatType.CV_32F || + cv.MatType.CV_64F => + List.generate(lutSize * lutType.channels, (i) => (lutSize - (i ~/ channel) - 1).toDouble()), + _ => List.generate(lutSize * lutType.channels, (i) => lutSize - (i ~/ channel) - 1), + }; + final lutInverse = cv.Mat.fromList(1, lutSize, lutType, lutData); + await testOneLUT(src, lutInverse); + } + } + } + }); + + test('cv.LUT 1 async', () async { + final mat = cv.imread("test/images/lenna.png", flags: cv.IMREAD_COLOR); + final src = mat.convertTo(cv.MatType.CV_16UC3, alpha: 65536.0 / 255.0); + final lutData = List.generate(65536 * 3, (i) => 65536 - (i ~/ 3) - 1); + final lut = cv.Mat.fromList(1, 65536, cv.MatType.CV_16UC3, lutData); + final dst = await cv.LUTAsync(src, lut); + expect(dst.isEmpty, equals(false)); + expect(dst.shape, src.shape); + // cv.imwrite("lut.png", dst.convertTo(cv.MatType.CV_8UC3, alpha: 255.0/65536.0)); + }); + + test('cv.magnitude async', () async { + final src1 = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final src2 = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final dst = await cv.magnitudeAsync(src1, src2); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.max async', () async { + final src1 = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final src2 = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final dst = await cv.maxAsync(src1, src2); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.min async', () async { + final src1 = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final src2 = cv.Mat.randu(4, 4, cv.MatType.CV_32FC1); + final dst = await cv.minAsync(src1, src2); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.meanStdDev async', () async { + final src = cv.Mat.randu(101, 102, cv.MatType.CV_8UC3); + final (mean, stdDev) = await cv.meanStdDevAsync(src); + expect(mean.val, isNotEmpty); + expect(stdDev.val, isNotEmpty); + }); + + test('cv.merge async', () async { + final src = [ + cv.Mat.randu(101, 102, cv.MatType.CV_8UC1), + cv.Mat.randu(101, 102, cv.MatType.CV_8UC1), + cv.Mat.randu(101, 102, cv.MatType.CV_8UC1), + ].cvd; + final dst = await cv.mergeAsync(src); + expect(dst.isEmpty, equals(false)); + expect(dst.channels, equals(3)); + }); + + test('cv.minMaxIdx async', () async { + final src = cv.Mat.randu(10, 10, cv.MatType.CV_32FC1); + final (min, max, minIdx, maxIdx) = await cv.minMaxIdxAsync(src); + expect(minIdx, greaterThanOrEqualTo(0)); + expect(maxIdx, greaterThanOrEqualTo(0)); + expect(max > min, equals(true)); + }); + + test('cv.minMaxLoc async', () async { + final src = cv.Mat.randu(10, 10, cv.MatType.CV_32FC1); + final (min, max, minLoc, maxLoc) = await cv.minMaxLocAsync(src); + expect(minLoc.x, greaterThanOrEqualTo(0)); + expect(maxLoc.x, greaterThanOrEqualTo(0)); + expect(max > min, equals(true)); + }); + + test('cv.mixChannels async', () async { + final bgra = cv.Mat.fromScalar(100, 100, cv.MatType.CV_8UC4, cv.Scalar(255, 0, 0, 255)); + final bgr = cv.Mat.create(cols: bgra.cols, rows: bgra.rows, type: cv.MatType.CV_8UC3); + final alpha = cv.Mat.create(cols: bgra.cols, rows: bgra.rows, type: cv.MatType.CV_8UC1); + final out = [bgr, alpha].cvd; + final fromTo = [0, 2, 1, 1, 2, 0, 3, 3].i32; + final dst = await cv.mixChannelsAsync([bgra].cvd, out, fromTo); + expect(dst.isEmpty, false); + }); + + test('cv.mulSpectrums async', () async { + final a = cv.Mat.zeros(101, 102, cv.MatType.CV_32FC1); + final b = cv.Mat.zeros(101, 102, cv.MatType.CV_32FC1); + + final dst = await cv.mulSpectrumsAsync(a, b, 0); + expect(dst.isEmpty, false); + + final dst1 = await cv.mulSpectrumsAsync(a, b, cv.DFT_ROWS); + expect(dst1.isEmpty, false); + }); + + test('cv.multiply async', () async { + final mat1 = cv.Mat.randn(101, 102, cv.MatType.CV_64FC1); + final mat2 = cv.Mat.randn(101, 102, cv.MatType.CV_64FC1); + final mat3 = await cv.multiplyAsync(mat1, mat2); + expect(mat3.isEmpty, equals(false)); + expect(mat3.at(0, 0), equals(mat1.at(0, 0) * mat2.at(0, 0))); + }); + + test('cv.normalize async', () async { + final src = cv.Mat.randn(101, 102, cv.MatType.CV_8UC1); + final dst = cv.Mat.empty(); + await cv.normalizeAsync(src, dst); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.norm async', () async { + final src1 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC1); + final n = await cv.normAsync(src1); + expect(n, equals(0)); + + final src2 = cv.Mat.zeros(100, 100, cv.MatType.CV_8UC1); + final n1 = await cv.norm1Async(src1, src2); + expect(n1, equals(0)); + }); + + test('cv.perspectiveTransform async', () async { + final src = cv.Mat.zeros(100, 1, cv.MatType.CV_32FC2); + final tm = cv.Mat.zeros(3, 3, cv.MatType.CV_32FC1); + final dst = await cv.perspectiveTransformAsync(src, tm); + expect(dst.isEmpty, equals(false)); + }); + + test('cv.solve async', () async { + final a = cv.Mat.zeros(3, 3, cv.MatType.CV_32FC1); + final b = cv.Mat.zeros(3, 1, cv.MatType.CV_32FC1); + final testPoints = [ + (1.0, 1.0, 1.0, 0.0), + (0.0, 0.0, 1.0, 2.0), + (9.0, 3.0, 1.0, 2.0), + ]; + for (var i = 0; i < testPoints.length; i++) { + a.set(i, 0, testPoints[i].$1); + a.set(i, 1, testPoints[i].$2); + a.set(i, 2, testPoints[i].$3); + b.set(i, 0, testPoints[i].$4); + } + final (solved, solve) = await cv.solveAsync(a, b, flags: cv.DECOMP_LU); + expect(solved, equals(true)); + expect((solve.at(0, 0), solve.at(1, 0), solve.at(2, 0)), (1, -3, 2)); + }); + + test('cv.solveCubic async', () async { + final coeffs = cv.Mat.zeros(1, 4, cv.MatType.CV_32FC1); + coeffs.set(0, 0, 2.0); + coeffs.set(0, 1, 3.0); + coeffs.set(0, 2, -11.0); + coeffs.set(0, 3, -6.0); + + final (rootsCount, roots) = await cv.solveCubicAsync(coeffs); + expect(rootsCount, equals(3)); + expect((roots.at(0, 0), roots.at(0, 1), roots.at(0, 2)), (-3.0, 2.0, -0.5)); + }); + + test('cv.solvePoly async', () async { + final coeffs = cv.Mat.zeros(1, 3, cv.MatType.CV_32FC1); + coeffs.set(0, 0, 49.0); + coeffs.set(0, 1, -14.0); + coeffs.set(0, 2, 1.0); + + final (diffError, roots) = await cv.solvePolyAsync(coeffs); + expect(diffError, lessThan(1.0e-61)); + expect(roots.at(0, 0), equals(7.0)); + }); + + test('cv.reduce async', () async { + final src = cv.Mat.randu(2, 3, cv.MatType.CV_8UC1); + for (var i = 0; i < src.rows; i++) { + for (var j = 0; j < src.cols; j++) { + src.set(i, j, j + 1); + } + } + final dst = await cv.reduceAsync(src, 0, cv.REDUCE_SUM, dtype: cv.MatType.CV_32FC1.value); + expect((dst.rows, dst.cols), equals((1, 3))); + expect((dst.at(0, 0), dst.at(0, 1), dst.at(0, 2)), (2, 4, 6)); + + final dst1 = await cv.reduceAsync(src, 1, cv.REDUCE_SUM, dtype: cv.MatType.CV_32FC1.value); + expect((dst1.rows, dst1.cols), equals((2, 1))); + expect((dst1.at(0, 0), dst1.at(1, 0)), (6, 6)); + }); + + test('cv.reduceArgMax async', () async { + final src = cv.Mat.randu(2, 3, cv.MatType.CV_8UC1); + for (var i = 0; i < src.rows; i++) { + for (var j = 0; j < src.cols; j++) { + src.set(i, j, j + 1); + } + } + final dst = await cv.reduceArgMaxAsync(src, 1); + expect((dst.rows, dst.cols), equals((2, 1))); + expect((dst.at(0, 0), dst.at(1, 0)), (2, 2)); + }); + + test('cv.reduceArgMin async', () async { + final src = cv.Mat.randu(2, 3, cv.MatType.CV_8UC1); + for (var i = 0; i < src.rows; i++) { + for (var j = 0; j < src.cols; j++) { + src.set(i, j, j + 1); + } + } + final dst = await cv.reduceArgMinAsync(src, 1); + expect((dst.rows, dst.cols), equals((2, 1))); + expect((dst.at(0, 0), dst.at(1, 0)), (0, 0)); + }); + + test('cv.repeat async', () async { + final src = cv.Mat.randu(1, 3, cv.MatType.CV_8UC1); + for (var i = 0; i < src.rows; i++) { + for (var j = 0; j < src.cols; j++) { + src.set(i, j, j); + } + } + final dst = await cv.repeatAsync(src, 3, 1); + expect((dst.rows, dst.cols), equals((3, 3))); + }); + + test('cv.scaleAdd async', () async { + final src = cv.Mat.randu(2, 3, cv.MatType.CV_64FC1); + final src2 = cv.Mat.randu(2, 3, cv.MatType.CV_64FC1); + final dst = await cv.scaleAddAsync(src, 0.6, src2); + expect(dst.at(0, 0), closeTo(src.at(0, 0) * 0.6 + src2.at(0, 0), 1e-4)); + }); + + test('cv.setIdentity async', () async { + final src = cv.Mat.randu(4, 3, cv.MatType.CV_64FC1); + await cv.setIdentityAsync(src, s: cv.Scalar.all(2.5)); + expect(src.isEmpty, false); + expect((src.at(0, 0), src.at(1, 1), src.at(2, 2)), (2.5, 2.5, 2.5)); + }); + + test('cv.sort async', () async { + final src = cv.Mat.randu(2, 3, cv.MatType.CV_8UC1); + for (var i = 0; i < src.rows; i++) { + for (var j = 0; j < src.cols; j++) { + src.set(i, j, j); + } + } + final dst = await cv.sortAsync(src, cv.SORT_EVERY_ROW + cv.SORT_DESCENDING); + expect(dst.isEmpty, false); + expect(dst.at(0, 0), 2); + }); + + test('cv.sortIdx async', () async { + final src = cv.Mat.randu(2, 3, cv.MatType.CV_8UC1); + for (var i = 0; i < src.rows; i++) { + for (var j = 0; j < src.cols; j++) { + src.set(i, j, j); + } + } + final dst = await cv.sortIdxAsync(src, cv.SORT_EVERY_ROW + cv.SORT_DESCENDING); + expect(dst.isEmpty, false); + + expect(dst.at(0, 0), 2); + }); + + test('cv.split async', () async { + final src = cv.imread("test/images/lenna.png", flags: cv.IMREAD_COLOR); + final chans = cv.split(src); + expect(chans.length, equals(src.channels)); + + final dst = await cv.mergeAsync(chans); + expect(dst.isEmpty, false); + + final diff = await cv.absDiffAsync(src, dst); + expect(diff.isEmpty, false); + + final sum = diff.sum(); + expect(sum, equals(cv.Scalar.black)); + }); + + test('cv.subtract async', () async { + final src1 = cv.Mat.zeros(10, 10, cv.MatType.CV_8UC3); + final src2 = cv.Mat.ones(10, 10, cv.MatType.CV_8UC3); + final dst = await cv.subtractAsync(src2, src1); + expect(dst.isEmpty, false); + expect(dst.at(0, 0), equals(1)); + }); + + test('cv.trace async', () async { + final src = cv.Mat.randu(3, 3, cv.MatType.CV_8UC1); + for (var row = 0; row < src.rows; row++) { + for (var col = 0; col < src.cols; col++) { + if (row == col) { + src.set(row, col, 1); + } + } + } + + final trace = await cv.traceAsync(src); + expect(trace, equals(cv.Scalar(3, 0, 0, 0))); + }); + + test('cv.transform async', () async { + final src = cv.Mat.randu(3, 3, cv.MatType.CV_8UC3); + final tm = cv.Mat.zeros(4, 4, cv.MatType.CV_8UC4); + final dst = await cv.transformAsync(src, tm); + expect(dst.isEmpty, false); + }); + + test('cv.transpose async', () async { + final src = cv.imread("test/images/lenna.png", flags: cv.IMREAD_COLOR); + final dst = await cv.transposeAsync(src); + expect((dst.rows, dst.cols), (src.cols, src.rows)); + }); + + test('cv.pow async', () async { + final src = cv.Mat.fromScalar(512, 512, cv.MatType.CV_8UC3, cv.Scalar.all(2)); + final dst = await cv.powAsync(src, 3); + expect(dst.at(0, 0), 8); + }); + + test('cv.polarToCart async', () async { + final magnitude = cv.Mat.zeros(101, 102, cv.MatType.CV_32FC1); + final angle = cv.Mat.zeros(101, 102, cv.MatType.CV_32FC1); + final (x, y) = await cv.polarToCartAsync(magnitude, angle); + expect(x.isEmpty || y.isEmpty, false); + }); + + test('cv.phase async', () async { + final x = cv.Mat.fromScalar(1, 1, cv.MatType.CV_32FC1, cv.Scalar(1.1, 2.2, 3.3, 4.4)); + final y = cv.Mat.fromScalar(1, 1, cv.MatType.CV_32FC1, cv.Scalar(5.5, 6.6, 7.7, 8.8)); + final angle = await cv.phaseAsync(x, y); + expect(angle.isEmpty, false); + expect(angle.rows, equals(x.rows)); + }); + + test('cv.randn async', () async { + final dst = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + await cv.randnAsync(dst, cv.Scalar.all(10), cv.Scalar.all(1)); + expect(dst.isEmpty, false); + }); + + test('cv.randu async', () async { + final dst = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + await cv.randuAsync(dst, cv.Scalar.all(10), cv.Scalar.all(100)); + expect(dst.isEmpty, false); + }); + + test('cv.randShuffle async', () async { + final dst = cv.Mat.zeros(10, 10, cv.MatType.CV_32FC1); + await cv.randShuffleAsync(dst); + expect(dst.isEmpty, false); + }); +} diff --git a/test/core/mat_async_test.dart b/test/core/mat_async_test.dart new file mode 100644 index 00000000..acee0523 --- /dev/null +++ b/test/core/mat_async_test.dart @@ -0,0 +1,125 @@ +import 'package:opencv_dart/opencv_dart.dart' as cv; +import 'package:test/test.dart'; + +void main() async { + test('Mat Creation Async', () async { + final mat0 = await cv.MatAsync.emptyAsync(); + expect(mat0.isEmpty, true); + + final mat1 = await cv.MatAsync.createAsync(cols: 100, rows: 100, r: 255, g: 255, b: 255); + expect(mat1.isEmpty, equals(false)); + expect((mat1.width, mat1.height, mat1.channels), (100, 100, 3)); + expect(mat1.type, cv.MatType.CV_8UC3); + expect(mat1.total, equals(100 * 100)); + expect(mat1.isContinus, equals(true)); + expect(mat1.step, equals(100 * 3)); + expect(mat1.elemSize, equals(3)); + expect(mat1.at(0, 0, 0), 255); + + final mat2 = await cv.MatAsync.zerosAsync(3, 3, cv.MatType.CV_8UC1); + expect((mat2.width, mat2.height, mat2.channels), (3, 3, 1)); + expect(mat2.countNoneZero, equals(0)); + mat2.setU8(0, 0, 241); + expect(mat2.toList()[0][0], 241); + + final mat3 = await cv.MatAsync.eyeAsync(3, 3, cv.MatType.CV_8UC3); + expect((mat3.width, mat3.height, mat3.channels), (3, 3, 3)); + final expected3 = List.generate( + mat3.rows, + (row) => List.generate( + mat3.cols, + (col) => List.generate(mat3.channels, (c) => row == col && c == 0 ? 1 : 0), + ), + ); + expect(mat3.toList3D(), expected3); + + final mat4 = await cv.MatAsync.onesAsync(100, 100, cv.MatType.CV_8UC3); + expect((mat4.width, mat4.height, mat4.channels), (100, 100, 3)); + + final mat5 = await mat4.convertToAsync(cv.MatType.CV_8UC1); + mat5.setTo(cv.Scalar.all(255)); + expect(mat5.at(0, 0), equals(255)); + }); + + test('cv.MatAsync.fromVecAsync', () async { + final points = [cv.Point(1, 2), cv.Point(3, 4), cv.Point(5, 6), cv.Point(7, 8)]; + final mat = await cv.MatAsync.fromVecAsync(points.cvd); + expect(mat.rows, equals(4)); + expect(mat.cols, equals(1)); + expect(mat.channels, equals(2)); + expect(mat.at(0, 0), 1); + + final points1 = [cv.Point2f(1, 2), cv.Point2f(3, 4), cv.Point2f(5, 6), cv.Point2f(7, 8)]; + final mat1 = await cv.MatAsync.fromVecAsync(points1.cvd); + expect(mat1.rows, equals(4)); + expect(mat1.cols, equals(1)); + expect(mat1.channels, equals(2)); + expect(mat1.at(0, 0), 1); + + final points2 = [cv.Point3f(1, 2, 1), cv.Point3f(3, 4, 3), cv.Point3f(5, 6, 5), cv.Point3f(7, 8, 7)]; + final mat2 = await cv.MatAsync.fromVecAsync(points2.cvd); + expect(mat2.rows, equals(4)); + expect(mat2.cols, equals(1)); + expect(mat2.channels, equals(3)); + expect(mat2.at(0, 0), 1); + }); + + test('cv.MatAsync Operations', () async { + final mat1 = await cv.MatAsync.fromScalarAsync(3, 3, cv.MatType.CV_16UC3, cv.Scalar.all(999)); + expect(mat1.at(0, 0), equals(999)); + + final mat2 = await mat1.cloneAsync(); + expect(mat2.at(0, 0), mat1.at(0, 0)); + + final mat3 = await mat2.regionAsync(cv.Rect(0, 0, 2, 2)); + expect(mat3.rows, equals(2)); + expect(mat3.cols, equals(2)); + expect(mat3.at(0, 0), equals(999)); + + final mat4 = await cv.MatAsync.emptyAsync(); + await mat1.copyToAsync(mat4); + + final mat5 = await mat1.reshapeAsync(3, 9); + expect(mat5.rows, equals(9)); + expect(mat5.cols, equals(1)); + }); + + test('Mat Rotate async', () async { + final mat0 = await cv.MatAsync.onesAsync(200, 100, cv.MatType.CV_8UC3); + final mat1 = await mat0.rotateAsync(cv.ROTATE_90_CLOCKWISE); + expect((mat1.height, mat1.width, mat1.channels), (100, 200, 3)); + + final mat2 = await mat1.rotateAsync(cv.ROTATE_90_CLOCKWISE); + expect((mat2.height, mat2.width, mat2.channels), (200, 100, 3)); + }); + + test('Mat test others Async', () async { + final mat0 = await cv.MatAsync.fromScalarAsync(200, 100, cv.MatType.CV_8UC3, cv.Scalar.all(1)); + expect(mat0.props, equals([mat0.ptr.address])); + final data = mat0.data; + expect(data.length, greaterThan(0)); + + final mean_ = await mat0.meanAsync(); + expect(mean_.val1, equals(1)); + + final sum_ = await mat0.sumAsync(); + expect(sum_.val1, equals(200 * 100)); + + final mat1 = await mat0.convertToAsync(cv.MatType.CV_32FC3); + expect(mat1.at(0, 0), 1); + final sqrt_ = await mat1.sqrtAsync(); + expect(sqrt_.at(0, 0), equals(1.0)); + + final matB = await cv.extractChannelAsync(mat0, 0); + final meanB = await matB.meanAsync(); + expect(meanB.val1, equals(1)); + final sumB = await matB.sumAsync(); + expect(sumB.val1, equals(200 * 100)); + + final matG = await cv.extractChannelAsync(mat0, 1); + final meanG = await matG.meanAsync(); + expect(meanG.val1, equals(1)); + + await matG.convertTo(cv.MatType.CV_32FC1).patchNaNsAsync(val: 1); + }); +} diff --git a/test/core/rng_async_test.dart b/test/core/rng_async_test.dart new file mode 100644 index 00000000..92001d21 --- /dev/null +++ b/test/core/rng_async_test.dart @@ -0,0 +1,33 @@ +import 'package:opencv_dart/opencv_dart.dart' as cv; +import 'package:test/test.dart'; + +void main() async { + test("cv.RNG", () async { + final rng = await cv.RngAsync.createAsync(); + final v = List.generate(100000, (index) => rng.uniform(0, 241)); + expect(v, everyElement(greaterThanOrEqualTo(0))); + final v1 = List.generate(100000, (index) => rng.uniform(2.41, 241.0)); + expect(v1, everyElement(greaterThanOrEqualTo(2.41))); + + rng.dispose(); + }); + + test("cv.RNG.fromSeed", () async { + final rng = await cv.RngAsync.fromSeedAsync(241); + final v = List.generate(100000, (index) => rng.gaussian(2.41)); + expect(v.length, equals(100000)); + + final v1 = await rng.nextAsync(); + expect(v1, isA()); + + final rng1 = cv.Rng.fromSeed(241); + expect(rng == rng1, false); + }); + + test("cv.RNG.fill", () async { + final rng = cv.Rng.fromSeed(241); + final mat = cv.Mat.zeros(241, 241, cv.MatType.CV_32FC3); + await rng.fillAsync(mat, cv.RNG_DIST_NORMAL, 0, 10, inplace: true); + expect(mat.at(0, 0) != 0, true); + }); +}