Add cv.seamlessClone, bindings and tests

Author: foxxyz

cc/photo/photo.cc

@@ -12,6 +12,8 @@ NAN_MODULE_INIT(Photo::Init) {
 	Nan::SetMethod(target, "fastNlMeansDenoisingColoredAsync", FastNlMeansDenoisingColoredAsync);
 	Nan::SetMethod(target, "inpaint", Inpaint);
 	Nan::SetMethod(target, "inpaintAsync", InpaintAsync);
+	Nan::SetMethod(target, "seamlessClone", SeamlessClone);
+	Nan::SetMethod(target, "seamlessCloneAsync", SeamlessCloneAsync);
 };
 
 NAN_METHOD(Photo::FastNlMeansDenoisingColored) {
@@ -46,4 +48,20 @@ NAN_METHOD(Photo::InpaintAsync) {
   );
 }
 
+NAN_METHOD(Photo::SeamlessClone) {
+  FF::executeSyncBinding(
+    std::make_shared<PhotoBindings::SeamlessCloningWorker>(),
+    "Photo::SeamlessClone",
+    info
+  );
+}
+
+NAN_METHOD(Photo::SeamlessCloneAsync) {
+  FF::executeAsyncBinding(
+    std::make_shared<PhotoBindings::SeamlessCloningWorker>(),
+    "Photo::SeamlessCloneAsync",
+    info
+  );
+}
+
 #endif

cc/photo/photo.h

@@ -14,6 +14,8 @@ class Photo {
 	static NAN_METHOD(FastNlMeansDenoisingColoredAsync);
 	static NAN_METHOD(Inpaint);
 	static NAN_METHOD(InpaintAsync);
+	static NAN_METHOD(SeamlessClone);
+	static NAN_METHOD(SeamlessCloneAsync);
 };
 
 #endif

cc/photo/photoBindings.h

@@ -86,7 +86,40 @@ namespace PhotoBindings {
       return Mat::Converter::wrap(dst);
     }
   };
-  
+
+  struct SeamlessCloningWorker : public CatchCvExceptionWorker {
+  public:
+    // required function arguments
+    cv::Mat src;
+    cv::Mat dst;
+    cv::Mat mask;
+    cv::Point2d p;
+    int flags;
+
+    // return value
+    cv::Mat blend;
+
+    bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+      return (
+        Mat::Converter::arg(0, &src, info) ||
+        Mat::Converter::arg(1, &dst, info) ||
+        Mat::Converter::arg(2, &mask, info) ||
+        Point2::Converter::arg(3, &p, info) ||
+        FF::IntConverter::arg(4, &flags, info)
+      );
+    }
+
+    std::string executeCatchCvExceptionWorker() {
+      cv::seamlessClone(
+        src, dst, mask, p, blend, flags
+      );
+      return "";
+    }
+
+    v8::Local<v8::Value> getReturnValue() {
+      return Mat::Converter::wrap(blend);
+    }
+  };
 
 }
 

cc/photo/photoConstants.cc

@@ -9,6 +9,9 @@ using namespace cv;
 void PhotoConstants::Init(v8::Local<v8::Object> target) {
 	FF_SET_CV_CONSTANT(target, INPAINT_NS);
 	FF_SET_CV_CONSTANT(target, INPAINT_TELEA);
+	FF_SET_CV_CONSTANT(target, NORMAL_CLONE);
+	FF_SET_CV_CONSTANT(target, MIXED_CLONE);
+	FF_SET_CV_CONSTANT(target, MONOCHROME_TRANSFER);
 }
 
 #endif

lib/typings/constants.d.ts

@@ -435,6 +435,8 @@ export const LINE_4: number;
 export const LINE_8: number;
 export const LINE_AA: number;
 export const LMEDS: number;
+export const MIXED_CLONE: number;
+export const MONOCHROME_TRANSFER: number;
 export const MORPH_BLACKHAT: number;
 export const MORPH_CLOSE: number;
 export const MORPH_CROSS: number;
@@ -455,6 +457,7 @@ export const NORM_L2SQR: number;
 export const NORM_MINMAX: number;
 export const NORM_RELATIVE: number;
 export const NORM_const_MASK: number;
+export const NORMAL_CLONE: number;
 export const RANSAC: number;
 export const REGULAR: number;
 export const RETR_CCOMP: number;

lib/typings/cv.d.ts

@@ -163,6 +163,8 @@ export function reduce(mat: Mat, dim: number, rtype: number, dtype?: number): Ma
 export function reduceAsync(mat: Mat, dim: number, rtype: number, dtype?: number): Promise<Mat>;
 export function sampsonDistance(pt1: Vec2, pt2: Vec2, F: Mat): number;
 export function sampsonDistanceAsync(pt1: Vec2, pt2: Vec2, F: Mat): Promise<number>;
+export function seamlessClone(src: Mat, dst: Mat, mask: Mat, p: Point2, flags: number): Mat;
+export function seamlessCloneAsync(src: Mat, dst: Mat, mask: Mat, p: Point2, flags: number): Promise<Mat>;
 export function solve(mat: Mat, mat2: Mat, flags?: number): Mat;
 export function solveAsync(mat: Mat, mat2: Mat, flags?: number): Promise<Mat>;
 export function solveP3P(objectPoints: Point3[], imagePoints: Point2[], cameraMatrix: Mat, distCoeffs: number[], flags?: number): { returnValue: boolean, rvecs: Mat[], tvecs: Mat[] };

test/tests/photo/index.js

@@ -59,6 +59,38 @@ module.exports = function ({ cv, utils }) {
           done();
         }).catch(done);
     });
-  })
+  });
+
+  describe('seamlessClone', () => {
+
+    it('should have constants', () => {
+      expect(isNaN(cv.NORMAL_CLONE)).to.be.equal(false);
+      expect(isNaN(cv.MIXED_CLONE)).to.be.equal(false);
+      expect(isNaN(cv.MONOCHROME_TRANSFER)).to.be.equal(false);
+    });
+
+    const src = new cv.Mat(5, 5, cv.CV_8UC3, [128, 128, 128]);
+    const dest = new cv.Mat(10, 10, cv.CV_8UC3, [32, 32, 32]);
+    const mask = new cv.Mat(10, 10, cv.CV8U, 255);
+    const center = new cv.Point(5, 5);
+    const cloneType = cv.NORMAL_CLONE;
+
+    const expectOutput = (res) => {
+      assertMetaData(res)(dest.rows, dest.cols, cv.CV_8UC3);
+    };
+
+    generateAPITests({
+      getDut: () => cv,
+      methodName: 'seamlessClone',
+      getRequiredArgs: () => ([
+        src,
+        dest,
+        mask,
+        center,
+        cloneType
+      ]),
+      expectOutput
+    });
+  });
 
 };