node 12 fixes

cc/core/Mat.cc

@@ -103,7 +103,7 @@ NAN_MODULE_INIT(Mat::Init) {
   Nan::SetPrototypeMethod(ctor, "eigenAsync", EigenAsync);
   Nan::SetPrototypeMethod(ctor, "solve", Solve);
   Nan::SetPrototypeMethod(ctor, "solveAsync", SolveAsync);
-    
+
 #if CV_VERSION_MINOR > 1
   Nan::SetPrototypeMethod(ctor, "rotate", Rotate);
   Nan::SetPrototypeMethod(ctor, "rotateAsync", RotateAsync);
@@ -120,7 +120,7 @@ NAN_MODULE_INIT(Mat::Init) {
   MatXimgproc::Init(ctor);
   #endif // HAVE_XIMGPROC
 
-  target->Set(Nan::New("Mat").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Mat").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 void Mat::setNativeProps(cv::Mat mat) {
@@ -223,7 +223,7 @@ NAN_METHOD(Mat::Eye) {
   FF_ARG_INT(0, int rows);
   FF_ARG_INT(1, int cols);
   FF_ARG_INT(2, int type);
-  FF_OBJ jsEyeMat = FF_NEW_INSTANCE(Mat::constructor);
+  FF_OBJ jsEyeMat = FF::newInstance(Nan::New(Mat::constructor));
   FF_UNWRAP_MAT_AND_GET(jsEyeMat) = cv::Mat::eye(cv::Size(cols, rows), type);
   FF_RETURN(jsEyeMat);
 }
@@ -260,15 +260,15 @@ NAN_METHOD(Mat::At) {
     FF_ARR vec = FF_ARR::Cast(val);
     FF_OBJ jsVec;
     if (vec->Length() == 2) {
-      jsVec = FF_NEW_INSTANCE(Vec2::constructor);
+      jsVec = FF::newInstance(Nan::New(Vec2::constructor));
       FF_UNWRAP_VEC2(jsVec)->vec = cv::Vec2d(vec->Get(0)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(), vec->Get(1)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value());
     }
     else if (vec->Length() == 3) {
-      jsVec = FF_NEW_INSTANCE(Vec3::constructor);
+      jsVec = FF::newInstance(Nan::New(Vec3::constructor));
       FF_UNWRAP_VEC3(jsVec)->vec = cv::Vec3d(vec->Get(0)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(), vec->Get(1)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(), vec->Get(2)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value());
     }
     else {
-      jsVec = FF_NEW_INSTANCE(Vec4::constructor);
+      jsVec = FF::newInstance(Nan::New(Vec4::constructor));
       FF_UNWRAP_VEC4(jsVec)->vec = cv::Vec4d(vec->Get(0)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(), vec->Get(1)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(), vec->Get(2)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(), vec->Get(3)->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value());
     }
     jsVal = jsVec;
@@ -353,7 +353,7 @@ NAN_METHOD(Mat::GetRegion) {
     return Nan::ThrowError("Mat::GetRegion expected arg0 to be an instance of Rect");
   }
   cv::Rect2d rect = FF_UNWRAP(info[0]->ToObject(Nan::GetCurrentContext()).ToLocalChecked(), Rect)->rect;
-  FF_OBJ jsRegion = FF_NEW_INSTANCE(constructor);
+  FF_OBJ jsRegion = FF::newInstance(Nan::New(constructor));
   FF_UNWRAP_MAT_AND_GET(jsRegion) = FF_UNWRAP_MAT_AND_GET(info.This())(rect);
   FF_RETURN(jsRegion);
 }
@@ -404,7 +404,7 @@ NAN_METHOD(Mat::Normalize) {
     FF_ARG_INSTANCE_IFDEF(4, mask, Mat::constructor, FF_UNWRAP_MAT_AND_GET, mask);
   }
 
-  FF_OBJ jsMat = FF_NEW_INSTANCE(constructor);
+  FF_OBJ jsMat = FF::newInstance(Nan::New(constructor));
   cv::normalize(FF_UNWRAP_MAT_AND_GET(info.This()), FF_UNWRAP_MAT_AND_GET(jsMat), alpha, beta, normType, dtype, mask);
   FF_RETURN(jsMat);
 }

cc/core/MatImgprocBindings.h

@@ -801,7 +801,7 @@ namespace MatImgprocBindings {
     v8::Local<v8::Value> getReturnValue() {
       v8::Local<v8::Array> ret = Nan::New<v8::Array>(contours.size());
       for (uint i = 0; i < ret->Length(); i++) {
-        FF_OBJ jsContour = FF_NEW_INSTANCE(Contour::constructor);
+        FF_OBJ jsContour = FF::newInstance(Nan::New(Contour::constructor));
         FF_UNWRAP(jsContour, Contour)->contour = contours.at(i);
         FF_UNWRAP(jsContour, Contour)->hierarchy = hierarchy.at(i);
         ret->Set(i, jsContour);

cc/core/Point.cc

@@ -28,9 +28,9 @@ NAN_MODULE_INIT(Point::Init) {
   v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(Point::New);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(Nan::New("Point").ToLocalChecked());
-  target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction());
-  target->Set(Nan::New("Point2").ToLocalChecked(), ctor->GetFunction());
-  target->Set(Nan::New("Point3").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Point").ToLocalChecked(), FF::getFunction(ctor));
+  target->Set(Nan::New("Point2").ToLocalChecked(), FF::getFunction(ctor));
+  target->Set(Nan::New("Point3").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(Point::New) {
@@ -43,12 +43,11 @@ NAN_METHOD(Point::New) {
 	v8::Local<v8::Object> jsPoint;
 	if (info.Length() == 3) {
 		double z = info[2]->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value();
-		jsPoint = Nan::NewInstance(Nan::New(Point3::constructor)->GetFunction()).ToLocalChecked();
+		jsPoint = FF::newInstance(Nan::New(Point3::constructor));
 		Nan::ObjectWrap::Unwrap<Point3>(jsPoint)->pt = cv::Point3d(x, y, z);
 	}
 	else {
-		v8::Local<v8::Function> ct = Nan::New(Point2::constructor)->GetFunction();
-		jsPoint = Nan::NewInstance(ct).ToLocalChecked();
+		jsPoint = FF::newInstance(Nan::New(Point2::constructor));
 		Nan::ObjectWrap::Unwrap<Point2>(jsPoint)->pt = cv::Point2d(x, y);
 	}
   info.GetReturnValue().Set(jsPoint);

cc/core/Point.h

@@ -29,7 +29,7 @@ class Point : public Nan::ObjectWrap {
 	static v8::Local<v8::Array> packJSPoint2Array(std::vector<cv::Point_<type>> pts) {
 		v8::Local<v8::Array> jsPts = Nan::New<v8::Array>(pts.size());
 		for (uint i = 0; i < jsPts->Length(); i++) {
-			v8::Local<v8::Object> jsPt2 = FF_NEW_INSTANCE(Point2::constructor);
+			v8::Local<v8::Object> jsPt2 = FF::newInstance(Nan::New(Point2::constructor));
 			FF_UNWRAP_PT2_AND_GET(jsPt2) = pts.at(i);
 			jsPts->Set(i, jsPt2);
 		}
@@ -40,7 +40,7 @@ class Point : public Nan::ObjectWrap {
 	static v8::Local<v8::Array> packJSPoint3Array(std::vector<cv::Point3_<type>> pts) {
 		v8::Local<v8::Array> jsPts = Nan::New<v8::Array>(pts.size());
 		for (uint i = 0; i < jsPts->Length(); i++) {
-			v8::Local<v8::Object> jsPt3 = FF_NEW_INSTANCE(Point3::constructor);
+			v8::Local<v8::Object> jsPt3 = FF::newInstance(Nan::New(Point3::constructor));
 			FF_UNWRAP_PT3_AND_GET(jsPt3) = pts.at(i);
 			jsPts->Set(i, jsPt3);
 		}

cc/core/Rect.cc

@@ -22,7 +22,7 @@ NAN_MODULE_INIT(Rect::Init) {
   Nan::SetPrototypeMethod(ctor, "rescale", Rescale);
   Nan::SetPrototypeMethod(ctor, "rescaleAsync", RescaleAsync);
 
-  target->Set(Nan::New("Rect").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Rect").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(Rect::New) {

cc/core/RotatedRect.cc

@@ -13,7 +13,7 @@ NAN_MODULE_INIT(RotatedRect::Init) {
 
 	Nan::SetPrototypeMethod(ctor, "boundingRect", RotatedRect::BoundingRect);
 
-  target->Set(Nan::New("RotatedRect").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("RotatedRect").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(RotatedRect::New) {

cc/core/RotatedRect.h

@@ -17,19 +17,19 @@ class RotatedRect : public Nan::ObjectWrap {
 	static FF_GETTER(RotatedRect, GetAngle, rect.angle);
 
 	static NAN_GETTER(GetCenter) {
-		v8::Local<v8::Object> jsCenter = FF_NEW_INSTANCE(Point2::constructor);
+		v8::Local<v8::Object> jsCenter = FF::newInstance(Nan::New(Point2::constructor));
 		FF_UNWRAP_PT2_AND_GET(jsCenter) = FF_UNWRAP(info.This(), RotatedRect)->rect.center;
 		info.GetReturnValue().Set(jsCenter);
 	}
 
 	static NAN_GETTER(GetSize) {
-		v8::Local<v8::Object> jsSize = FF_NEW_INSTANCE(Size::constructor);
+		v8::Local<v8::Object> jsSize = FF::newInstance(Nan::New(Size::constructor));
 		FF_UNWRAP_SIZE_AND_GET(jsSize) = FF_UNWRAP(info.This(), RotatedRect)->rect.size;
 		info.GetReturnValue().Set(jsSize);
 	}
 
 	static NAN_METHOD(BoundingRect) {
-		v8::Local<v8::Object> jsRect = FF_NEW_INSTANCE(Rect::constructor);
+		v8::Local<v8::Object> jsRect = FF::newInstance(Nan::New(Rect::constructor));
 		FF_UNWRAP(jsRect, Rect)->rect = FF_UNWRAP(info.This(), RotatedRect)->rect.boundingRect();
 		info.GetReturnValue().Set(jsRect);
 	}

cc/core/Size.cc

@@ -10,7 +10,7 @@ NAN_MODULE_INIT(Size::Init) {
 	Nan::SetAccessor(ctor->InstanceTemplate(), Nan::New("width").ToLocalChecked(), Size::GetWidth);
 	Nan::SetAccessor(ctor->InstanceTemplate(), Nan::New("height").ToLocalChecked(), Size::GetHeight);
 
-  target->Set(Nan::New("Size").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Size").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(Size::New) {

cc/core/TermCriteria.cc

@@ -11,7 +11,7 @@ NAN_MODULE_INIT(TermCriteria::Init) {
 	Nan::SetAccessor(ctor->InstanceTemplate(), FF_NEW_STRING("maxCount"), TermCriteria::GetMaxCount);
 	Nan::SetAccessor(ctor->InstanceTemplate(), FF_NEW_STRING("epsilon"), TermCriteria::GetEpsilon);
 
-  target->Set(FF_NEW_STRING("TermCriteria"), ctor->GetFunction());
+  target->Set(FF_NEW_STRING("TermCriteria"), FF::getFunction(ctor));
 };
 
 NAN_METHOD(TermCriteria::New) {

cc/core/Vec.cc

@@ -42,10 +42,10 @@ NAN_MODULE_INIT(Vec::Init) {
   v8::Local<v8::FunctionTemplate> ctor = Nan::New<v8::FunctionTemplate>(Vec::New);
   ctor->InstanceTemplate()->SetInternalFieldCount(1);
   ctor->SetClassName(Nan::New("Vec").ToLocalChecked());
-  target->Set(Nan::New("Vec").ToLocalChecked(), ctor->GetFunction());
-  target->Set(Nan::New("Vec2").ToLocalChecked(), ctor->GetFunction());
-  target->Set(Nan::New("Vec3").ToLocalChecked(), ctor->GetFunction());
-  target->Set(Nan::New("Vec4").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Vec").ToLocalChecked(), FF::getFunction(ctor));
+  target->Set(Nan::New("Vec2").ToLocalChecked(), FF::getFunction(ctor));
+  target->Set(Nan::New("Vec3").ToLocalChecked(), FF::getFunction(ctor));
+  target->Set(Nan::New("Vec4").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(Vec::New) {
@@ -55,8 +55,7 @@ NAN_METHOD(Vec::New) {
 	}
 	v8::Local<v8::Object> jsVec;
 	if (info.Length() == 4) {
-		v8::Local<v8::Function> ct = Nan::New(Vec4::constructor)->GetFunction();
-		jsVec = Nan::NewInstance(ct).ToLocalChecked();
+		jsVec = FF::newInstance(Nan::New(Vec4::constructor));
 		Nan::ObjectWrap::Unwrap<Vec4>(jsVec)->vec = cv::Vec4d(
 			info[0]->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(),
 			info[1]->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value(),
@@ -68,12 +67,11 @@ NAN_METHOD(Vec::New) {
 		double y = info[1]->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value();
 		if (info.Length() == 3) {
 			double z = info[2]->ToNumber(Nan::GetCurrentContext()).ToLocalChecked()->Value();
-			jsVec = Nan::NewInstance(Nan::New(Vec3::constructor)->GetFunction()).ToLocalChecked();
+			jsVec = FF::newInstance(Nan::New(Vec3::constructor));
 			Nan::ObjectWrap::Unwrap<Vec3>(jsVec)->vec = cv::Vec3d(x, y, z);
 		}
 		else {
-			v8::Local<v8::Function> ct = Nan::New(Vec2::constructor)->GetFunction();
-			jsVec = Nan::NewInstance(ct).ToLocalChecked();
+			jsVec = FF::newInstance(Nan::New(Vec2::constructor));
 			Nan::ObjectWrap::Unwrap<Vec2>(jsVec)->vec = cv::Vec2d(x, y);
 		}
 	}

cc/core/Vec.h

@@ -42,7 +42,7 @@ class Vec : public Nan::ObjectWrap {
 	static v8::Local<v8::Array> packJSVec4Array(std::vector<cv::Vec4d> vecs) {
 		v8::Local<v8::Array> jsVecs = Nan::New<v8::Array>(vecs.size());
 		for (uint i = 0; i < jsVecs->Length(); i++) {
-			v8::Local<v8::Object> jsVec4 = FF_NEW_INSTANCE(Vec4::constructor);
+			v8::Local<v8::Object> jsVec4 = FF::newInstance(Nan::New(Vec4::constructor));
 			FF_UNWRAP_VEC4_AND_GET(jsVec4) = vecs.at(i);
 			jsVecs->Set(i, jsVec4);
 		}

cc/core/core.cc

@@ -9,8 +9,8 @@
     }                                                                                 \
     bool operator()(const ff_type& a, const ff_type& b) {                             \
       FF_VAL cbArgs[2];                                                               \
-      cbArgs[0] = FF_NEW_INSTANCE(ff_ctor);                                           \
-      cbArgs[1] = FF_NEW_INSTANCE(ff_ctor);                                           \
+      cbArgs[0] = FF::newInstance(Nan::New(ff_ctor));                                           \
+      cbArgs[1] = FF::newInstance(Nan::New(ff_ctor));                                           \
       ff_unwrapper(cbArgs[0]->ToObject(Nan::GetCurrentContext()).ToLocalChecked()) = a;                                        \
       ff_unwrapper(cbArgs[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked()) = b;                                        \
       Nan::AsyncResource resource("opencv4nodejs:Predicate::Constructor");            \

cc/core/coreUtils.h

@@ -19,12 +19,12 @@
 #define FF_ERR_WHERE(func, clazz) std::string(#clazz) + "  " + std::string(#func) + " : "
 
 #define FF_SELF_OPERATOR_RET(func, unwrapper)					\
-	v8::Local<v8::Object> jsObj = FF_NEW_INSTANCE(constructor);	\
+	v8::Local<v8::Object> jsObj = FF::newInstance(Nan::New(constructor));	\
 	unwrapper(jsObj) = func(unwrapper(info.This()));		\
 	return info.GetReturnValue().Set(jsObj);		
 
 #define FF_SELF_OPERATOR(func, unwrapper)							\
-	v8::Local<v8::Object> jsObj = FF_NEW_INSTANCE(constructor);	\
+	v8::Local<v8::Object> jsObj = FF::newInstance(Nan::New(constructor));	\
 	func(unwrapper(info.This()), unwrapper(jsObj));			\
 	return info.GetReturnValue().Set(jsObj);					
 
@@ -33,7 +33,7 @@
 		return Nan::ThrowError(FF_NEW_STRING(FF_ERR_WHERE(func, clazz)	\
 			+ std::string("expected arg to be a Scalar")));							\
 	}																																\
-	v8::Local<v8::Object> jsObj = FF_NEW_INSTANCE(constructor);							\
+	v8::Local<v8::Object> jsObj = FF::newInstance(Nan::New(constructor));							\
 	applyFunc(																											\
 		func,																													\
 		unwrapper(info.This()),																				\
@@ -45,7 +45,7 @@
 #define FF_OPERATOR(func, applyFunc, unwrapper, clazz)														\
 	FF_REQUIRE_INSTANCE(constructor, info[0],	FF_NEW_STRING(FF_ERR_WHERE(func, clazz) \
 		+ std::string("expected arg to be an instance of ") + std::string(#clazz)));	\
-	v8::Local<v8::Object> jsObj = FF_NEW_INSTANCE(constructor);															\
+	v8::Local<v8::Object> jsObj = FF::newInstance(Nan::New(constructor));															\
 	applyFunc(																																			\
 		func,																																					\
 		unwrapper(info.This()),																												\

cc/macros.h

@@ -4,8 +4,6 @@
 #ifndef __FF_MACROS_H__
 #define __FF_MACROS_H__
 
-#define FF_NEW_INSTANCE(ctor) Nan::NewInstance(Nan::New(ctor)->GetFunction()).ToLocalChecked()
-
 #define FF_GETTER(clazz, name, prop)	\
 	NAN_GETTER(name) { info.GetReturnValue().Set(Nan::ObjectWrap::Unwrap<clazz>(info.This())->prop); }
 
@@ -21,7 +19,7 @@
 
 #define FF_GETTER_JSOBJ(clazz, name, value, unwrapper, ctor)	\
 	NAN_GETTER(name) {																					\
-		v8::Local<v8::Object> jsObj = FF_NEW_INSTANCE(ctor);			\
+		v8::Local<v8::Object> jsObj = FF::newInstance(Nan::New(ctor));			\
 		unwrapper(jsObj) = FF_UNWRAP(info.This(), clazz)->value;	\
 		info.GetReturnValue().Set(jsObj);													\
 	}

cc/modules/calib3d/calib3d.cc

@@ -160,8 +160,8 @@ NAN_METHOD(Calib3d::FindHomography) {
     FF_ARG_NUMBER_IFDEF(5, confidence, confidence);
   }
 
-  FF_OBJ jsMat = FF_NEW_INSTANCE(Mat::constructor);
-  FF_OBJ mask = FF_NEW_INSTANCE(Mat::constructor);
+  FF_OBJ jsMat = FF::newInstance(Nan::New(Mat::constructor));
+  FF_OBJ mask = FF::newInstance(Nan::New(Mat::constructor));
   FF_UNWRAP_MAT_AND_GET(jsMat) = cv::findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, FF_UNWRAP_MAT_AND_GET(mask), maxIters, confidence);
 
   v8::Local<v8::Object> output = Nan::New<v8::Object>();

cc/modules/dnn/Net.cc

@@ -25,7 +25,7 @@ NAN_MODULE_INIT(Net::Init) {
   Nan::SetPrototypeMethod(ctor, "getUnconnectedOutLayers", GetUnconnectedOutLayers);
   Nan::SetPrototypeMethod(ctor, "getUnconnectedOutLayersAsync", GetUnconnectedOutLayersAsync);
 
-  target->Set(Nan::New("Net").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("Net").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(Net::New) {

cc/modules/face/EigenFaceRecognizer.cc

@@ -14,7 +14,7 @@ NAN_MODULE_INIT(EigenFaceRecognizer::Init) {
 	ctor->SetClassName(Nan::New("EigenFaceRecognizer").ToLocalChecked());
 	instanceTemplate->SetInternalFieldCount(1);
 
-	target->Set(Nan::New("EigenFaceRecognizer").ToLocalChecked(), ctor->GetFunction());
+	target->Set(Nan::New("EigenFaceRecognizer").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(EigenFaceRecognizer::New) {

cc/modules/face/FacemarkAAM.cc

@@ -17,7 +17,7 @@ NAN_MODULE_INIT(FacemarkAAM::Init) {
   ctor->SetClassName(Nan::New("FacemarkAAM").ToLocalChecked());
   instanceTemplate->SetInternalFieldCount(1);
 
-  target->Set(Nan::New("FacemarkAAM").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("FacemarkAAM").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(FacemarkAAM::New) {

cc/modules/face/FacemarkAAMData.cc

@@ -17,7 +17,7 @@ NAN_MODULE_INIT(FacemarkAAMData::Init) {
 
   Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("s0"), s0Get, s0Set);
 
-  target->Set(FF_NEW_STRING("FacemarkAAMData"), ctor->GetFunction());
+  target->Set(FF_NEW_STRING("FacemarkAAMData"), FF::getFunction(ctor));
 };
 
 NAN_METHOD(FacemarkAAMData::New) {

cc/modules/face/FacemarkAAMParams.cc

@@ -26,7 +26,7 @@ NAN_MODULE_INIT(FacemarkAAMParams::Init) {
   Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("textureMaxM"), textureMaxMGet, textureMaxMSet);
   Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("verbose"), verboseGet, verboseSet);
 
-  target->Set(FF_NEW_STRING("FacemarkAAMParams"), ctor->GetFunction());
+  target->Set(FF_NEW_STRING("FacemarkAAMParams"), FF::getFunction(ctor));
 };
 
 NAN_METHOD(FacemarkAAMParams::New) {

cc/modules/face/FacemarkLBF.cc

@@ -17,7 +17,7 @@ NAN_MODULE_INIT(FacemarkLBF::Init) {
   ctor->SetClassName(Nan::New("FacemarkLBF").ToLocalChecked());
   instanceTemplate->SetInternalFieldCount(1);
 
-  target->Set(Nan::New("FacemarkLBF").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("FacemarkLBF").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(FacemarkLBF::New) {

cc/modules/face/FacemarkLBFParams.cc

@@ -32,7 +32,7 @@ NAN_MODULE_INIT(FacemarkLBFParams::Init) {
   Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("treeN"), treeNGet, treeNSet);
   Nan::SetAccessor(instanceTemplate, FF_NEW_STRING("verbose"), verboseGet, verboseSet);
 
-  target->Set(FF_NEW_STRING("FacemarkLBFParams"), ctor->GetFunction());
+  target->Set(FF_NEW_STRING("FacemarkLBFParams"), FF::getFunction(ctor));
 };
 
 NAN_METHOD(FacemarkLBFParams::New) {

cc/modules/face/FisherFaceRecognizer.cc

@@ -14,7 +14,7 @@ NAN_MODULE_INIT(FisherFaceRecognizer::Init) {
 	ctor->SetClassName(Nan::New("FisherFaceRecognizer").ToLocalChecked());
 	instanceTemplate->SetInternalFieldCount(1);
 
-	target->Set(Nan::New("FisherFaceRecognizer").ToLocalChecked(), ctor->GetFunction());
+	target->Set(Nan::New("FisherFaceRecognizer").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(FisherFaceRecognizer::New) {

cc/modules/face/LBPHFaceRecognizer.cc

@@ -14,7 +14,7 @@ NAN_MODULE_INIT(LBPHFaceRecognizer::Init) {
 	ctor->SetClassName(Nan::New("LBPHFaceRecognizer").ToLocalChecked());
 	instanceTemplate->SetInternalFieldCount(1);
 
-	target->Set(Nan::New("LBPHFaceRecognizer").ToLocalChecked(), ctor->GetFunction());
+	target->Set(Nan::New("LBPHFaceRecognizer").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 struct LBPHFaceRecognizer::NewWorker : public FF::SimpleWorker {

cc/modules/features2d/BFMatcher.cc

@@ -20,7 +20,7 @@ NAN_MODULE_INIT(BFMatcher::Init) {
     Nan::SetPrototypeMethod(ctor, "knnMatch", knnMatch);
     Nan::SetPrototypeMethod(ctor, "knnMatchAsync", knnMatchAsync);
 
-    target->Set(Nan::New("BFMatcher").ToLocalChecked(), ctor->GetFunction());
+    target->Set(Nan::New("BFMatcher").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(BFMatcher::New) {

cc/modules/features2d/DescriptorMatch.cc

@@ -12,7 +12,7 @@ NAN_MODULE_INIT(DescriptorMatch::Init) {
   Nan::SetAccessor(ctor->InstanceTemplate(), Nan::New("trainIdx").ToLocalChecked(), GetTrainIdx);
   Nan::SetAccessor(ctor->InstanceTemplate(), Nan::New("distance").ToLocalChecked(), GetDistance);
 
-  target->Set(Nan::New("DescriptorMatch").ToLocalChecked(), ctor->GetFunction());
+  target->Set(Nan::New("DescriptorMatch").ToLocalChecked(), FF::getFunction(ctor));
 };
 
 NAN_METHOD(DescriptorMatch::New) {