Merge branch 'master' of https://github.com/justadudewhohacks/opencv4nodejs into #149

Author: justadudewhohacks

cc/core/Rect.cc

@@ -1,4 +1,5 @@
 #include "Rect.h"
+#include "Size.h"
 
 Nan::Persistent<v8::FunctionTemplate> Rect::constructor;
 
@@ -16,6 +17,8 @@ NAN_MODULE_INIT(Rect::Init) {
 	Nan::SetPrototypeMethod(ctor, "or", Or);
 	Nan::SetPrototypeMethod(ctor, "toSquare", ToSquare);
 	Nan::SetPrototypeMethod(ctor, "toSquareAsync", ToSquareAsync);
+	Nan::SetPrototypeMethod(ctor, "pad", Pad);
+	Nan::SetPrototypeMethod(ctor, "padAsync", PadAsync);
 	Nan::SetPrototypeMethod(ctor, "rescale", Rescale);
 	Nan::SetPrototypeMethod(ctor, "rescaleAsync", RescaleAsync);
 
@@ -132,6 +135,54 @@ NAN_METHOD(Rect::ToSquareAsync) {
 }
 
 
+struct Rect::PadWorker : SimpleWorker {
+public:
+	cv::Rect2d rect;
+	cv::Size2d newSize = cv::Size2d();
+	cv::Rect2d outRect;
+
+	PadWorker(cv::Rect2d rect) {
+		this->rect = rect;
+	}
+
+	const char* execute() {
+		double offX = (rect.width - newSize.width) / 2;
+		double offY = (rect.height - newSize.height) / 2;
+		outRect = cv::Rect(rect.x + offX, rect.y + offY, newSize.width, newSize.height);
+		return "";
+	}
+
+	bool unwrapRequiredArgs(Nan::NAN_METHOD_ARGS_TYPE info) {
+		bool isSizeArg = Size::Converter::hasInstance(info[0]);
+		double f = 1;
+		bool didThrow = 
+			(!isSizeArg && DoubleConverter::arg(0, &f, info))
+			|| (isSizeArg && Size::Converter::arg(0, &newSize, info));
+
+		if (!isSizeArg) {
+			newSize = cv::Size2d(rect.width * f, rect.height * f);
+		}
+		return didThrow;
+	}
+
+	FF_VAL getReturnValue() {
+		return Rect::Converter::wrap(outRect);
+	}
+};
+
+NAN_METHOD(Rect::Pad) {
+	PadWorker worker(Rect::Converter::unwrap(info.This()));
+	FF_WORKER_SYNC("Rect::Pad", worker);
+	info.GetReturnValue().Set(worker.getReturnValue());
+
+}
+
+NAN_METHOD(Rect::PadAsync) {
+	PadWorker worker(Rect::Converter::unwrap(info.This()));
+	FF_WORKER_ASYNC("Rect::PadAsync", PadWorker, worker);
+}
+
+
 struct Rect::RescaleWorker : SimpleWorker {
 public:
 	cv::Rect2d rect;
@@ -143,11 +194,7 @@ struct Rect::RescaleWorker : SimpleWorker {
 	}
 
 	const char* execute() {
-		double newWidth = rect.width * f;
-		double newHeight = rect.height * f;
-		double offX = (rect.width - newWidth) / 2;
-		double offY = (rect.height - newHeight) / 2;
-		outRect = cv::Rect(rect.x + offX, rect.y + offY, newWidth, newHeight);
+		outRect = cv::Rect(f * rect.x, f * rect.y, f * rect.width, f * rect.height);
 		return "";
 	}
 

cc/core/Rect.h

@@ -27,6 +27,10 @@ class Rect : public Nan::ObjectWrap {
 	static NAN_METHOD(ToSquare);
 	static NAN_METHOD(ToSquareAsync);
 
+	struct PadWorker;
+	static NAN_METHOD(Pad);
+	static NAN_METHOD(PadAsync);
+
 	struct RescaleWorker;
 	static NAN_METHOD(Rescale);
 	static NAN_METHOD(RescaleAsync);

test/tests/core/Rect.test.js

@@ -95,10 +95,59 @@ describe('Rect', () => {
     });
   });
 
+  describe('pad', () => {
+    describe('by factor', () => {
+      describe('pad down', () => {
+        generateAPITests({
+          getDut: () => new cv.Rect(0, 0, 100, 100),
+          methodName: 'pad',
+          methodNameSpace: 'Rect',
+          getRequiredArgs: () => [0.5],
+          expectOutput: (res) => {
+            expect(res.x).to.equal(25);
+            expect(res.y).to.equal(25);
+            expect(res.width).to.equal(50);
+            expect(res.height).to.equal(50);
+          }
+        });
+      });
+
+      describe('pad up', () => {
+        generateAPITests({
+          getDut: () => new cv.Rect(0, 0, 100, 100),
+          methodName: 'pad',
+          methodNameSpace: 'Rect',
+          getRequiredArgs: () => [2],
+          expectOutput: (res) => {
+            expect(res.x).to.equal(-50);
+            expect(res.y).to.equal(-50);
+            expect(res.width).to.equal(200);
+            expect(res.height).to.equal(200);
+          }
+        });
+      });
+    });
+
+    describe('by Size', () => {
+      generateAPITests({
+        getDut: () => new cv.Rect(0, 0, 100, 100),
+        methodName: 'pad',
+        methodNameSpace: 'Rect',
+        getRequiredArgs: () => [new cv.Size(50, 200)],
+        expectOutput: (res) => {
+          expect(res.x).to.equal(25);
+          expect(res.y).to.equal(-50);
+          expect(res.width).to.equal(50);
+          expect(res.height).to.equal(200);
+        }
+      });
+    });
+  });
+
   describe('rescale', () => {
     describe('scale down', () => {
       generateAPITests({
-        getDut: () => new cv.Rect(0, 0, 100, 100),
+        getDut: () => new cv.Rect(50, 50, 100, 100),
         methodName: 'rescale',
         methodNameSpace: 'Rect',
         getRequiredArgs: () => [0.5],
@@ -113,13 +162,13 @@ describe('Rect', () => {
 
     describe('scale up', () => {
       generateAPITests({
-        getDut: () => new cv.Rect(0, 0, 100, 100),
+        getDut: () => new cv.Rect(50, 50, 100, 100),
         methodName: 'rescale',
         methodNameSpace: 'Rect',
         getRequiredArgs: () => [2],
         expectOutput: (res) => {
-          expect(res.x).to.equal(-50);
-          expect(res.y).to.equal(-50);
+          expect(res.x).to.equal(100);
+          expect(res.y).to.equal(100);
           expect(res.width).to.equal(200);
           expect(res.height).to.equal(200);
         }