Merge pull request #236 from findie/feature/inpaint

photo inpaint

Author: justadudewhohacks

binding.gyp

@@ -22,6 +22,7 @@
 			"cc/ExternalMemTracking.cc",
 			"cc/cvTypes/cvTypes.cc",
 			"cc/cvTypes/imgprocConstants.cc",
+			"cc/cvTypes/photoConstants.cc",
 			"cc/cvTypes/videoCaptureProps.cc",
 			"cc/core/core.cc",
 			"cc/core/Mat.cc",

cc/cvTypes/cvTypes.cc

@@ -1,13 +1,15 @@
 #include "cvTypes.h"
 #include "matTypes.h"
 #include "imgprocConstants.h"
+#include "photoConstants.h"
 #include "videoCaptureProps.h"
 
 using namespace cv;
 
 void CvTypes::Init(v8::Local<v8::Object> target) {
 	initMatTypes(target);
 	ImgprocConstants::Init(target);
+	PhotoConstants::Init(target);
 	VideoCaptureProps::Init(target);
 
 	FF_SET_CV_CONSTANT(target, NORM_INF);

cc/cvTypes/photoConstants.cc

@@ -0,0 +1,8 @@
+#include "photoConstants.h"
+
+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);
+}

cc/cvTypes/photoConstants.h

@@ -0,0 +1,14 @@
+#include "macros.h"
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/photo.hpp>
+
+#ifndef __FF_PHOTOCONSTANTS_H__
+#define __FF_PHOTOCONSTANTS_H__
+
+class PhotoConstants {
+public:
+	static void Init(v8::Local<v8::Object> target);
+};
+
+#endif //__FF_PHOTOCONSTANTS_H__

cc/modules/photo.cc

@@ -5,6 +5,8 @@
 
 NAN_MODULE_INIT(Photo::Init) {
   Nan::SetMethod(target, "fastNlMeansDenoisingColored", FastNlMeansDenoisingColored);
+  Nan::SetMethod(target, "inpaint", Inpaint);
+  Nan::SetMethod(target, "inpaintAsync", InpaintAsync);
 };
 
 NAN_METHOD(Photo::FastNlMeansDenoisingColored) {
@@ -30,4 +32,59 @@ NAN_METHOD(Photo::FastNlMeansDenoisingColored) {
 	FF_OBJ jsDst = FF_NEW_INSTANCE(Mat::constructor);
 	cv::fastNlMeansDenoisingColored(src, FF_UNWRAP_MAT_AND_GET(jsDst), h, hColor, templateWindowSize, searchWindowSize);
   FF_RETURN(jsDst);
+}
+
+struct Photo::InpaintWorker : public SimpleWorker {
+public:
+	cv::Mat src;
+	InpaintWorker(cv::Mat self) {
+		this->src = self;
+	}
+
+	// required function arguments
+	cv::Mat inpaintMask;
+	double inpaintRadius;
+	int flags;
+
+	// function return value
+	cv::Mat dst;
+
+	bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+		return (
+				Mat::Converter::arg(1, &inpaintMask, info) ||
+				DoubleConverter::arg(2, &inpaintRadius, info) ||
+				IntConverter::arg(3, &flags, info)
+		);
+	}
+
+	const char* execute() {
+		cv::inpaint(
+				src, inpaintMask, dst,
+				inpaintRadius, flags
+		);
+		return "";
+	}
+
+	FF_VAL getReturnValue() {
+		return Mat::Converter::wrap(dst);
+	}
+};
+
+NAN_METHOD(Photo::Inpaint) {
+		FF_METHOD_CONTEXT("Photo::Inpaint");
+
+		FF_ARG_INSTANCE(0, cv::Mat src, Mat::constructor, FF_UNWRAP_MAT_AND_GET);
+
+		InpaintWorker worker(src);
+		FF_WORKER_SYNC("Photo::Inpaint", worker);
+		info.GetReturnValue().Set(worker.getReturnValue());
+}
+
+NAN_METHOD(Photo::InpaintAsync) {
+		FF_METHOD_CONTEXT("Photo::InpaintAsync");
+
+		FF_ARG_INSTANCE(0, cv::Mat src, Mat::constructor, FF_UNWRAP_MAT_AND_GET);
+
+		InpaintWorker worker(src);
+		FF_WORKER_ASYNC("Photo::InpaintAsync", InpaintWorker, worker);
 }

cc/modules/photo.h

@@ -10,6 +10,9 @@ class Photo {
   static NAN_MODULE_INIT(Init);
   static NAN_METHOD(FastNlMeansDenoisingColored);
 
+	struct InpaintWorker;
+	static NAN_METHOD(Inpaint);
+	static NAN_METHOD(InpaintAsync);
 };
 
 #endif

lib/typings/constants.d.ts

@@ -479,6 +479,8 @@ export const VIDEOWRITER_PROP_NSTRIPES: number;
 export const VIDEOWRITER_PROP_QUALITY: number;
 export const WARP_FILL_OUTLIERS: number;
 export const WARP_INVERSE_MAP: number;
+export const INPAINT_NS: number;
+export const INPAINT_TELEA: number;
 
 export const HAAR_EYE: string;
 export const HAAR_EYE_TREE_EYEGLASSES: string;

lib/typings/cv.d.ts

@@ -49,6 +49,8 @@ export function estimateAffine3DAsync(from: Point2[], to: Point2[], method?: num
 export function estimateAffinePartial2D(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): { out: Mat, inliers: Mat };
 export function estimateAffinePartial2DAsync(from: Point2[], to: Point2[], method?: number, ransacReprojThreshold?: number, maxIters?: number, confidence?: number, refineIters?: number): Promise<{ out: Mat, inliers: Mat }>;
 export function fastNlMeansDenoisingColored(src: Mat, h?: number, hColor?: number, templateWindowSize?: number, searchWindowSize?: number): Mat;
+export function inpaint(src: Mat, mask: Mat, inpaintRadius: number, flags: number): Mat;
+export function inpaintAsync(src: Mat, mask: Mat, inpaintRadius: number, flags: number): Promise<Mat>;
 export function findEssentialMat(points1: Point2[], points2: Point2[], focal?: number, pp?: Point2, method?: number, prob?: number, threshold?: number): { E: Mat, mask: Mat };
 export function findEssentialMatAsync(points1: Point2[], points2: Point2[], focal?: number, pp?: Point2, method?: number, prob?: number, threshold?: number): Promise<{ E: Mat, mask: Mat }>;
 export function findFundamentalMat(points1: Point2[], points2: Point2[], method?: number, param1?: number, param2?: number): { F: Mat, mask: Mat };

test/tests/modules/photo/photo.test.js

@@ -0,0 +1,63 @@
+const cv = global.dut;
+const {
+  assertError,
+  assertPropsWithValue,
+  assertMetaData,
+  funcShouldRequireArgs,
+  readTestImage,
+  generateAPITests
+} = global.utils;
+const { expect } = require('chai');
+
+describe('photo', () => {
+
+  describe('inpaint', () => {
+
+    it('should have constants', () => {
+      expect(isNaN(cv.INPAINT_TELEA)).to.be.equal(false);
+      expect(isNaN(cv.INPAINT_NS)).to.be.equal(false);
+    });
+
+
+    it('should perform inpainting', () => {
+
+      // construct a black image with a white dot in the middle
+      const imgData = new Array(7*7).fill(0);
+      imgData[7 * 3 + 3] = 255;
+      const image = new cv.Mat(new Buffer(imgData), 7,7,cv.CV_8U);
+      // construct the mask from the same image (since we want to inpaint the white dot)
+      const mask = image.copy();
+
+      // perform inpainting
+      const inpainted = cv.inpaint(image, mask, 3, cv.INPAINT_TELEA);
+
+      // now the result should be all black
+      const sum = inpainted.sum();
+
+      // so sum should be 0
+      expect(sum).to.be.equal(0);
+    });
+
+    it('should perform inpainting async', (done) => {
+
+      // construct a black image with a white dot in the middle
+      const imgData = new Array(7*7).fill(0);
+      imgData[7 * 3 + 3] = 255;
+      const image = new cv.Mat(new Buffer(imgData), 7,7,cv.CV_8U);
+      // construct the mask from the same image (since we want to inpaint the white dot)
+      const mask = image.copy();
+
+      // perform inpainting
+      cv.inpaintAsync(image, mask, 3, cv.INPAINT_TELEA)
+        .then(inpainted => {
+          // now the result should be all black
+          const sum = inpainted.sum();
+
+          // so sum should be 0
+          expect(sum).to.be.equal(0);
+
+          done();
+        }).catch(done);
+    });
+  })
+});