Merge pull request #84 from UrielCh/minmax

Minmax

.gitignore

@@ -11,7 +11,6 @@ data/dnn
 .idea/
 dist
 .DS_Store
-native-node-utils
 */**.js.map
 examples/typed/*.js
 examples/typed/faceDetect/*.js

.npmignore

@@ -16,4 +16,3 @@ tmpdata
 ci
 .dockerignore
 dist
-native-node-utils

CHANGELOG.md

@@ -1,5 +1,10 @@
 # changelog
 
+## Version 6.5.0
+- integrate native-node-utils code inside cc/native-node-utils
+- add comments in native-node-utils
+- add cv.min cv.max
+
 ## Version 6.4.5
 - drop .ts files from npm package.
 - add .d.ts file for ts files in npm package.

Dockerfile.alpine.examples

@@ -8,7 +8,7 @@
 FROM urielch/opencv-nodejs:6.2.5-alpine As build
 WORKDIR /usr/src/app
 ENV NODE_ENV=development
-RUN npm install -g rimraf@3.0.2
+RUN npm install -g rimraf@4.4.0
 COPY examples/package.json ./
 COPY examples/tsconfig.prod.json ./tsconfig.json
 RUN sed -i -r "s/\"@u4\/opencv4nodejs\": \"link:..\",//g" package.json
@@ -25,10 +25,10 @@ FROM urielch/opencv-nodejs:6.2.5-alpine
 WORKDIR /usr/src/app
 ENV NODE_ENV=production
 COPY --from=build /usr/src/app/package*.json ./
-RUN npm install -g rimraf@3.0.2 && \
+RUN npm install -g rimraf@4.4.0 && \
     npm install && \
     rimraf node_modules/**/*.{md,ts,map,h,c,cc,cpp,gyp,yml,txt} node_modules/**/{LICENSE,.github,.npmignore,LICENSE.txt,.travis.yml,.eslintrc,sponsors} && \
-    npm uninstall -g rimraf@3.0.2 && \
+    npm uninstall -g rimraf@4.4.0 && \
     npm cache clean --force && \
     find . -type f -empty -print -delete && \
     find . -type d -empty -print -delete && \

Dockerfile.debian.examples

@@ -7,7 +7,7 @@
 FROM urielch/opencv-nodejs:6.2.5-debian As build
 WORKDIR /usr/src/app
 ENV NODE_ENV=development
-RUN npm install -g rimraf@3.0.2
+RUN npm install -g rimraf@4.4.0
 COPY examples/package.json ./
 COPY examples/tsconfig.prod.json ./tsconfig.json
 RUN sed -i -r "s/\"@u4\/opencv4nodejs\": \".+\",//g" package.json
@@ -24,10 +24,10 @@ FROM urielch/opencv-nodejs:6.2.5-debian
 WORKDIR /usr/src/app
 ENV NODE_ENV=production
 COPY --from=build /usr/src/app/package*.json ./
-RUN npm install -g rimraf@3.0.2 && \
+RUN npm install -g rimraf@4.4.0 && \
     npm install && \
     rimraf node_modules/**/*.{md,ts,map,h,c,cc,cpp,gyp,yml,txt} node_modules/**/{LICENSE,.github,.npmignore,LICENSE.txt,.travis.yml,.eslintrc,sponsors} && \
-    npm uninstall -g rimraf@3.0.2 && \
+    npm uninstall -g rimraf@4.4.0 && \
     npm cache clean --force && \
     find . -type f -empty -print -delete && \
     find . -type d -empty -print -delete && \

binding.gyp

@@ -9,7 +9,7 @@
 			"cc",
 			"cc/core",
 			"<!(node -e \"require('nan')\")",
-			"<!(node -e \"require('native-node-utils')\")"
+			"cc/native-node-utils",
 		],
 		"libraries": [
 			"<!@(node ./install/parseEnv.js OPENCV4NODEJS_LIBRARIES)",

cc/core/core.cc

@@ -52,8 +52,16 @@ NAN_MODULE_INIT(Core::Init) {
   Nan::SetMethod(target, "meanStdDevAsync", MeanStdDevAsync);
   Nan::SetMethod(target, "reduce", Reduce);
   Nan::SetMethod(target, "reduceAsync", ReduceAsync);
+
   Nan::SetMethod(target, "eigen", Eigen);
   Nan::SetMethod(target, "eigenAsync", EigenAsync);
+
+  Nan::SetMethod(target, "min", Min);
+  Nan::SetMethod(target, "minAsync", MinAsync);
+
+  Nan::SetMethod(target, "max", Max);
+  Nan::SetMethod(target, "maxAsync", MaxAsync);
+
   Nan::SetMethod(target, "solve", Solve);
   Nan::SetMethod(target, "solveAsync", SolveAsync);
 
@@ -372,6 +380,22 @@ NAN_METHOD(Core::EigenAsync) {
 	FF::asyncBinding<CoreBindings::Eigen>("Core", "Eigen", info);
 }
 
+NAN_METHOD(Core::Min) {
+	FF::syncBinding<CoreBindings::Min>("Core", "Min", info);
+}
+
+NAN_METHOD(Core::MinAsync) {
+	FF::asyncBinding<CoreBindings::Min>("Core", "Min", info);
+}
+
+NAN_METHOD(Core::Max) {
+	FF::syncBinding<CoreBindings::Max>("Core", "Max", info);
+}
+
+NAN_METHOD(Core::MaxAsync) {
+	FF::asyncBinding<CoreBindings::Max>("Core", "Max", info);
+}
+
 NAN_METHOD(Core::Solve) {
 	FF::syncBinding<CoreBindings::Solve>("Core", "Solve", info);
 }

cc/core/core.h

@@ -55,6 +55,10 @@ class Core : public Nan::ObjectWrap {
 	static NAN_METHOD(MeanStdDevAsync);
 	static NAN_METHOD(Reduce);
 	static NAN_METHOD(ReduceAsync);
+	static NAN_METHOD(Min);
+	static NAN_METHOD(MinAsync);
+	static NAN_METHOD(Max);
+	static NAN_METHOD(MaxAsync);
 	static NAN_METHOD(Eigen);
 	static NAN_METHOD(EigenAsync);
 	static NAN_METHOD(Solve);

cc/core/coreBindings.h

@@ -219,6 +219,32 @@ namespace CoreBindings {
 		};
 	};
 
+	class Min: public CvBinding {
+	public:
+		void setup() {
+			auto src1 = req<Mat::Converter>();
+			auto src2 = req<Mat::Converter>();
+			auto dest = ret<Mat::Converter>("dest", cv::noArray().getMat());
+
+			executeBinding = [=]() {
+				cv::min(src1->ref(), src2->ref(), dest->ref());
+			};
+		};
+	};
+
+	class Max: public CvBinding {
+	public:
+		void setup() {
+			auto src1 = req<Mat::Converter>();
+			auto src2 = req<Mat::Converter>();
+			// auto dest = opt<Mat::Converter>("dest", cv::noArray().getMat());
+			auto dest = ret<Mat::Converter>("dest"); //, cv::noArray().getMat());
+			executeBinding = [=]() {
+				cv::max(src1->ref(), src2->ref(), dest->ref());
+			};
+		};
+	};
+
 	class Eigen : public CvClassMethodBinding<Mat> {
 	public:
 		void createBinding(std::shared_ptr<FF::Value<cv::Mat>> self) {

cc/native-node-utils/AbstractConverter.h

@@ -0,0 +1,125 @@
+#include "utils.h"
+
+#ifndef __FF_ABSTRACT_CONVERTER_H__
+#define __FF_ABSTRACT_CONVERTER_H__
+
+namespace FF {
+
+	/*
+	ConverterImpl implements:
+		static std::string getTypeName()
+		static v8::Local<v8::Value> wrap(ConverterImpl::Type val)
+		static bool unwrap(ConverterImpl::Type* pVal, v8::Local<v8::Value> jsVal)
+		static ConverterImpl::Type unwrapUnchecked(v8::Local<v8::Value> jsVal)
+	*/
+	template <class ConverterImpl>
+	class AbstractConverter {
+	public:
+		typedef typename ConverterImpl::Type Type;
+
+		static bool assertType(v8::Local<v8::Value> jsVal) {
+			return ConverterImpl::assertType(jsVal);
+		}
+
+		static v8::Local<v8::Value> wrap(Type val) {
+			return ConverterImpl::wrap(val);
+		}
+
+		static Type unwrapUnchecked(v8::Local<v8::Value> jsVal) {
+			return ConverterImpl::unwrapUnchecked(jsVal);
+		}
+
+		static bool unwrapTo(Type* val, v8::Local<v8::Value> jsVal) {
+			if (ConverterImpl::unwrap(val, jsVal)) {
+				Nan::ThrowError(FF::newString(
+					std::string("failed to unwrap value, expected ") 
+					+ std::string(ConverterImpl::getTypeName())
+				));
+				return true;
+			}
+			return false;
+		}
+
+		static bool arg(int argN, Type* val, Nan::NAN_METHOD_ARGS_TYPE info) {
+			Nan::TryCatch tryCatch;
+			if (!hasArg(info, argN) || ConverterImpl::unwrap(val, info[argN])) {
+				if (tryCatch.HasCaught()) {
+					tryCatch.ReThrow();
+				}
+				else {
+					Nan::ThrowError(FF::newString(
+						std::string("expected argument ")
+						+ std::to_string(argN)
+						+ std::string(" to be of type ")
+						+ std::string(ConverterImpl::getTypeName())
+					));
+					tryCatch.ReThrow();
+				}
+				return true;
+			}
+			return false;
+		}
+
+		static bool optArg(int argN, Type* val, Nan::NAN_METHOD_ARGS_TYPE info) {
+			if (hasArg(info, argN) && info[argN]->IsFunction()) {
+				return false;
+			}
+
+			Nan::TryCatch tryCatch;
+			if (hasArg(info, argN) && ConverterImpl::unwrap(val, info[argN])) {
+				if (tryCatch.HasCaught()) {
+					tryCatch.ReThrow();
+				}
+				else {
+					Nan::ThrowError(FF::newString(
+						std::string("expected argument ")
+						+ std::to_string(argN)
+						+ std::string(" to be of type ")
+						+ std::string(ConverterImpl::getTypeName())
+					));
+					tryCatch.ReThrow();
+				}
+				return true;
+			}
+			return false;
+		}
+
+		static bool prop(Type* val, const char* prop, v8::Local<v8::Object> opts) {
+			if (!Nan::HasOwnProperty(opts, Nan::New(prop).ToLocalChecked()).FromJust()) {
+				Nan::ThrowError(FF::newString(
+					std::string("expected object to have property: ") 
+					+ std::string(prop)
+				));
+				return true;
+			}
+
+			return AbstractConverter::optProp(val, prop, opts);
+		}
+
+		static bool optProp(Type* val, const char* prop, v8::Local<v8::Object> opts) {
+			Nan::TryCatch tryCatch;
+			if (
+				Nan::HasOwnProperty(opts, Nan::New(prop).ToLocalChecked()).FromJust()
+				&& ConverterImpl::unwrap(val, Nan::Get(opts, Nan::New(prop).ToLocalChecked()).ToLocalChecked())
+				) {
+				if (tryCatch.HasCaught()) {
+					tryCatch.ReThrow();
+				}
+				else {
+					Nan::ThrowError(FF::newString(
+						std::string("expected property ")
+						+ std::string(prop)
+						+ std::string(" to be of type ")
+						+ std::string(ConverterImpl::getTypeName())
+					));
+					tryCatch.ReThrow();
+				}
+				return true;
+			}
+			return false;
+		}
+	};
+}
+
+
+#endif

cc/native-node-utils/ArrayConverter.h

@@ -0,0 +1,63 @@
+#include <nan.h>
+
+#ifndef __FF_ARRAY_CONVERTER_H__
+#define __FF_ARRAY_CONVERTER_H__
+
+namespace FF {
+
+	template <class ElementConverterImpl, class ElementCastType>
+	class ArrayConverterImpl {
+	public:
+		typedef std::vector<ElementCastType> Type;
+
+		static std::string getTypeName() {
+			return std::string("array of ") + ElementConverterImpl::getTypeName();
+		}
+
+		static bool assertType(v8::Local<v8::Value> jsVal) {
+			return jsVal->IsArray();
+		}
+
+		static Type unwrapUnchecked(v8::Local<v8::Value> jsVal) {
+			Type vec;
+			unwrap(&vec, jsVal);
+			return vec;
+		}
+
+		static bool unwrap(Type* vec, v8::Local<v8::Value> jsVal) {
+			if (!jsVal->IsArray()) {
+				return true;
+			}
+
+			v8::Local<v8::Array> jsArr = v8::Local<v8::Array>::Cast(jsVal);
+			for (int i = 0; i < (int)jsArr->Length(); i++) {
+				if (!ElementConverterImpl::assertType(Nan::Get(jsArr, i).ToLocalChecked())) {
+					Nan::ThrowError(
+						Nan::New(
+							std::string("expected array element at index ")
+							+ std::to_string(i)
+							+ std::string(" to be of type ")
+							+ std::string(ElementConverterImpl::getTypeName())
+						).ToLocalChecked()
+					);
+					return true;
+				}
+
+				ElementCastType obj = (ElementCastType)ElementConverterImpl::unwrapUnchecked(Nan::Get(jsArr, i).ToLocalChecked());
+				vec->push_back(obj);
+			}
+
+			return false;
+		}
+
+		static v8::Local<v8::Value> wrap(Type vec) {
+			v8::Local<v8::Array> jsArr = Nan::New<v8::Array>(vec.size());
+			for (int i = 0; i < (int)jsArr->Length(); i++) {
+				Nan::Set(jsArr, i, ElementConverterImpl::wrap(vec.at(i)));
+			}
+			return jsArr;
+		}
+	};
+
+}
+#endif