add EdgeBoxes, more test

Author: rainyl

lib/src/contrib/ximgproc.dart

@@ -10,6 +10,7 @@ import 'package:opencv_dart/src/core/mat_type.dart';
 import '../core/base.dart';
 import '../core/mat.dart';
 import '../core/point.dart';
+import '../core/rect.dart';
 import '../core/scalar.dart';
 import '../core/size.dart';
 import '../core/vec.dart';
@@ -233,6 +234,112 @@ class ximgproc {
   static const int BINARIZATION_NICK = 3;
 }
 
+/// https://docs.opencv.org/4.x/dd/d65/classcv_1_1ximgproc_1_1EdgeBoxes.html#details
+class EdgeBoxes extends CvStruct<cvg.EdgeBoxes> {
+  EdgeBoxes.fromPointer(super.ptr, [bool attach = true]) : super.fromPointer() {
+    if (attach) finalizer.attach(this, ptr.cast(), detach: this);
+  }
+
+  /// https://docs.opencv.org/4.x/dd/d65/classcv_1_1ximgproc_1_1EdgeBoxes.html#details
+  factory EdgeBoxes({
+    double alpha = 0.65,
+    double beta = 0.75,
+    double eta = 1,
+    double minScore = 0.01,
+    int maxBoxes = 10000,
+    double edgeMinMag = 0.1,
+    double edgeMergeThr = 0.5,
+    double clusterMinMag = 0.5,
+    double maxAspectRatio = 3,
+    double minBoxArea = 1000,
+    double gamma = 2,
+    double kappa = 1.5,
+  }) {
+    final p = calloc<cvg.EdgeBoxes>()
+      ..ref.alpha = alpha
+      ..ref.beta = beta
+      ..ref.eta = eta
+      ..ref.minScore = minScore
+      ..ref.maxBoxes = maxBoxes
+      ..ref.edgeMinMag = edgeMinMag
+      ..ref.edgeMergeThr = edgeMergeThr
+      ..ref.clusterMinMag = clusterMinMag
+      ..ref.maxAspectRatio = maxAspectRatio
+      ..ref.minBoxArea = minBoxArea
+      ..ref.gamma = gamma
+      ..ref.kappa = kappa;
+
+    return EdgeBoxes.fromPointer(p);
+  }
+
+  /// Returns array containing proposal boxes.
+  ///
+  /// https://docs.opencv.org/4.x/dd/d65/classcv_1_1ximgproc_1_1EdgeBoxes.html#a822e422556f8103d01a0a4db6815f0e5
+  (VecRect boxes, VecFloat scores) getBoundingBoxes(InputArray edge_map, InputArray orientation_map) {
+    final pvr = calloc<cvg.VecRect>();
+    final pvf = calloc<cvg.VecFloat>();
+    cvRun(() => CFFI.ximgproc_EdgeBoxes_getBoundingBoxes(ref, edge_map.ref, orientation_map.ref, pvr, pvf));
+    return (VecRect.fromPointer(pvr), VecFloat.fromPointer(pvf));
+  }
+
+  double get alpha => ref.alpha;
+  set alpha(double value) => ref.alpha = value;
+
+  double get beta => ref.beta;
+  set beta(double value) => ref.beta = value;
+
+  double get eta => ref.eta;
+  set eta(double value) => ref.eta = value;
+
+  double get minScore => ref.minScore;
+  set minScore(double value) => ref.minScore = value;
+
+  int get maxBoxes => ref.maxBoxes;
+  set maxBoxes(int value) => ref.maxBoxes = value;
+
+  double get edgeMinMag => ref.edgeMinMag;
+  set edgeMinMag(double value) => ref.edgeMinMag = value;
+
+  double get edgeMergeThr => ref.edgeMergeThr;
+  set edgeMergeThr(double value) => ref.edgeMergeThr = value;
+
+  double get clusterMinMag => ref.clusterMinMag;
+  set clusterMinMag(double value) => ref.clusterMinMag = value;
+
+  double get maxAspectRatio => ref.maxAspectRatio;
+  set maxAspectRatio(double value) => ref.maxAspectRatio = value;
+
+  double get minBoxArea => ref.minBoxArea;
+  set minBoxArea(double value) => ref.minBoxArea = value;
+
+  double get gamma => ref.gamma;
+  set gamma(double value) => ref.gamma = value;
+
+  double get kappa => ref.kappa;
+  set kappa(double value) => ref.kappa = value;
+
+  static final finalizer = ffi.NativeFinalizer(calloc.nativeFree);
+
+  @override
+  List<num> get props => [
+        alpha,
+        beta,
+        eta,
+        minScore,
+        maxBoxes,
+        edgeMinMag,
+        edgeMergeThr,
+        clusterMinMag,
+        maxAspectRatio,
+        minBoxArea,
+        gamma,
+        kappa,
+      ];
+
+  @override
+  cvg.EdgeBoxes get ref => ptr.ref;
+}
+
 class RFFeatureGetter extends CvStruct<cvg.RFFeatureGetter> {
   RFFeatureGetter.fromPointer(super.ptr, [bool attach = true]) : super.fromPointer() {
     if (attach) finalizer.attach(this, ptr.cast(), detach: this);
@@ -244,9 +351,6 @@ class RFFeatureGetter extends CvStruct<cvg.RFFeatureGetter> {
     return RFFeatureGetter.fromPointer(p);
   }
 
-  static final finalizer =
-      OcvFinalizer<cvg.RFFeatureGetterPtr>(CFFI.addresses.ximgproc_RFFeatureGetter_Close);
-
   Mat getFeatures(InputArray src, int gnrmRad, int gsmthRad, int shrink, int outNum, int gradNum) {
     final p = calloc<cvg.Mat>();
     cvRun(
@@ -274,6 +378,14 @@ class RFFeatureGetter extends CvStruct<cvg.RFFeatureGetter> {
     return rval;
   }
 
+  static final finalizer =
+      OcvFinalizer<cvg.RFFeatureGetterPtr>(CFFI.addresses.ximgproc_RFFeatureGetter_Close);
+
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.ximgproc_RFFeatureGetter_Close(ptr);
+  }
+
   @override
   List<int> get props => [ptr.address];
 
@@ -350,6 +462,11 @@ class StructuredEdgeDetection extends CvStruct<cvg.StructuredEdgeDetection> {
   static final finalizer =
       OcvFinalizer<cvg.StructuredEdgeDetectionPtr>(CFFI.addresses.ximgproc_StructuredEdgeDetection_Close);
 
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.ximgproc_StructuredEdgeDetection_Close(ptr);
+  }
+
   @override
   List<int> get props => [ptr.address];
 
@@ -412,6 +529,11 @@ class GraphSegmentation extends CvStruct<cvg.GraphSegmentation> {
   static final finalizer =
       OcvFinalizer<cvg.GraphSegmentationPtr>(CFFI.addresses.ximgproc_GraphSegmentation_Close);
 
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.ximgproc_GraphSegmentation_Close(ptr);
+  }
+
   @override
   List<int> get props => [ptr.address];
 
@@ -586,6 +708,11 @@ class EdgeDrawing extends CvStruct<cvg.EdgeDrawing> {
 
   static final finalizer = OcvFinalizer<cvg.EdgeDrawingPtr>(CFFI.addresses.ximgproc_EdgeDrawing_Close);
 
+  void dispose() {
+    finalizer.detach(this);
+    CFFI.ximgproc_EdgeDrawing_Close(ptr);
+  }
+
   @override
   List<int> get props => [ptr.address];
 

lib/src/opencv.g.dart

@@ -35837,6 +35837,35 @@ class CvNative {
   late final _undistort_Async = _undistort_AsyncPtr.asFunction<
       ffi.Pointer<CvStatus> Function(Mat, Mat, Mat, Mat, CvCallback_1)>();
 
+  ffi.Pointer<CvStatus> ximgproc_EdgeBoxes_getBoundingBoxes(
+    EdgeBoxes self,
+    Mat edge_map,
+    Mat orientation_map,
+    ffi.Pointer<VecRect> boxes,
+    ffi.Pointer<VecFloat> scores,
+  ) {
+    return _ximgproc_EdgeBoxes_getBoundingBoxes(
+      self,
+      edge_map,
+      orientation_map,
+      boxes,
+      scores,
+    );
+  }
+
+  late final _ximgproc_EdgeBoxes_getBoundingBoxesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<CvStatus> Function(
+              EdgeBoxes,
+              Mat,
+              Mat,
+              ffi.Pointer<VecRect>,
+              ffi.Pointer<VecFloat>)>>('ximgproc_EdgeBoxes_getBoundingBoxes');
+  late final _ximgproc_EdgeBoxes_getBoundingBoxes =
+      _ximgproc_EdgeBoxes_getBoundingBoxesPtr.asFunction<
+          ffi.Pointer<CvStatus> Function(EdgeBoxes, Mat, Mat,
+              ffi.Pointer<VecRect>, ffi.Pointer<VecFloat>)>();
+
   void ximgproc_EdgeDrawing_Close(
     EdgeDrawingPtr self,
   ) {
@@ -37714,6 +37743,23 @@ final class BlockMeanHash extends ffi.Struct {
 
 typedef BlockMeanHashPtr = ffi.Pointer<BlockMeanHash>;
 
+final class Box extends ffi.Struct {
+  @ffi.Int()
+  external int h;
+
+  @ffi.Float()
+  external double score;
+
+  @ffi.Int()
+  external int w;
+
+  @ffi.Int()
+  external int x;
+
+  @ffi.Int()
+  external int y;
+}
+
 final class CLAHE extends ffi.Struct {
   external ffi.Pointer<ffi.Void> ptr;
 }
@@ -37791,7 +37837,41 @@ final class DMatch extends ffi.Struct {
 }
 
 final class EdgeBoxes extends ffi.Struct {
-  external ffi.Pointer<ffi.Pointer<ffi.Void>> ptr;
+  @ffi.Float()
+  external double alpha;
+
+  @ffi.Float()
+  external double beta;
+
+  @ffi.Float()
+  external double eta;
+
+  @ffi.Float()
+  external double minScore;
+
+  @ffi.Int()
+  external int maxBoxes;
+
+  @ffi.Float()
+  external double edgeMinMag;
+
+  @ffi.Float()
+  external double edgeMergeThr;
+
+  @ffi.Float()
+  external double clusterMinMag;
+
+  @ffi.Float()
+  external double maxAspectRatio;
+
+  @ffi.Float()
+  external double minBoxArea;
+
+  @ffi.Float()
+  external double gamma;
+
+  @ffi.Float()
+  external double kappa;
 }
 
 final class EdgeDrawing extends ffi.Struct {

src/extra/ximgproc.cpp

@@ -1,6 +1,7 @@
 #include "ximgproc.h"
 #include "core/types.h"
 #include "opencv2/core/types.hpp"
+#include "opencv2/ximgproc/edgeboxes.hpp"
 #include "opencv2/ximgproc/structured_edge_detection.hpp"
 
 CvStatus *
@@ -159,6 +160,37 @@ CvStatus *ximgproc_StructuredEdgeDetection_edgesNms(
   END_WRAP
 }
 
+// EdgeBoxes
+CvStatus *ximgproc_EdgeBoxes_getBoundingBoxes(
+    EdgeBoxes self,
+    Mat edge_map,
+    Mat orientation_map,
+    CVD_OUT VecRect *boxes,
+    CVD_OUT VecFloat *scores
+) {
+  BEGIN_WRAP
+  std::vector<float> _scores;
+  std::vector<cv::Rect> _boxes;
+  auto _self = cv::ximgproc::createEdgeBoxes(
+      self.alpha,
+      self.beta,
+      self.eta,
+      self.minScore,
+      self.maxBoxes,
+      self.edgeMinMag,
+      self.edgeMergeThr,
+      self.clusterMinMag,
+      self.maxAspectRatio,
+      self.minBoxArea,
+      self.gamma,
+      self.kappa
+  );
+  _self->getBoundingBoxes(*edge_map.ptr, *orientation_map.ptr, _boxes, _scores);
+  boxes->ptr = new std::vector<cv::Rect>(_boxes);
+  scores->ptr = new std::vector<float>(_scores);
+  END_WRAP
+}
+
 // GraphSegmentation
 CvStatus *
 ximgproc_GraphSegmentation_Create(float sigma, float k, int min_size, GraphSegmentation *rval) {