Async imgproc

lib/opencv_dart.dart

@@ -34,8 +34,11 @@ export 'src/highgui/highgui.dart';
 export 'src/imgcodecs/imgcodecs.dart';
 export 'src/imgcodecs/imgcodecs_async.dart';
 export 'src/imgproc/clahe.dart';
+export 'src/imgproc/clahe_async.dart';
 export 'src/imgproc/imgproc.dart';
+export 'src/imgproc/imgproc_async.dart';
 export 'src/imgproc/subdiv2d.dart';
+export 'src/imgproc/subdiv2d_async.dart';
 export 'src/objdetect/objdetect.dart';
 export 'src/objdetect/objdetect_async.dart';
 export 'src/photo/photo.dart';

lib/src/core/base.dart

@@ -13,7 +13,6 @@ import 'package:ffi/ffi.dart';
 
 import "../opencv.g.dart" as cvg;
 import "exception.dart" show CvException;
-import 'mat.dart';
 
 const _libraryName = "opencv_dart";
 
@@ -153,13 +152,7 @@ Future<T> cvRunAsync3<T>(
 
 Future<T> cvRunAsync4<T>(
   ffi.Pointer<cvg.CvStatus> Function(cvg.CvCallback_4 callback) func,
-  void Function(
-    Completer<T> completer,
-    VoidPtr p,
-    VoidPtr p1,
-    VoidPtr p2,
-    VoidPtr p3,
-  ) onComplete,
+  void Function(Completer<T> completer, VoidPtr p, VoidPtr p1, VoidPtr p2, VoidPtr p3) onComplete,
 ) {
   final completer = Completer<T>();
   late final NativeCallable<cvg.CvCallback_4Function> ccallback;
@@ -189,12 +182,24 @@ Future<T> cvRunAsync5<T>(
   return completer.future;
 }
 
-// Completers for async
-void matCompleter(Completer<Mat> completer, VoidPtr p) => completer.complete(Mat.fromPointer(p.cast()));
-void matCompleter2(Completer<(Mat, Mat)> completer, VoidPtr p, VoidPtr p1) =>
-    completer.complete((Mat.fromPointer(p.cast()), Mat.fromPointer(p1.cast())));
-void matCompleter3(Completer<(Mat, Mat, Mat)> completer, VoidPtr p, VoidPtr p1, VoidPtr p2) =>
-    completer.complete((Mat.fromPointer(p.cast()), Mat.fromPointer(p1.cast()), Mat.fromPointer(p2.cast())));
+// async completers
+void intCompleter(Completer<int> completer, VoidPtr p) {
+  final value = p.cast<ffi.Int>().value;
+  calloc.free(p);
+  completer.complete(value);
+}
+
+void doubleCompleter(Completer<double> completer, VoidPtr p) {
+  final value = p.cast<ffi.Double>().value;
+  calloc.free(p);
+  completer.complete(value);
+}
+
+void floatCompleter(Completer<double> completer, VoidPtr p) {
+  final value = p.cast<ffi.Float>().value;
+  calloc.free(p);
+  completer.complete(value);
+}
 
 // Arena wrapper
 R cvRunArena<R>(

lib/src/core/core.dart

@@ -26,6 +26,12 @@ String openCvVersion() {
   return s;
 }
 
+Future<String> openCvVersionAsync() async => cvRunAsync(CFFI.openCVVersion_Async, (c, p) {
+      final s = p.cast<ffi.Pointer<ffi.Char>>().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.
@@ -37,6 +43,12 @@ String getBuildInformation() {
   return s;
 }
 
+Future<String> getBuildInformationAsync() async => cvRunAsync(CFFI.getBuildInfo_Async, (c, p) {
+      final s = p.cast<ffi.Pointer<ffi.Char>>().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.
 ///

lib/src/core/cv_vec.dart

@@ -4,6 +4,7 @@ import 'package:ffi/ffi.dart';
 
 import '../opencv.g.dart' as cvg;
 import 'base.dart';
+import 'vec.dart';
 
 abstract class CvVec<T extends ffi.Struct> extends CvStruct<T> {
   CvVec.fromPointer(super.ptr) : super.fromPointer();
@@ -1069,3 +1070,177 @@ class Vec6d extends CvVec<cvg.Vec6d> {
   String toString() =>
       "Vec6d(${val1.toStringAsFixed(3)}, ${val2.toStringAsFixed(3)}, ${val3.toStringAsFixed(3)}, ${val4.toStringAsFixed(3)}, ${val5.toStringAsFixed(3)}, ${val6.toStringAsFixed(3)})";
 }
+
+class VecVec4i extends Vec<Vec4i> implements CvStruct<cvg.VecVec4i> {
+  VecVec4i._(this.ptr, [bool attach = true]) {
+    if (attach) {
+      finalizer.attach(this, ptr.cast(), detach: this);
+    }
+  }
+
+  factory VecVec4i.fromPointer(cvg.VecVec4iPtr ptr, [bool attach = true]) => VecVec4i._(ptr, attach);
+
+  factory VecVec4i.fromList(List<Vec4i> pts) {
+    final ptr = calloc<cvg.VecVec4i>();
+    cvRun(() => CFFI.VecVec4i_New(ptr));
+    for (var i = 0; i < pts.length; i++) {
+      final p = pts[i];
+      cvRun(() => CFFI.VecVec4i_Append(ptr.ref, p.ref));
+    }
+    final vec = VecVec4i._(ptr);
+    return vec;
+  }
+
+  @override
+  cvg.VecVec4iPtr ptr;
+  static final finalizer = OcvFinalizer<cvg.VecVec4iPtr>(CFFI.addresses.VecVec4i_Close);
+
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.VecVec4i_Close(ptr);
+  }
+
+  @override
+  Iterator<Vec4i> get iterator => VecVec4iIterator(ref);
+
+  @override
+  cvg.VecVec4i get ref => ptr.ref;
+}
+
+class VecVec4iIterator extends VecIterator<Vec4i> {
+  VecVec4iIterator(this.ptr);
+  cvg.VecVec4i ptr;
+
+  @override
+  int get length {
+    return using<int>((arena) {
+      final p = arena<ffi.Int>();
+      cvRun(() => CFFI.VecVec4i_Size(ptr, p));
+      final len = p.value;
+      return len;
+    });
+  }
+
+  @override
+  Vec4i operator [](int idx) {
+    final p = calloc<cvg.Vec4i>();
+    cvRun(() => CFFI.VecVec4i_At(ptr, idx, p));
+    return Vec4i.fromPointer(p);
+  }
+}
+
+class VecVec4f extends Vec<Vec4f> implements CvStruct<cvg.VecVec4f> {
+  VecVec4f._(this.ptr, [bool attach = true]) {
+    if (attach) {
+      finalizer.attach(this, ptr.cast(), detach: this);
+    }
+  }
+
+  factory VecVec4f.fromPointer(cvg.VecVec4fPtr ptr, [bool attach = true]) => VecVec4f._(ptr, attach);
+
+  factory VecVec4f.fromList(List<Vec4f> pts) {
+    final ptr = calloc<cvg.VecVec4f>();
+    cvRun(() => CFFI.VecVec4f_New(ptr));
+    for (var i = 0; i < pts.length; i++) {
+      final p = pts[i];
+      cvRun(() => CFFI.VecVec4f_Append(ptr.ref, p.ref));
+    }
+    final vec = VecVec4f._(ptr);
+    return vec;
+  }
+
+  @override
+  cvg.VecVec4fPtr ptr;
+  static final finalizer = OcvFinalizer<cvg.VecVec4fPtr>(CFFI.addresses.VecVec4f_Close);
+
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.VecVec4f_Close(ptr);
+  }
+
+  @override
+  Iterator<Vec4f> get iterator => VecVec4fIterator(ref);
+
+  @override
+  cvg.VecVec4f get ref => ptr.ref;
+}
+
+class VecVec4fIterator extends VecIterator<Vec4f> {
+  VecVec4fIterator(this.ptr);
+  cvg.VecVec4f ptr;
+
+  @override
+  int get length {
+    return using<int>((arena) {
+      final p = arena<ffi.Int>();
+      cvRun(() => CFFI.VecVec4f_Size(ptr, p));
+      final len = p.value;
+      return len;
+    });
+  }
+
+  @override
+  Vec4f operator [](int idx) {
+    final p = calloc<cvg.Vec4f>();
+    cvRun(() => CFFI.VecVec4f_At(ptr, idx, p));
+    return Vec4f.fromPointer(p);
+  }
+}
+
+class VecVec6f extends Vec<Vec6f> implements CvStruct<cvg.VecVec6f> {
+  VecVec6f._(this.ptr, [bool attach = true]) {
+    if (attach) {
+      finalizer.attach(this, ptr.cast(), detach: this);
+    }
+  }
+
+  factory VecVec6f.fromPointer(cvg.VecVec6fPtr ptr, [bool attach = true]) => VecVec6f._(ptr, attach);
+
+  factory VecVec6f.fromList(List<Vec6f> pts) {
+    final ptr = calloc<cvg.VecVec6f>();
+    cvRun(() => CFFI.VecVec6f_New(ptr));
+    for (var i = 0; i < pts.length; i++) {
+      final p = pts[i];
+      cvRun(() => CFFI.VecVec6f_Append(ptr.ref, p.ref));
+    }
+    final vec = VecVec6f._(ptr);
+    return vec;
+  }
+
+  @override
+  cvg.VecVec6fPtr ptr;
+  static final finalizer = OcvFinalizer<cvg.VecVec6fPtr>(CFFI.addresses.VecVec6f_Close);
+
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.VecVec6f_Close(ptr);
+  }
+
+  @override
+  Iterator<Vec6f> get iterator => VecVec6fIterator(ref);
+
+  @override
+  cvg.VecVec6f get ref => ptr.ref;
+}
+
+class VecVec6fIterator extends VecIterator<Vec6f> {
+  VecVec6fIterator(this.ptr);
+  cvg.VecVec6f ptr;
+
+  @override
+  int get length {
+    return using<int>((arena) {
+      final p = arena<ffi.Int>();
+      cvRun(() => CFFI.VecVec6f_Size(ptr, p));
+      final len = p.value;
+      return len;
+    });
+  }
+
+  @override
+  Vec6f operator [](int idx) {
+    final p = calloc<cvg.Vec6f>();
+    cvRun(() => CFFI.VecVec6f_At(ptr, idx, p));
+    return Vec6f.fromPointer(p);
+  }
+}

lib/src/core/mat.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:ffi' as ffi;
 import 'dart:typed_data';
 
@@ -1410,3 +1411,17 @@ class VecMatIterator extends VecIterator<Mat> {
 extension ListMatExtension on List<Mat> {
   VecMat get cvd => VecMat.fromList(this);
 }
+
+// Completers for async
+void matCompleter(Completer<Mat> completer, VoidPtr p) =>
+    completer.complete(Mat.fromPointer(p.cast<cvg.Mat>()));
+void matCompleter2(Completer<(Mat, Mat)> completer, VoidPtr p, VoidPtr p1) =>
+    completer.complete((Mat.fromPointer(p.cast<cvg.Mat>()), Mat.fromPointer(p1.cast<cvg.Mat>())));
+void matCompleter3(Completer<(Mat, Mat, Mat)> completer, VoidPtr p, VoidPtr p1, VoidPtr p2) =>
+    completer.complete(
+      (
+        Mat.fromPointer(p.cast<cvg.Mat>()),
+        Mat.fromPointer(p1.cast<cvg.Mat>()),
+        Mat.fromPointer(p2.cast<cvg.Mat>())
+      ),
+    );

lib/src/core/moments.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:ffi' as ffi;
 
 import 'package:ffi/ffi.dart';
@@ -85,3 +86,8 @@ class Moments extends CvStruct<cvg.Moment> {
         nu03,
       ];
 }
+
+// async completer
+void momentsCompleter(Completer<Moments> completer, VoidPtr p) {
+  completer.complete(Moments.fromPointer(p.cast<cvg.Moment>()));
+}

lib/src/core/point.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:ffi' as ffi;
 
 import 'package:ffi/ffi.dart';
@@ -615,3 +616,10 @@ extension Point3fRecordExtension on (double x, double y, double z) {
     return point;
   }
 }
+
+// completers
+void vecPointCompleter(Completer<VecPoint> completer, VoidPtr p) =>
+    completer.complete(VecPoint.fromPointer(p.cast<cvg.VecPoint>()));
+
+void vecPoint2fCompleter(Completer<VecPoint2f> completer, VoidPtr p) =>
+    completer.complete(VecPoint2f.fromPointer(p.cast<cvg.VecPoint2f>()));

lib/src/core/rect.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:ffi' as ffi;
 
 import 'package:ffi/ffi.dart';
@@ -220,3 +221,10 @@ class VecRectIterator extends VecIterator<Rect> {
 extension ListRectExtension on List<Rect> {
   VecRect get cvd => VecRect.fromList(this);
 }
+
+// Completers for async
+void rectCompleter(Completer<Rect> completer, VoidPtr p) =>
+    completer.complete(Rect.fromPointer(p.cast<cvg.Rect>()));
+
+void rotatedRectCompleter(Completer<RotatedRect> completer, VoidPtr p) =>
+    completer.complete(RotatedRect.fromPointer(p.cast<cvg.RotatedRect>()));

lib/src/core/scalar.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:ffi' as ffi;
 import 'dart:math' as math;
 
@@ -100,3 +101,8 @@ extension RecordScalarExtension on (double val1, double val2, double val3, doubl
     return scalar;
   }
 }
+
+// async completer
+void scalarCompleter(Completer<Scalar> completer, VoidPtr p) {
+  completer.complete(Scalar.fromPointer(p.cast<cvg.Scalar>()));
+}

lib/src/core/vec.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:ffi' as ffi;
@@ -515,3 +516,13 @@ extension ListDoubleExtension on List<double> {
 extension ListStringExtension on List<String> {
   VecVecChar get i8 => VecVecChar.fromList(map((e) => e.i8.toList()).toList());
 }
+
+// async completers
+void vecIntCompleter(Completer<VecInt> completer, VoidPtr p) =>
+    completer.complete(VecInt.fromPointer(p.cast<cvg.VecInt>()));
+
+void vecFloatCompleter(Completer<VecFloat> completer, VoidPtr p) =>
+    completer.complete(VecFloat.fromPointer(p.cast<cvg.VecFloat>()));
+
+void vecDoubleCompleter(Completer<VecDouble> completer, VoidPtr p) =>
+    completer.complete(VecDouble.fromPointer(p.cast<cvg.VecDouble>()));

lib/src/gapi/gapi.dart

@@ -4,13 +4,13 @@ import 'dart:ffi' as ffi;
 
 import 'package:ffi/ffi.dart';
 
-import '../constants.g.dart';
+// import '../constants.g.dart';
 import '../core/base.dart';
-import '../core/dmatch.dart';
-import '../core/keypoint.dart';
-import '../core/mat.dart';
-import '../core/scalar.dart';
-import '../core/vec.dart';
+// import '../core/dmatch.dart';
+// import '../core/keypoint.dart';
+// import '../core/mat.dart';
+// import '../core/scalar.dart';
+// import '../core/vec.dart';
 import '../opencv.g.dart' as cvg;
 import 'gmat.dart';
 import 'gscalar.dart';