add guidedFilter guidedFilterAsync

Author: kunkkaliu

Diff for: binding.gyp

@@ -27,6 +27,7 @@
 			"cc/core/core.cc",
 			"cc/core/Mat.cc",
 			"cc/core/MatImgproc.cc",
+			"cc/core/MatXimgproc.cc",
 			"cc/core/MatCalib3d.cc",
 			"cc/core/Point.cc",
 			"cc/core/Vec.cc",

Diff for: cc/core/Mat.cc

@@ -1,5 +1,6 @@
 #include "Mat.h"
 #include "MatImgproc.h"
+#include "MatXimgproc.h"
 #include "MatCalib3d.h"
 #include "MatBindings.h"
 
@@ -111,6 +112,7 @@ NAN_MODULE_INIT(Mat::Init) {
   FF_PROTO_SET_MAT_OPERATIONS(ctor);
 
   MatImgproc::Init(ctor);
+  MatXimgproc::Init(ctor);
   MatCalib3d::Init(ctor);
 
   target->Set(Nan::New("Mat").ToLocalChecked(), ctor->GetFunction());

Diff for: cc/core/MatXimgproc.cc

@@ -0,0 +1,23 @@
+#include "MatXimgproc.h"
+#include "MatXimgprocBindings.h"
+
+void MatXimgproc::Init(v8::Local<v8::FunctionTemplate> ctor) {
+  Nan::SetPrototypeMethod(ctor, "guidedFilter", GuidedFilter);
+  Nan::SetPrototypeMethod(ctor, "guidedFilterAsync", GuidedFilterAsync);
+};
+
+NAN_METHOD(MatXimgproc::GuidedFilter) {
+  FF::SyncBinding(
+    std::make_shared<MatXimgprocBindings::GuidedFilterWorker>(Mat::Converter::unwrap(info.This())),
+    "Mat::GuidedFilter",
+    info
+  );
+}
+
+NAN_METHOD(MatXimgproc::GuidedFilterAsync) {
+  FF::AsyncBinding(
+    std::make_shared<MatXimgprocBindings::GuidedFilterWorker>(Mat::Converter::unwrap(info.This())),
+    "Mat::GuidedFilterAsync",
+    info
+  );
+}

Diff for: cc/core/MatXimgproc.h

@@ -0,0 +1,16 @@
+#include "Mat.h"
+#include <opencv2/ximgproc.hpp>
+
+#ifndef __FF_MATXIMGPROC_H__
+#define __FF_MATXIMGPROC_H__
+
+class MatXimgproc {
+public:
+  static void Init(v8::Local<v8::FunctionTemplate> ctor);
+
+  static NAN_METHOD(GuidedFilter);
+  static NAN_METHOD(GuidedFilterAsync);
+
+};
+
+#endif

Diff for: cc/core/MatXimgprocBindings.h

@@ -0,0 +1,59 @@
+#include "MatXimgproc.h"
+
+#ifndef __FF_MATXIMGPROCBINDINGS_H__
+#define __FF_MATXIMGPROCBINDINGS_H__
+
+namespace MatXimgprocBindings {
+ 
+  struct GuidedFilterWorker : public CatchCvExceptionWorker {
+  public:
+    cv::Mat self;
+    GuidedFilterWorker(cv::Mat self) {
+      this->self = self;
+    }
+  
+    cv::Mat guide;
+    int radius;
+    double eps;
+    int ddepth = -1;
+  
+    cv::Mat dst;
+  
+    std::string executeCatchCvExceptionWorker() {
+      cv::ximgproc::guidedFilter(guide, self, dst, radius, eps, ddepth);
+      return "";
+    }
+  
+    v8::Local<v8::Value> getReturnValue() {
+      return Mat::Converter::wrap(dst);
+    }
+  
+    bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return (
+        Mat::Converter::arg(0, &guide, info) ||
+        IntConverter::arg(1, &radius, info) ||
+        DoubleConverter::arg(2, &eps, info)
+        );
+    }
+  
+    bool unwrapOptionalArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return (
+        IntConverter::optArg(3, &ddepth, info)
+        );
+    }
+  
+    bool hasOptArgsObject(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return FF_ARG_IS_OBJECT(3);
+    }
+  
+    bool unwrapOptionalArgsFromOpts(Nan::NAN_METHOD_ARGS_TYPE info) {
+      v8::Local<v8::Object> opts = info[3]->ToObject();
+      return (
+        IntConverter::optProp(&ddepth, "ddepth", opts)
+      );
+    }
+  };  
+
+}
+
+#endif

Diff for: examples/guidedFilter.js

@@ -0,0 +1,8 @@
+const path = require('path');
+const cv = require('../');
+
+const image = cv.imread(path.resolve(__dirname, '../data/Lenna.png'));
+
+const dst = image.guidedFilter(image, 10, 500, -1);
+
+cv.imshowWait("dst", dst);

Diff for: lib/typings/Mat.d.ts

@@ -179,6 +179,8 @@ export class Mat {
   goodFeaturesToTrackAsync(maxCorners: number, qualityLevel: number, minDistance: number, mask?: Mat, blockSize?: number, gradientSize?: number, useHarrisDetector?: boolean, harrisK?: number): Promise<Point2[]>;
   grabCut(mask: Mat, rect: Rect, bgdModel: Mat, fgdModel: Mat, iterCount: number, mode: number): void;
   grabCutAsync(mask: Mat, rect: Rect, bgdModel: Mat, fgdModel: Mat, iterCount: number, mode: number): Promise<void>;
+  guidedFilter(guide: Mat, radius: number, eps: number, ddepth?: number): Mat;
+  guidedFilterAsync(guide: Mat, radius: number, eps: number, ddepth?: number): Promise<Mat>;
   hDiv(otherMat: Mat): Mat;
   hMul(otherMat: Mat): Mat;
   houghCircles(method: number, dp: number, minDist: number, param1?: number, param2?: number, minRadius?: number, maxRadius?: number): Vec3[];

Diff for: test/tests/core/Mat/Mat.test.js

@@ -18,6 +18,7 @@ const constructorTestsFromJsArray = require('./constructorTestsFromJsArray');
 const constructorTestsFromFillVector = require('./constructorTestsFromFillVector');
 const operatorTests = require('./operatorTests');
 const imgprocTests = require('./imgprocTests');
+const ximgprocTests = require('./ximgprocTests');
 const calib3dTests = require('./calib3dTests');
 const { doubleMin, doubleMax } = require('./typeRanges');
 
@@ -48,6 +49,7 @@ describe('Mat', () => {
   accessorTests();
 
   describe('imgproc methods', () => imgprocTests(getTestImg));
+  describe('ximgproc methods', () => ximgprocTests());
   describe('calib3d methods', () => calib3dTests());
 
   describe('constructor from channels', () => {

Diff for: test/tests/core/Mat/ximgprocTests.js

@@ -0,0 +1,33 @@
+const cv = global.dut;
+
+const {
+    generateAPITests,
+    assertMetaData,
+} = global.utils;
+
+module.exports = () => {
+    describe('guidedFilter', () => {
+        const getDut = () => new cv.Mat(100, 100, cv.CV_8UC3);
+
+        const guide = new cv.Mat(100, 100, cv.CV_8UC3);
+        const radius = 3;
+        const eps = 100;
+        const ddepth = -1;
+        generateAPITests({
+            getDut,
+            methodName: 'guidedFilter',
+            methodNameSpace: 'Mat',
+            getRequiredArgs: () => ([
+                guide,
+                radius,
+                eps
+            ]),
+            getOptionalArgs: () => ([
+                ddepth
+            ]),
+            expectOutput: (res) => {
+                assertMetaData(res)(100, 100, cv.CV_8UC3);
+            }
+        });
+    });
+}