Upgrade utils report
Upgrade utils report
npm remove nan --save
npm install nan --save to get the last version
node-gyp rebuild
- Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor;
+ Nan::Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(BackgroundSubtractorWrap::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(BackgroundSubtractorWrap::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("BackgroundSubtractor"));
+ ctor->SetClassName(Nan::New("BackgroundSubtractor").ToLocalChecked());
- NODE_SET_METHOD(ctor, "createMOG", CreateMOG);
NODE_SET_PROTOTYPE_METHOD(ctor, "applyMOG", ApplyMOG);
+ Nan::SetMethod(ctor, "createMOG", CreateMOG);
Nan::SetPrototypeMethod(ctor, "applyMOG", ApplyMOG);
- target->Set(NanNew("BackgroundSubtractor"), ctor->GetFunction());
+ target->Set(Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
+ if (info.This()->InternalFieldCount() == 0) {
- pt->Wrap(args.This());
+ pt->Wrap(info.This());
- NanReturnValue(args.This());
+ info.GetReturnValue().Set(info.This());
- NanScope();
+ Nan::HandleScope scope;
- // if(args.Length() > 1){
+ // if(info.Length() > 1){
- Local<Object> n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance();
+ Local<Object> n = Nan::New(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance();
- NanReturnValue( n );
+ info.GetReturnValue().Set( n );
- if (args.Length() == 0) {
argv[0] = NanNew("Input image missing");
argv[1] = NanNull();
cb->Call(NanGetCurrentContext()->Global(), 2, argv);
NanReturnUndefined();
+ if (info.Length() == 0) {
argv[0] = Nan::New("Input image missing").ToLocalChecked();
argv[1] = Nan::Null();
cb->Call(Nan::GetCurrentContext()->Global(), 2, argv);
return;
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(fgMask);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(fgMask);
- if (Buffer::HasInstance(args[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject());
unsigned len = Buffer::Length(args[0]->ToObject());
+ if (Buffer::HasInstance(info[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject());
unsigned len = Buffer::Length(info[0]->ToObject());
- Matrix *_img = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *_img = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- return NanThrowTypeError("Error loading file");
+ return Nan::ThrowTypeError("Error loading file");
- argv[0] = NanNull();
+ argv[0] = Nan::Null();
- cb->Call(NanGetCurrentContext()->Global(), 2, argv);
+ cb->Call(Nan::GetCurrentContext()->Global(), 2, argv);
- NanReturnUndefined();
+ return;
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *matrix = ObjectWrap::Unwrap<Matrix>(matrixWrap);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *matrix = Nan::ObjectWrap::Unwrap<Matrix>(matrixWrap);
- Matrix* m = ObjectWrap::Unwrap<Matrix>(matrix->ToObject());
+ Matrix* m = Nan::ObjectWrap::Unwrap<Matrix>(matrix->ToObject());
- cv::Point2f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
pt->Get(NanNew<String>("y"))->ToNumber()->Value()));
+ cv::Point2f(pt->Get(Nan::New<String>("x").ToLocalChecked())->ToNumber()->Value(),
pt->Get(Nan::New<String>("y").ToLocalChecked())->ToNumber()->Value()));
- cv::Point3f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
pt->Get(NanNew<String>("y"))->ToNumber()->Value(),
pt->Get(NanNew<String>("z"))->ToNumber()->Value()));
+ cv::Point3f(pt->Get(Nan::New<String>("x").ToLocalChecked())->ToNumber()->Value(),
pt->Get(Nan::New<String>("y").ToLocalChecked())->ToNumber()->Value(),
pt->Get(Nan::New<String>("z").ToLocalChecked())->ToNumber()->Value()));
- Persistent<Object> inner;
Local<Object> obj = NanNew<Object>();
NanAssignPersistent(inner, obj);
+ Nan::Persistent<Object> inner;
Local<Object> obj = Nan::New<Object>();
inner.Reset(obj);
- NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners);
NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners);
NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera);
NODE_SET_METHOD(obj, "solvePnP", SolvePnP);
NODE_SET_METHOD(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix);
NODE_SET_METHOD(obj, "stereoCalibrate", StereoCalibrate);
NODE_SET_METHOD(obj, "stereoRectify", StereoRectify);
NODE_SET_METHOD(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines);
NODE_SET_METHOD(obj, "reprojectImageTo3d", ReprojectImageTo3D);
+ Nan::SetMethod(obj, "findChessboardCorners", FindChessboardCorners);
Nan::SetMethod(obj, "drawChessboardCorners", DrawChessboardCorners);
Nan::SetMethod(obj, "calibrateCamera", CalibrateCamera);
Nan::SetMethod(obj, "solvePnP", SolvePnP);
Nan::SetMethod(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix);
Nan::SetMethod(obj, "stereoCalibrate", StereoCalibrate);
Nan::SetMethod(obj, "stereoRectify", StereoRectify);
Nan::SetMethod(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines);
Nan::SetMethod(obj, "reprojectImageTo3d", ReprojectImageTo3D);
- target->Set(NanNew("calib3d"), obj);
+ target->Set(Nan::New("calib3d").ToLocalChecked(), obj);
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- cv::Mat mat = matFromMatrix(args[0]);
+ cv::Mat mat = matFromMatrix(info[0]);
- cv::Size patternSize = sizeFromArray(args[1]);
+ cv::Size patternSize = sizeFromArray(info[1]);
- Local<Object> ret = NanNew<Object>();
ret->Set(NanNew<String>("found"), NanNew<Boolean>(found));
+ Local<Object> ret = Nan::New<Object>();
ret->Set(Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found));
- Local<Array> cornersArray = NanNew<Array>(corners.size());
+ Local<Array> cornersArray = Nan::New<Array>(corners.size());
- Local<Object> point_data = NanNew<Object>();
point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
+ Local<Object> point_data = Nan::New<Object>();
point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x));
point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y));
- cornersArray->Set(NanNew<Number>(i), point_data);
+ cornersArray->Set(Nan::New<Number>(i), point_data);
- ret->Set(NanNew<String>("corners"), cornersArray);
+ ret->Set(Nan::New<String>("corners").ToLocalChecked(), cornersArray);
- NanReturnValue(ret);
+ info.GetReturnValue().Set(ret);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- cv::Mat mat = matFromMatrix(args[0]);
+ cv::Mat mat = matFromMatrix(info[0]);
- cv::Size patternSize = sizeFromArray(args[1]);
+ cv::Size patternSize = sizeFromArray(info[1]);
- std::vector<cv::Point2f> corners = points2fFromArray(args[2]);
+ std::vector<cv::Point2f> corners = points2fFromArray(info[2]);
- bool patternWasFound = args[3]->ToBoolean()->Value();
+ bool patternWasFound = info[3]->ToBoolean()->Value();
- NanReturnValue(args[0]);
+ info.GetReturnValue().Set(info[0]);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- points3fFromArrayOfArrays(args[0]);
+ points3fFromArrayOfArrays(info[0]);
- points2fFromArrayOfArrays(args[1]);
+ points2fFromArrayOfArrays(info[1]);
- cv::Size imageSize = sizeFromArray(args[2]);
+ cv::Size imageSize = sizeFromArray(info[2]);
- Local<Object> ret = NanNew<Object>();
+ Local<Object> ret = Nan::New<Object>();
- ret->Set(NanNew<String>("reprojectionError"), NanNew<Number>(error));
+ ret->Set(Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error));
- ret->Set(NanNew<String>("K"), KMatrixWrap);
+ ret->Set(Nan::New<String>("K").ToLocalChecked(), KMatrixWrap);
- ret->Set(NanNew<String>("distortion"), distMatrixWrap);
+ ret->Set(Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap);
- NanReturnValue(ret);
+ info.GetReturnValue().Set(ret);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- std::vector<cv::Point3f> objectPoints = points3fFromArray(args[0]);
+ std::vector<cv::Point3f> objectPoints = points3fFromArray(info[0]);
- std::vector<cv::Point2f> imagePoints = points2fFromArray(args[1]);
+ std::vector<cv::Point2f> imagePoints = points2fFromArray(info[1]);
- cv::Mat K = matFromMatrix(args[2]);
+ cv::Mat K = matFromMatrix(info[2]);
- cv::Mat dist = matFromMatrix(args[3]);
+ cv::Mat dist = matFromMatrix(info[3]);
- Local<Object> ret = NanNew<Object>();
+ Local<Object> ret = Nan::New<Object>();
- ret->Set(NanNew<String>("rvec"), rMatrixWrap);
+ ret->Set(Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap);
- ret->Set(NanNew<String>("tvec"), tMatrixWrap);
+ ret->Set(Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap);
- NanReturnValue(ret);
+ info.GetReturnValue().Set(ret);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- cv::Mat Kin = matFromMatrix(args[0]);
+ cv::Mat Kin = matFromMatrix(info[0]);
- cv::Mat dist = matFromMatrix(args[1]);
+ cv::Mat dist = matFromMatrix(info[1]);
- cv::Size imageSize = sizeFromArray(args[2]);
+ cv::Size imageSize = sizeFromArray(info[2]);
- double alpha = args[3]->ToNumber()->Value();
+ double alpha = info[3]->ToNumber()->Value();
- cv::Size newImageSize = sizeFromArray(args[4]);
+ cv::Size newImageSize = sizeFromArray(info[4]);
- NanReturnValue(KMatrixWrap);
+ info.GetReturnValue().Set(KMatrixWrap);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- points3fFromArrayOfArrays(args[0]);
+ points3fFromArrayOfArrays(info[0]);
- points2fFromArrayOfArrays(args[1]);
+ points2fFromArrayOfArrays(info[1]);
- points2fFromArrayOfArrays(args[2]);
+ points2fFromArrayOfArrays(info[2]);
- cv::Size imageSize = sizeFromArray(args[3]);
+ cv::Size imageSize = sizeFromArray(info[3]);
- if (args.Length() >= 8) {
k1 = matFromMatrix(args[4]);
d1 = matFromMatrix(args[5]);
+ if (info.Length() >= 8) {
k1 = matFromMatrix(info[4]);
d1 = matFromMatrix(info[5]);
- k2 = matFromMatrix(args[6]);
d2 = matFromMatrix(args[7]);
+ k2 = matFromMatrix(info[6]);
d2 = matFromMatrix(info[7]);
- Local<Object> ret = NanNew<Object>();
+ Local<Object> ret = Nan::New<Object>();
- ret->Set(NanNew<String>("K1"), K1MatrixWrap);
ret->Set(NanNew<String>("distortion1"), d1MatrixWrap);
ret->Set(NanNew<String>("K2"), K2MatrixWrap);
ret->Set(NanNew<String>("distortion2"), d2MatrixWrap);
ret->Set(NanNew<String>("R"), RMatrixWrap);
ret->Set(NanNew<String>("t"), tMatrixWrap);
ret->Set(NanNew<String>("E"), EMatrixWrap);
ret->Set(NanNew<String>("F"), FMatrixWrap);
+ ret->Set(Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap);
ret->Set(Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap);
ret->Set(Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap);
ret->Set(Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap);
ret->Set(Nan::New<String>("R").ToLocalChecked(), RMatrixWrap);
ret->Set(Nan::New<String>("t").ToLocalChecked(), tMatrixWrap);
ret->Set(Nan::New<String>("E").ToLocalChecked(), EMatrixWrap);
ret->Set(Nan::New<String>("F").ToLocalChecked(), FMatrixWrap);
- NanReturnValue(ret);
+ info.GetReturnValue().Set(ret);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- cv::Mat K1 = matFromMatrix(args[0]);
+ cv::Mat K1 = matFromMatrix(info[0]);
- cv::Mat d1 = matFromMatrix(args[1]);
+ cv::Mat d1 = matFromMatrix(info[1]);
- cv::Mat K2 = matFromMatrix(args[2]);
+ cv::Mat K2 = matFromMatrix(info[2]);
- cv::Mat d2 = matFromMatrix(args[3]);
+ cv::Mat d2 = matFromMatrix(info[3]);
- cv::Size imageSize = sizeFromArray(args[4]);
+ cv::Size imageSize = sizeFromArray(info[4]);
- cv::Mat R = matFromMatrix(args[5]);
+ cv::Mat R = matFromMatrix(info[5]);
- cv::Mat t = matFromMatrix(args[6]);
+ cv::Mat t = matFromMatrix(info[6]);
- Local<Object> ret = NanNew<Object>();
+ Local<Object> ret = Nan::New<Object>();
- ret->Set(NanNew<String>("R1"), matrixFromMat(R1));
ret->Set(NanNew<String>("R2"), matrixFromMat(R2));
ret->Set(NanNew<String>("P1"), matrixFromMat(P1));
ret->Set(NanNew<String>("P2"), matrixFromMat(P2));
ret->Set(NanNew<String>("Q"), matrixFromMat(Q));
+ ret->Set(Nan::New<String>("R1").ToLocalChecked(), matrixFromMat(R1));
ret->Set(Nan::New<String>("R2").ToLocalChecked(), matrixFromMat(R2));
ret->Set(Nan::New<String>("P1").ToLocalChecked(), matrixFromMat(P1));
ret->Set(Nan::New<String>("P2").ToLocalChecked(), matrixFromMat(P2));
ret->Set(Nan::New<String>("Q").ToLocalChecked(), matrixFromMat(Q));
- NanReturnValue(ret);
+ info.GetReturnValue().Set(ret);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- std::vector<cv::Point2f> points = points2fFromArray(args[0]);
+ std::vector<cv::Point2f> points = points2fFromArray(info[0]);
- int whichImage = int(args[1]->ToNumber()->Value());
+ int whichImage = int(info[1]->ToNumber()->Value());
- cv::Mat F = matFromMatrix(args[2]);
+ cv::Mat F = matFromMatrix(info[2]);
- Local<Array> linesArray = NanNew<Array>(lines.size());
+ Local<Array> linesArray = Nan::New<Array>(lines.size());
- Local<Object> line_data = NanNew<Object>();
line_data->Set(NanNew<String>("a"), NanNew<Number>(lines[i][0]));
line_data->Set(NanNew<String>("b"), NanNew<Number>(lines[i][1]));
line_data->Set(NanNew<String>("c"), NanNew<Number>(lines[i][2]));
+ Local<Object> line_data = Nan::New<Object>();
line_data->Set(Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0]));
line_data->Set(Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1]));
line_data->Set(Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2]));
- linesArray->Set(NanNew<Number>(i), line_data);
+ linesArray->Set(Nan::New<Number>(i), line_data);
- NanReturnValue(linesArray);
+ info.GetReturnValue().Set(linesArray);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- cv::Mat disparity = matFromMatrix(args[0]);
+ cv::Mat disparity = matFromMatrix(info[0]);
- cv::Mat Q = matFromMatrix(args[1]);
+ cv::Mat Q = matFromMatrix(info[1]);
- NanReturnValue(depthImageMatrix);
+ info.GetReturnValue().Set(depthImageMatrix);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- class BackgroundSubtractorWrap: public node::ObjectWrap {
+ class BackgroundSubtractorWrap: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- Persistent<FunctionTemplate> TrackedObject::constructor;
+ Nan::Persistent<FunctionTemplate> TrackedObject::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(TrackedObject::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(TrackedObject::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("TrackedObject"));
+ ctor->SetClassName(Nan::New("TrackedObject").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "track", Track);
+ Nan::SetPrototypeMethod(ctor, "track", Track);
- target->Set(NanNew("TrackedObject"), ctor->GetFunction());
+ target->Set(Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
+ if (info.This()->InternalFieldCount() == 0) {
- Matrix* m = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- if (args[1]->IsArray()) {
Local<Object> v8rec = args[1]->ToObject();
+ if (info[1]->IsArray()) {
Local<Object> v8rec = info[1]->ToObject();
- if (args[2]->IsObject()) {
Local<Object> opts = args[2]->ToObject();
+ if (info[2]->IsObject()) {
Local<Object> opts = info[2]->ToObject();
- if (opts->Get(NanNew("channel"))->IsString()) {
v8::String::Utf8Value c(opts->Get(NanNew("channel"))->ToString());
+ if (opts->Get(Nan::New("channel").ToLocalChecked())->IsString()) {
v8::String::Utf8Value c(opts->Get(Nan::New("channel").ToLocalChecked())->ToString());
- to->Wrap(args.This());
NanReturnValue(args.This());
+ to->Wrap(info.This());
info.GetReturnValue().Set(info.This());
- if (args.Length() != 1) {
NanThrowTypeError("track takes an image param");
NanReturnUndefined();
+ if (info.Length() != 1) {
Nan::ThrowTypeError("track takes an image param");
return;
- Matrix *im = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *im = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- return NanThrowTypeError("OPENCV ERROR: prev rectangle is illogical");
+ return Nan::ThrowTypeError("OPENCV ERROR: prev rectangle is illogical");
- v8::Local<v8::Array> arr = NanNew<Array>(4);
+ v8::Local<v8::Array> arr = Nan::New<Array>(4);
- arr->Set(0, NanNew<Number>(bounds.x));
arr->Set(1, NanNew<Number>(bounds.y));
arr->Set(2, NanNew<Number>(bounds.x + bounds.width));
arr->Set(3, NanNew<Number>(bounds.y + bounds.height));
+ arr->Set(0, Nan::New<Number>(bounds.x));
arr->Set(1, Nan::New<Number>(bounds.y));
arr->Set(2, Nan::New<Number>(bounds.x + bounds.width));
arr->Set(3, Nan::New<Number>(bounds.y + bounds.height));
- arr->Set(i, NanNew<Number>(pts[i].x));
arr->Set(i + 1, NanNew<Number>(pts[i].y));
+ arr->Set(i, Nan::New<Number>(pts[i].x));
arr->Set(i + 1, Nan::New<Number>(pts[i].y));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- class Calib3D: public node::ObjectWrap {
+ class Calib3D: public Nan::ObjectWrap {
- Persistent<FunctionTemplate> CascadeClassifierWrap::constructor;
+ Nan::Persistent<FunctionTemplate> CascadeClassifierWrap::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate> (CascadeClassifierWrap::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate> (CascadeClassifierWrap::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("CascadeClassifier"));
+ ctor->SetClassName(Nan::New("CascadeClassifier").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "detectMultiScale", DetectMultiScale);
+ Nan::SetPrototypeMethod(ctor, "detectMultiScale", DetectMultiScale);
- target->Set(NanNew("CascadeClassifier"), ctor->GetFunction());
+ target->Set(Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new");
+ if (info.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new");
- CascadeClassifierWrap *pt = new CascadeClassifierWrap(*args[0]);
pt->Wrap(args.This());
NanReturnValue( args.This() );
+ CascadeClassifierWrap *pt = new CascadeClassifierWrap(*info[0]);
pt->Wrap(info.This());
info.GetReturnValue().Set( info.This() );
- filename = std::string(*NanAsciiString(fileName->ToString()));
+ filename = std::string(*Nan::Utf8String(fileName->ToString()));
- NanThrowTypeError("Error loading file");
+ Nan::ThrowTypeError("Error loading file");
- class AsyncDetectMultiScale: public NanAsyncWorker {
+ class AsyncDetectMultiScale: public Nan::AsyncWorker {
- AsyncDetectMultiScale(NanCallback *callback, CascadeClassifierWrap *cc,
+ AsyncDetectMultiScale(Nan::Callback *callback, CascadeClassifierWrap *cc,
- NanAsyncWorker(callback),
+ Nan::AsyncWorker(callback),
- NanScope();
+ Nan::HandleScope scope;
- v8::Local < v8::Array > arr = NanNew < v8::Array > (this->res.size());
+ v8::Local < v8::Array > arr = Nan::New < v8::Array > (this->res.size());
- v8::Local < v8::Object > x = NanNew<v8::Object>();
x->Set(NanNew("x"), NanNew < Number > (this->res[i].x));
x->Set(NanNew("y"), NanNew < Number > (this->res[i].y));
x->Set(NanNew("width"), NanNew < Number > (this->res[i].width));
x->Set(NanNew("height"), NanNew < Number > (this->res[i].height));
+ v8::Local < v8::Object > x = Nan::New<v8::Object>();
x->Set(Nan::New("x").ToLocalChecked(), Nan::New < Number > (this->res[i].x));
x->Set(Nan::New("y").ToLocalChecked(), Nan::New < Number > (this->res[i].y));
x->Set(Nan::New("width").ToLocalChecked(), Nan::New < Number > (this->res[i].width));
x->Set(Nan::New("height").ToLocalChecked(), Nan::New < Number > (this->res[i].height));
- argv[0] = NanNull();
+ argv[0] = Nan::Null();
- NanScope();
+ Nan::HandleScope scope;
- CascadeClassifierWrap *self = ObjectWrap::Unwrap<CascadeClassifierWrap> (args.This());
+ CascadeClassifierWrap *self = Nan::ObjectWrap::Unwrap<CascadeClassifierWrap> (info.This());
- if (args.Length() < 2) {
NanThrowTypeError("detectMultiScale takes at least 2 args");
+ if (info.Length() < 2) {
Nan::ThrowTypeError("detectMultiScale takes at least 2 info");
- Matrix *im = ObjectWrap::Unwrap < Matrix > (args[0]->ToObject());
+ Matrix *im = Nan::ObjectWrap::Unwrap < Matrix > (info[0]->ToObject());
- if (args.Length() > 2 && args[2]->IsNumber()) {
scale = args[2]->NumberValue();
+ if (info.Length() > 2 && info[2]->IsNumber()) {
scale = info[2]->NumberValue();
- if (args.Length() > 3 && args[3]->IsInt32()) {
neighbors = args[3]->IntegerValue();
+ if (info.Length() > 3 && info[3]->IsInt32()) {
neighbors = info[3]->IntegerValue();
- if (args.Length() > 5 && args[4]->IsInt32() && args[5]->IsInt32()) {
minw = args[4]->IntegerValue();
minh = args[5]->IntegerValue();
+ if (info.Length() > 5 && info[4]->IsInt32() && info[5]->IsInt32()) {
minw = info[4]->IntegerValue();
minh = info[5]->IntegerValue();
- NanCallback *callback = new NanCallback(cb.As<Function>());
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
- NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale,
+ Nan::AsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale,
- NanReturnUndefined();
+ return;
- class CascadeClassifierWrap: public node::ObjectWrap {
+ class CascadeClassifierWrap: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- class TrackedObject: public node::ObjectWrap {
+ class TrackedObject: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- class Constants: public node::ObjectWrap {
+ class Constants: public Nan::ObjectWrap {
- obj->Set(NanNew<String>(#C), NanNew<Integer>(C));
+ obj->Set(Nan::New<String>(#C), Nan::New<Integer>(C));
- obj->Set(NanNew<String>(#C), NanNew<Integer>((int)(cv::C)));
+ obj->Set(Nan::New<String>(#C), Nan::New<Integer>((int)(cv::C)));
- Persistent<Object> inner;
Local<Object> obj = NanNew<Object>();
NanAssignPersistent(inner, obj);
+ Nan::Persistent<Object> inner;
Local<Object> obj = Nan::New<Object>();
inner.Reset(obj);
- target->Set(NanNew("Constants"), obj);
+ target->Set(Nan::New("Constants").ToLocalChecked(), obj);
- v8::Persistent<FunctionTemplate> Contour::constructor;
+ Nan::Persistent<FunctionTemplate> Contour::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Contour::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(Contour::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("Contours"));
+ ctor->SetClassName(Nan::New("Contours").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "point", Point);
NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size);
NODE_SET_PROTOTYPE_METHOD(ctor, "cornerCount", CornerCount);
NODE_SET_PROTOTYPE_METHOD(ctor, "area", Area);
NODE_SET_PROTOTYPE_METHOD(ctor, "arcLength", ArcLength);
NODE_SET_PROTOTYPE_METHOD(ctor, "approxPolyDP", ApproxPolyDP);
NODE_SET_PROTOTYPE_METHOD(ctor, "convexHull", ConvexHull);
NODE_SET_PROTOTYPE_METHOD(ctor, "boundingRect", BoundingRect);
NODE_SET_PROTOTYPE_METHOD(ctor, "minAreaRect", MinAreaRect);
NODE_SET_PROTOTYPE_METHOD(ctor, "fitEllipse", FitEllipse);
NODE_SET_PROTOTYPE_METHOD(ctor, "isConvex", IsConvex);
NODE_SET_PROTOTYPE_METHOD(ctor, "moments", Moments);
NODE_SET_PROTOTYPE_METHOD(ctor, "hierarchy", Hierarchy);
NODE_SET_PROTOTYPE_METHOD(ctor, "serialize", Serialize);
NODE_SET_PROTOTYPE_METHOD(ctor, "deserialize", Deserialize);
target->Set(NanNew("Contours"), ctor->GetFunction());
+ Nan::SetPrototypeMethod(ctor, "point", Point);
Nan::SetPrototypeMethod(ctor, "size", Size);
Nan::SetPrototypeMethod(ctor, "cornerCount", CornerCount);
Nan::SetPrototypeMethod(ctor, "area", Area);
Nan::SetPrototypeMethod(ctor, "arcLength", ArcLength);
Nan::SetPrototypeMethod(ctor, "approxPolyDP", ApproxPolyDP);
Nan::SetPrototypeMethod(ctor, "convexHull", ConvexHull);
Nan::SetPrototypeMethod(ctor, "boundingRect", BoundingRect);
Nan::SetPrototypeMethod(ctor, "minAreaRect", MinAreaRect);
Nan::SetPrototypeMethod(ctor, "fitEllipse", FitEllipse);
Nan::SetPrototypeMethod(ctor, "isConvex", IsConvex);
Nan::SetPrototypeMethod(ctor, "moments", Moments);
Nan::SetPrototypeMethod(ctor, "hierarchy", Hierarchy);
Nan::SetPrototypeMethod(ctor, "serialize", Serialize);
Nan::SetPrototypeMethod(ctor, "deserialize", Deserialize);
target->Set(Nan::New("Contours").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new");
+ if (info.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new");
- contours->Wrap(args.Holder());
NanReturnValue(args.Holder());
+ contours->Wrap(info.Holder());
info.GetReturnValue().Set(info.Holder());
- ObjectWrap() {
+ Nan::ObjectWrap() {
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
int index = args[1]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
int index = info[1]->NumberValue();
- Local<Object> data = NanNew<Object>();
data->Set(NanNew("x"), NanNew<Number>(point.x));
data->Set(NanNew("y"), NanNew<Number>(point.y));
+ Local<Object> data = Nan::New<Object>();
data->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x));
data->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y));
- NanReturnValue(data);
+ info.GetReturnValue().Set(data);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- Local<Array> data = NanNew<Array>(points.size());
+ Local<Array> data = Nan::New<Array>(points.size());
- Local<Object> point_data = NanNew<Object>();
point_data->Set(NanNew<String>("x"), NanNew<Number>(points[i].x));
point_data->Set(NanNew<String>("y"), NanNew<Number>(points[i].y));
+ Local<Object> point_data = Nan::New<Object>();
point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x));
point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y));
- NanReturnValue(data);
+ info.GetReturnValue().Set(data);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
- NanReturnValue(NanNew<Number>(self->contours.size()));
+ info.GetReturnValue().Set(Nan::New<Number>(self->contours.size()));
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- NanReturnValue(NanNew<Number>(self->contours[pos].size()));
+ info.GetReturnValue().Set(Nan::New<Number>(self->contours[pos].size()));
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- // NanReturnValue(NanNew<Number>(contourArea(self->contours)));
NanReturnValue(NanNew<Number>(contourArea(cv::Mat(self->contours[pos]))));
+ // info.GetReturnValue().Set(Nan::New<Number>(contourArea(self->contours)));
info.GetReturnValue().Set(Nan::New<Number>(contourArea(cv::Mat(self->contours[pos]))));
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
bool isClosed = args[1]->BooleanValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
bool isClosed = info[1]->BooleanValue();
- NanReturnValue(NanNew<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
+ info.GetReturnValue().Set(Nan::New<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
double epsilon = args[1]->NumberValue();
bool isClosed = args[2]->BooleanValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
double epsilon = info[1]->NumberValue();
bool isClosed = info[2]->BooleanValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
- int pos = args[0]->NumberValue();
bool clockwise = args[1]->BooleanValue();
+ int pos = info[0]->NumberValue();
bool clockwise = info[1]->BooleanValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- Local<Object> rect = NanNew<Object>();
+ Local<Object> rect = Nan::New<Object>();
- rect->Set(NanNew("x"), NanNew<Number>(bounding.x));
rect->Set(NanNew("y"), NanNew<Number>(bounding.y));
rect->Set(NanNew("width"), NanNew<Number>(bounding.width));
rect->Set(NanNew("height"), NanNew<Number>(bounding.height));
+ rect->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x));
rect->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y));
rect->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width));
rect->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height));
- NanReturnValue(rect);
+ info.GetReturnValue().Set(rect);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- Local<Object> rect = NanNew<Object>();
rect->Set(NanNew("angle"), NanNew<Number>(minimum.angle));
+ Local<Object> rect = Nan::New<Object>();
rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle));
- Local<Object> size = NanNew<Object>();
size->Set(NanNew("height"), NanNew<Number>(minimum.size.height));
size->Set(NanNew("width"), NanNew<Number>(minimum.size.width));
rect->Set(NanNew("size"), size);
+ Local<Object> size = Nan::New<Object>();
size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height));
size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width));
rect->Set(Nan::New("size").ToLocalChecked(), size);
- Local<Object> center = NanNew<Object>();
center->Set(NanNew("x"), NanNew<Number>(minimum.center.x));
center->Set(NanNew("y"), NanNew<Number>(minimum.center.y));
+ Local<Object> center = Nan::New<Object>();
center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x));
center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y));
- v8::Local<v8::Array> points = NanNew<Array>(4);
+ v8::Local<v8::Array> points = Nan::New<Array>(4);
- Local<Object> point = NanNew<Object>();
point->Set(NanNew("x"), NanNew<Number>(rect_points[i].x));
point->Set(NanNew("y"), NanNew<Number>(rect_points[i].y));
+ Local<Object> point = Nan::New<Object>();
point->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x));
point->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y));
- rect->Set(NanNew("points"), points);
+ rect->Set(Nan::New("points").ToLocalChecked(), points);
- NanReturnValue(rect);
+ info.GetReturnValue().Set(rect);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- Local<Object> jsEllipse = NanNew<Object>();
jsEllipse->Set(NanNew("angle"), NanNew<Number>(ellipse.angle));
+ Local<Object> jsEllipse = Nan::New<Object>();
jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle));
- Local<Object> size = NanNew<Object>();
size->Set(NanNew("height"), NanNew<Number>(ellipse.size.height));
size->Set(NanNew("width"), NanNew<Number>(ellipse.size.width));
jsEllipse->Set(NanNew("size"), size);
+ Local<Object> size = Nan::New<Object>();
size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height));
size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width));
jsEllipse->Set(Nan::New("size").ToLocalChecked(), size);
- Local<Object> center = NanNew<Object>();
center->Set(NanNew("x"), NanNew<Number>(ellipse.center.x));
center->Set(NanNew("y"), NanNew<Number>(ellipse.center.y));
jsEllipse->Set(NanNew("center"), center);
+ Local<Object> center = Nan::New<Object>();
center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x));
center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y));
jsEllipse->Set(Nan::New("center").ToLocalChecked(), center);
- NanReturnValue(jsEllipse);
+ info.GetReturnValue().Set(jsEllipse);
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- NanReturnValue(NanNew<Boolean>(isContourConvex(cv::Mat(self->contours[pos]))));
+ info.GetReturnValue().Set(Nan::New<Boolean>(isContourConvex(cv::Mat(self->contours[pos]))));
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->NumberValue();
- Local<Object> res = NanNew<Object>();
+ Local<Object> res = Nan::New<Object>();
- res->Set(NanNew("m00"), NanNew<Number>(mu.m00));
res->Set(NanNew("m10"), NanNew<Number>(mu.m10));
res->Set(NanNew("m01"), NanNew<Number>(mu.m01));
res->Set(NanNew("m11"), NanNew<Number>(mu.m11));
+ res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00));
res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10));
res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01));
res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11));
- NanReturnValue(res);
+ info.GetReturnValue().Set(res);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->IntegerValue();
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0]->IntegerValue();
- Local<Array> res = NanNew<Array>(4);
+ Local<Array> res = Nan::New<Array>(4);
- res->Set(0, NanNew<Number>(hierarchy[0]));
res->Set(1, NanNew<Number>(hierarchy[1]));
res->Set(2, NanNew<Number>(hierarchy[2]));
res->Set(3, NanNew<Number>(hierarchy[3]));
+ res->Set(0, Nan::New<Number>(hierarchy[0]));
res->Set(1, Nan::New<Number>(hierarchy[1]));
res->Set(2, Nan::New<Number>(hierarchy[2]));
res->Set(3, Nan::New<Number>(hierarchy[3]));
- NanReturnValue(res);
+ info.GetReturnValue().Set(res);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
- Local<Array> contours_data = NanNew<Array>(self->contours.size());
+ Local<Array> contours_data = Nan::New<Array>(self->contours.size());
- Local<Array> contour_data = NanNew<Array>(points.size());
+ Local<Array> contour_data = Nan::New<Array>(points.size());
- Local<Array> point_data = NanNew<Array>(2);
point_data->Set(0, NanNew<Number>(points[j].x));
point_data->Set(1, NanNew<Number>(points[j].y));
+ Local<Array> point_data = Nan::New<Array>(2);
point_data->Set(0, Nan::New<Number>(points[j].x));
point_data->Set(1, Nan::New<Number>(points[j].y));
- Local<Array> hierarchy_data = NanNew<Array>(self->hierarchy.size());
+ Local<Array> hierarchy_data = Nan::New<Array>(self->hierarchy.size());
- Local<Array> contour_data = NanNew<Array>(4);
contour_data->Set(0, NanNew<Number>(self->hierarchy[i][0]));
contour_data->Set(1, NanNew<Number>(self->hierarchy[i][1]));
contour_data->Set(2, NanNew<Number>(self->hierarchy[i][2]));
contour_data->Set(3, NanNew<Number>(self->hierarchy[i][3]));
+ Local<Array> contour_data = Nan::New<Array>(4);
contour_data->Set(0, Nan::New<Number>(self->hierarchy[i][0]));
contour_data->Set(1, Nan::New<Number>(self->hierarchy[i][1]));
contour_data->Set(2, Nan::New<Number>(self->hierarchy[i][2]));
contour_data->Set(3, Nan::New<Number>(self->hierarchy[i][3]));
- Local<Object> data = NanNew<Object>();
data->Set(NanNew<String>("contours"), contours_data);
data->Set(NanNew<String>("hierarchy"), hierarchy_data);
+ Local<Object> data = Nan::New<Object>();
data->Set(Nan::New<String>("contours").ToLocalChecked(), contours_data);
data->Set(Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data);
- NanReturnValue(data);
+ info.GetReturnValue().Set(data);
- NanScope();
+ Nan::HandleScope scope;
- Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+ Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
- Handle<Object> data = Handle<Object>::Cast(args[0]);
+ Handle<Object> data = Handle<Object>::Cast(info[0]);
- Handle<Array> contours_data = Handle<Array>::Cast(data->Get(NanNew<String>("contours")));
Handle<Array> hierarchy_data = Handle<Array>::Cast(data->Get(NanNew<String>("hierarchy")));
+ Handle<Array> contours_data = Handle<Array>::Cast(data->Get(Nan::New<String>("contours").ToLocalChecked()));
Handle<Array> hierarchy_data = Handle<Array>::Cast(data->Get(Nan::New<String>("hierarchy").ToLocalChecked()));
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- class Contour: public node::ObjectWrap {
+ class Contour: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- std::string filename = std::string(*NanAsciiString(v->ToString()));
+ std::string filename = std::string(*Nan::Utf8String(v->ToString()));
- Matrix *img = ObjectWrap::Unwrap<Matrix>(v->ToObject());
+ Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(v->ToObject());
- Persistent<FunctionTemplate> FaceRecognizerWrap::constructor;
+ Nan::Persistent<FunctionTemplate> FaceRecognizerWrap::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(FaceRecognizerWrap::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(FaceRecognizerWrap::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("FaceRecognizer"));
+ ctor->SetClassName(Nan::New("FaceRecognizer").ToLocalChecked());
- NODE_SET_METHOD(ctor, "createLBPHFaceRecognizer", CreateLBPH);
NODE_SET_METHOD(ctor, "createEigenFaceRecognizer", CreateEigen);
NODE_SET_METHOD(ctor, "createFisherFaceRecognizer", CreateFisher);
+ Nan::SetMethod(ctor, "createLBPHFaceRecognizer", CreateLBPH);
Nan::SetMethod(ctor, "createEigenFaceRecognizer", CreateEigen);
Nan::SetMethod(ctor, "createFisherFaceRecognizer", CreateFisher);
- NODE_SET_PROTOTYPE_METHOD(ctor, "trainSync", TrainSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "updateSync", UpdateSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "predictSync", PredictSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "saveSync", SaveSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "loadSync", LoadSync);
+ Nan::SetPrototypeMethod(ctor, "trainSync", TrainSync);
Nan::SetPrototypeMethod(ctor, "updateSync", UpdateSync);
Nan::SetPrototypeMethod(ctor, "predictSync", PredictSync);
Nan::SetPrototypeMethod(ctor, "saveSync", SaveSync);
Nan::SetPrototypeMethod(ctor, "loadSync", LoadSync);
- NODE_SET_PROTOTYPE_METHOD(ctor, "getMat", GetMat);
+ Nan::SetPrototypeMethod(ctor, "getMat", GetMat);
- target->Set(NanNew("FaceRecognizer"), ctor->GetFunction());
+ target->Set(Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
+ if (info.This()->InternalFieldCount() == 0) {
- pt->Wrap(args.This());
NanReturnValue(args.This());
+ pt->Wrap(info.This());
info.GetReturnValue().Set(info.This());
- NanScope();
+ Nan::HandleScope scope;
- Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
+ Local<Object> n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
- NanReturnValue( n );
+ info.GetReturnValue().Set( n );
- NanScope();
+ Nan::HandleScope scope;
- Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
+ Local<Object> n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
- NanReturnValue( n );
+ info.GetReturnValue().Set( n );
- NanScope();
+ Nan::HandleScope scope;
- Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
+ Local<Object> n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
- NanReturnValue( n );
+ info.GetReturnValue().Set( n );
- Handle<Value> UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args,
+ Handle<Value> UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info,
- if (args.Length() < 1 || !args[0]->IsArray()) {
+ if (info.Length() < 1 || !info[0]->IsArray()) {
- // const Local<Array> tuples = v8::Array::Cast(*args[0]);
const Local<Array> tuples = Local<Array>::Cast(args[0]);
+ // const Local<Array> tuples = v8::Array::Cast(*info[0]);
const Local<Array> tuples = Local<Array>::Cast(info[0]);
- return NanUndefined();
+ return Nan::Undefined();
- Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
+ Handle<Value> exception = UnwrapTrainingData(info, &images, &labels);
- NanReturnValue(exception); // FIXME: not too sure about returning exceptions like this
+ info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this
- NanReturnUndefined();
+ return;
- Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
+ Handle<Value> exception = UnwrapTrainingData(info, &images, &labels);
- NanReturnUndefined();
+ return;
- cv::Mat im = fromMatrixOrFilename(args[0]); // TODO CHECK!
+ cv::Mat im = fromMatrixOrFilename(info[0]); // TODO CHECK!
- v8::Local<v8::Object> res = NanNew<Object>();
res->Set(NanNew("id"), NanNew<Number>(predictedLabel));
res->Set(NanNew("confidence"), NanNew<Number>(confidence));
+ v8::Local<v8::Object> res = Nan::New<Object>();
res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
- NanReturnValue(res);
+ info.GetReturnValue().Set(res);
- if (!args[0]->IsString()) {
+ if (!info[0]->IsString()) {
- std::string filename = std::string(*NanAsciiString(args[0]->ToString()));
+ std::string filename = std::string(*Nan::Utf8String(info[0]->ToString()));
- NanReturnUndefined();
+ return;
- if (!args[0]->IsString()) {
+ if (!info[0]->IsString()) {
- std::string filename = std::string(*NanAsciiString(args[0]->ToString()));
+ std::string filename = std::string(*Nan::Utf8String(info[0]->ToString()));
- NanReturnUndefined();
+ return;
- if (!args[0]->IsString()) {
+ if (!info[0]->IsString()) {
- std::string key = std::string(*NanAsciiString(args[0]->ToString()));
+ std::string key = std::string(*Nan::Utf8String(info[0]->ToString()));
- Local<Object> im = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im);
+ Local<Object> im = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im);
- NanReturnValue(im);
+ info.GetReturnValue().Set(im);
- class FaceRecognizerWrap: public node::ObjectWrap {
+ class FaceRecognizerWrap: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- NanScope();
+ Nan::HandleScope scope;
- NODE_SET_METHOD(target, "ImageSimilarity", Similarity);
+ Nan::SetMethod(target, "ImageSimilarity", Similarity);
- class AsyncDetectSimilarity: public NanAsyncWorker {
+ class AsyncDetectSimilarity: public Nan::AsyncWorker {
- AsyncDetectSimilarity(NanCallback *callback, cv::Mat image1, cv::Mat image2) :
NanAsyncWorker(callback),
+ AsyncDetectSimilarity(Nan::Callback *callback, cv::Mat image1, cv::Mat image2) :
Nan::AsyncWorker(callback),
- NanScope();
+ Nan::HandleScope scope;
- argv[0] = NanNull();
argv[1] = NanNew<Number>(dissimilarity);
+ argv[0] = Nan::Null();
argv[1] = Nan::New<Number>(dissimilarity);
- NanScope();
+ Nan::HandleScope scope;
- cv::Mat image1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject())->mat;
cv::Mat image2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject())->mat;
+ cv::Mat image1 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject())->mat;
cv::Mat image2 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject())->mat;
- NanCallback *callback = new NanCallback(cb.As<Function>());
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
- NanAsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) );
NanReturnUndefined();
+ Nan::AsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) );
return;
- class Features: public node::ObjectWrap {
+ class Features: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- Persistent<FunctionTemplate> NamedWindow::constructor;
+ Nan::Persistent<FunctionTemplate> NamedWindow::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(NamedWindow::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(NamedWindow::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("NamedWindow"));
+ ctor->SetClassName(Nan::New("NamedWindow").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "show", Show);
NODE_SET_PROTOTYPE_METHOD(ctor, "destroy", Destroy);
NODE_SET_PROTOTYPE_METHOD(ctor, "blockingWaitKey", BlockingWaitKey);
+ Nan::SetPrototypeMethod(ctor, "show", Show);
Nan::SetPrototypeMethod(ctor, "destroy", Destroy);
Nan::SetPrototypeMethod(ctor, "blockingWaitKey", BlockingWaitKey);
- target->Set(NanNew("NamedWindow"), ctor->GetFunction());
+ target->Set(Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
+ if (info.This()->InternalFieldCount() == 0) {
- if (args.Length() == 1) {
win = new NamedWindow(std::string(*NanAsciiString(args[0]->ToString())), 0);
} else { //if (args.Length() == 2){
win = new NamedWindow(std::string(*NanAsciiString(args[0]->ToString())), 0);
+ if (info.Length() == 1) {
win = new NamedWindow(std::string(*Nan::Utf8String(info[0]->ToString())), 0);
} else { //if (info.Length() == 2){
win = new NamedWindow(std::string(*Nan::Utf8String(info[0]->ToString())), 0);
- win->Wrap(args.Holder());
NanReturnValue(args.Holder());
+ win->Wrap(info.Holder());
info.GetReturnValue().Set(info.Holder());
- Matrix *im = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *im = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- NanThrowError(err_msg);
+ Nan::ThrowError(err_msg);
- NanReturnValue(args.Holder());
+ info.GetReturnValue().Set(info.Holder());
- NanReturnValue(args.Holder());
+ info.GetReturnValue().Set(info.Holder());
- NanScope();
+ Nan::HandleScope scope;
- if (args.Length() > 1) {
time = args[1]->IntegerValue();
+ if (info.Length() > 1) {
time = info[1]->IntegerValue();
- if (args.Length() > 0) {
time = args[0]->IntegerValue();
+ if (info.Length() > 0) {
time = info[0]->IntegerValue();
- NanReturnValue(NanNew<Number>(res));
+ info.GetReturnValue().Set(Nan::New<Number>(res));
- class NamedWindow: public node::ObjectWrap {
+ class NamedWindow: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- Persistent<Object> inner;
Local<Object> obj = NanNew<Object>();
NanAssignPersistent(inner, obj);
+ Nan::Persistent<Object> inner;
Local<Object> obj = Nan::New<Object>();
inner.Reset(obj);
- NODE_SET_METHOD(obj, "undistort", Undistort);
NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
NODE_SET_METHOD(obj, "remap", Remap);
+ Nan::SetMethod(obj, "undistort", Undistort);
Nan::SetMethod(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
Nan::SetMethod(obj, "remap", Remap);
- target->Set(NanNew("imgproc"), obj);
+ target->Set(Nan::New("imgproc").ToLocalChecked(), obj);
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+ Matrix* m2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
- Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
+ Local<Object> outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = Nan::ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
- NanReturnValue(outMatrixWrap);
+ info.GetReturnValue().Set(outMatrixWrap);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+ Matrix* m2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
- Matrix* m3 = ObjectWrap::Unwrap<Matrix>(args[3]->ToObject());
+ Matrix* m3 = Nan::ObjectWrap::Unwrap<Matrix>(info[3]->ToObject());
- if (args[4]->IsArray()) {
Local<Object> v8sz = args[4]->ToObject();
+ if (info[4]->IsArray()) {
Local<Object> v8sz = info[4]->ToObject();
- int m1type = args[5]->IntegerValue();
+ int m1type = info[5]->IntegerValue();
- Local<Object> map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map1Matrix = ObjectWrap::Unwrap<Matrix>(map1Wrap);
+ Local<Object> map1Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map1Matrix = Nan::ObjectWrap::Unwrap<Matrix>(map1Wrap);
- Local<Object> map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map2Matrix = ObjectWrap::Unwrap<Matrix>(map2Wrap);
+ Local<Object> map2Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map2Matrix = Nan::ObjectWrap::Unwrap<Matrix>(map2Wrap);
- Local<Object> ret = NanNew<Object>();
ret->Set(NanNew<String>("map1"), map1Wrap);
ret->Set(NanNew<String>("map2"), map2Wrap);
+ Local<Object> ret = Nan::New<Object>();
ret->Set(Nan::New<String>("map1").ToLocalChecked(), map1Wrap);
ret->Set(Nan::New<String>("map2").ToLocalChecked(), map2Wrap);
- NanReturnValue(ret);
+ info.GetReturnValue().Set(ret);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+ Matrix* m2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
- int interpolation = args[3]->IntegerValue();
+ int interpolation = info[3]->IntegerValue();
- Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
+ Local<Object> outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = Nan::ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
- NanReturnValue(outMatrixWrap);
+ info.GetReturnValue().Set(outMatrixWrap);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- class ImgProc: public node::ObjectWrap {
+ class ImgProc: public Nan::ObjectWrap {
- class Matrix: public node::ObjectWrap {
+ class Matrix: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- static Handle<Value> Val(const Arguments& args);
static Handle<Value> RowRange(const Arguments& args);
static Handle<Value> ColRange(const Arguments& args);
static Handle<Value> Diag(const Arguments& args);
static Handle<Value> Clone(const Arguments& args);
static Handle<Value> CopyTo(const Arguments& args);
static Handle<Value> ConvertTo(const Arguments& args);
static Handle<Value> AssignTo(const Arguments& args);
static Handle<Value> SetTo(const Arguments& args);
static Handle<Value> Reshape(const Arguments& args);
static Handle<Value> Transpose(const Arguments& args);
static Handle<Value> Invert(const Arguments& args);
static Handle<Value> Multiply(const Arguments& args);
static Handle<Value> Cross(const Arguments& args);
static Handle<Value> Dot(const Arguments& args);
static Handle<Value> Zeroes(const Arguments& args);
static Handle<Value> Ones(const Arguments& args);
+ static Handle<Value> Val(const Arguments& info);
static Handle<Value> RowRange(const Arguments& info);
static Handle<Value> ColRange(const Arguments& info);
static Handle<Value> Diag(const Arguments& info);
static Handle<Value> Clone(const Arguments& info);
static Handle<Value> CopyTo(const Arguments& info);
static Handle<Value> ConvertTo(const Arguments& info);
static Handle<Value> AssignTo(const Arguments& info);
static Handle<Value> SetTo(const Arguments& info);
static Handle<Value> Reshape(const Arguments& info);
static Handle<Value> Transpose(const Arguments& info);
static Handle<Value> Invert(const Arguments& info);
static Handle<Value> Multiply(const Arguments& info);
static Handle<Value> Cross(const Arguments& info);
static Handle<Value> Dot(const Arguments& info);
static Handle<Value> Zeroes(const Arguments& info);
static Handle<Value> Ones(const Arguments& info);
- static Handle<Value> PushBack(const Arguments& args);
static Handle<Value> PopBack(const Arguments& args);
static Handle<Value> Total(const Arguments& args);
static Handle<Value> IsContinous(const Arguments& args);
static Handle<Value> Type(const Arguments& args);
static Handle<Value> Depth(const Arguments& args);
static Handle<Value> Channels(const Arguments& args);
static Handle<Value> StepOne(const Arguments& args);
static Handle<Value> GetPerspectiveTransform(const Arguments& args);
static Handle<Value> WarpPerspective(const Arguments& args);
+ static Handle<Value> PushBack(const Arguments& info);
static Handle<Value> PopBack(const Arguments& info);
static Handle<Value> Total(const Arguments& info);
static Handle<Value> IsContinous(const Arguments& info);
static Handle<Value> Type(const Arguments& info);
static Handle<Value> Depth(const Arguments& info);
static Handle<Value> Channels(const Arguments& info);
static Handle<Value> StepOne(const Arguments& info);
static Handle<Value> GetPerspectiveTransform(const Arguments& info);
static Handle<Value> WarpPerspective(const Arguments& info);
- NanScope();
+ Nan::HandleScope scope;
- target->Set(NanNew<String>("version"), NanNew<String>(out, n));
+ target->Set(Nan::New<String>("version").ToLocalChecked(), Nan::New<String>(out, n));
- NODE_SET_METHOD(target, "readImage", ReadImage);
+ Nan::SetMethod(target, "readImage", ReadImage);
- NanEscapableScope();
+ Nan::EscapableHandleScope scope;
- argv[0] = NanNull();
+ argv[0] = Nan::Null();
- Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h);
+ Local<Object> im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
- if (args[0]->IsNumber() && args[1]->IsNumber()) {
+ if (info[0]->IsNumber() && info[1]->IsNumber()) {
- width = args[0]->Uint32Value();
height = args[1]->Uint32Value();
+ width = info[0]->Uint32Value();
height = info[1]->Uint32Value();
- } else if (args[0]->IsString()) {
std::string filename = std::string(*NanUtf8String(args[0]->ToString()));
+ } else if (info[0]->IsString()) {
std::string filename = std::string(*Nan::Utf8String(info[0]->ToString()));
- } else if (Buffer::HasInstance(args[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject());
unsigned len = Buffer::Length(args[0]->ToObject());
+ } else if (Buffer::HasInstance(info[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject());
unsigned len = Buffer::Length(info[0]->ToObject());
- argv[0] = NanError("Error loading file");
+ argv[0] = Nan::Error("Error loading file");
- argv[0] = NanError(e.what());
argv[1] = NanNull();
+ argv[0] = Nan::Error(e.what());
argv[1] = Nan::Null();
- cb->Call(NanGetCurrentContext()->Global(), 2, argv);
+ cb->Call(Nan::GetCurrentContext()->Global(), 2, argv);
- NanReturnUndefined();
+ return;
- if (args.Length() <= (I) || !args[I]->IsFunction()) \
return NanThrowTypeError("Argument " #I " must be a function"); \
Local<Function> VAR = Local<Function>::Cast(args[I]);
+ if (info.Length() <= (I) || !info[I]->IsFunction()) \
return Nan::ThrowTypeError("Argument " #I " must be a function"); \
Local<Function> VAR = Local<Function>::Cast(info[I]);
- NanScope(); \
TYP *self = ObjectWrap::Unwrap<TYP>(args.This());
+ Nan::HandleScope scope; \
TYP *self = Nan::ObjectWrap::Unwrap<TYP>(info.This());
- NanThrowTypeError( ERR );
+ Nan::ThrowTypeError( ERR );
- NanThrowError( ERR );
+ Nan::ThrowError( ERR );
- if (args[IND]->IsInt32()){ \
NAME = args[IND]->Uint32Value(); \
+ if (info[IND]->IsInt32()){ \
NAME = info[IND]->Uint32Value(); \
- if (args[IND]->IsInt32()){ \
NAME = args[IND]->NumberValue(); \
+ if (info[IND]->IsInt32()){ \
NAME = info[IND]->NumberValue(); \
- class OpenCV: public node::ObjectWrap {
+ class OpenCV: public Nan::ObjectWrap {
- v8::Persistent<FunctionTemplate> Matrix::constructor;
+ Nan::Persistent<FunctionTemplate> Matrix::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Matrix::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(Matrix::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("Matrix"));
+ ctor->SetClassName(Nan::New("Matrix").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "row", Row);
NODE_SET_PROTOTYPE_METHOD(ctor, "col", Col);
NODE_SET_PROTOTYPE_METHOD(ctor, "pixelRow", PixelRow);
NODE_SET_PROTOTYPE_METHOD(ctor, "pixelCol", PixelCol);
NODE_SET_PROTOTYPE_METHOD(ctor, "empty", Empty);
NODE_SET_PROTOTYPE_METHOD(ctor, "get", Get);
NODE_SET_PROTOTYPE_METHOD(ctor, "set", Set);
NODE_SET_PROTOTYPE_METHOD(ctor, "put", Put);
NODE_SET_PROTOTYPE_METHOD(ctor, "brightness", Brightness);
NODE_SET_PROTOTYPE_METHOD(ctor, "normalize", Normalize);
NODE_SET_PROTOTYPE_METHOD(ctor, "getData", GetData);
NODE_SET_PROTOTYPE_METHOD(ctor, "pixel", Pixel);
NODE_SET_PROTOTYPE_METHOD(ctor, "width", Width);
NODE_SET_PROTOTYPE_METHOD(ctor, "height", Height);
NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size);
NODE_SET_PROTOTYPE_METHOD(ctor, "clone", Clone);
NODE_SET_PROTOTYPE_METHOD(ctor, "crop", Crop);
NODE_SET_PROTOTYPE_METHOD(ctor, "toBuffer", ToBuffer);
NODE_SET_PROTOTYPE_METHOD(ctor, "toBufferAsync", ToBufferAsync);
NODE_SET_PROTOTYPE_METHOD(ctor, "ellipse", Ellipse);
NODE_SET_PROTOTYPE_METHOD(ctor, "rectangle", Rectangle);
NODE_SET_PROTOTYPE_METHOD(ctor, "line", Line);
NODE_SET_PROTOTYPE_METHOD(ctor, "fillPoly", FillPoly);
NODE_SET_PROTOTYPE_METHOD(ctor, "save", Save);
NODE_SET_PROTOTYPE_METHOD(ctor, "saveAsync", SaveAsync);
NODE_SET_PROTOTYPE_METHOD(ctor, "resize", Resize);
NODE_SET_PROTOTYPE_METHOD(ctor, "rotate", Rotate);
NODE_SET_PROTOTYPE_METHOD(ctor, "copyTo", CopyTo);
NODE_SET_PROTOTYPE_METHOD(ctor, "pyrDown", PyrDown);
NODE_SET_PROTOTYPE_METHOD(ctor, "pyrUp", PyrUp);
NODE_SET_PROTOTYPE_METHOD(ctor, "channels", Channels);
NODE_SET_PROTOTYPE_METHOD(ctor, "convertGrayscale", ConvertGrayscale);
NODE_SET_PROTOTYPE_METHOD(ctor, "convertHSVscale", ConvertHSVscale);
NODE_SET_PROTOTYPE_METHOD(ctor, "gaussianBlur", GaussianBlur);
NODE_SET_PROTOTYPE_METHOD(ctor, "medianBlur", MedianBlur);
NODE_SET_PROTOTYPE_METHOD(ctor, "bilateralFilter", BilateralFilter);
NODE_SET_PROTOTYPE_METHOD(ctor, "copy", Copy);
NODE_SET_PROTOTYPE_METHOD(ctor, "flip", Flip);
NODE_SET_PROTOTYPE_METHOD(ctor, "roi", ROI);
NODE_SET_PROTOTYPE_METHOD(ctor, "ptr", Ptr);
NODE_SET_PROTOTYPE_METHOD(ctor, "absDiff", AbsDiff);
NODE_SET_PROTOTYPE_METHOD(ctor, "addWeighted", AddWeighted);
NODE_SET_PROTOTYPE_METHOD(ctor, "bitwiseXor", BitwiseXor);
NODE_SET_PROTOTYPE_METHOD(ctor, "bitwiseNot", BitwiseNot);
NODE_SET_PROTOTYPE_METHOD(ctor, "bitwiseAnd", BitwiseAnd);
NODE_SET_PROTOTYPE_METHOD(ctor, "countNonZero", CountNonZero);
NODE_SET_PROTOTYPE_METHOD(ctor, "canny", Canny);
NODE_SET_PROTOTYPE_METHOD(ctor, "dilate", Dilate);
NODE_SET_PROTOTYPE_METHOD(ctor, "erode", Erode);
NODE_SET_PROTOTYPE_METHOD(ctor, "findContours", FindContours);
NODE_SET_PROTOTYPE_METHOD(ctor, "drawContour", DrawContour);
NODE_SET_PROTOTYPE_METHOD(ctor, "drawAllContours", DrawAllContours);
NODE_SET_PROTOTYPE_METHOD(ctor, "goodFeaturesToTrack", GoodFeaturesToTrack);
NODE_SET_PROTOTYPE_METHOD(ctor, "houghLinesP", HoughLinesP);
NODE_SET_PROTOTYPE_METHOD(ctor, "crop", Crop);
NODE_SET_PROTOTYPE_METHOD(ctor, "houghCircles", HoughCircles);
NODE_SET_PROTOTYPE_METHOD(ctor, "inRange", inRange);
NODE_SET_PROTOTYPE_METHOD(ctor, "adjustROI", AdjustROI);
NODE_SET_PROTOTYPE_METHOD(ctor, "locateROI", LocateROI);
NODE_SET_PROTOTYPE_METHOD(ctor, "threshold", Threshold);
NODE_SET_PROTOTYPE_METHOD(ctor, "adaptiveThreshold", AdaptiveThreshold);
NODE_SET_PROTOTYPE_METHOD(ctor, "meanStdDev", MeanStdDev);
NODE_SET_PROTOTYPE_METHOD(ctor, "cvtColor", CvtColor);
NODE_SET_PROTOTYPE_METHOD(ctor, "split", Split);
NODE_SET_PROTOTYPE_METHOD(ctor, "merge", Merge);
NODE_SET_PROTOTYPE_METHOD(ctor, "equalizeHist", EqualizeHist);
NODE_SET_PROTOTYPE_METHOD(ctor, "floodFill", FloodFill);
NODE_SET_PROTOTYPE_METHOD(ctor, "matchTemplate", MatchTemplate);
NODE_SET_PROTOTYPE_METHOD(ctor, "templateMatches", TemplateMatches);
NODE_SET_PROTOTYPE_METHOD(ctor, "minMaxLoc", MinMaxLoc);
NODE_SET_PROTOTYPE_METHOD(ctor, "pushBack", PushBack);
NODE_SET_PROTOTYPE_METHOD(ctor, "putText", PutText);
NODE_SET_PROTOTYPE_METHOD(ctor, "getPerspectiveTransform", GetPerspectiveTransform);
NODE_SET_PROTOTYPE_METHOD(ctor, "warpPerspective", WarpPerspective);
NODE_SET_METHOD(ctor, "Zeros", Zeros);
NODE_SET_METHOD(ctor, "Ones", Ones);
NODE_SET_METHOD(ctor, "Eye", Eye);
NODE_SET_PROTOTYPE_METHOD(ctor, "copyWithMask", CopyWithMask);
NODE_SET_PROTOTYPE_METHOD(ctor, "setWithMask", SetWithMask);
NODE_SET_PROTOTYPE_METHOD(ctor, "meanWithMask", MeanWithMask);
NODE_SET_PROTOTYPE_METHOD(ctor, "shift", Shift);
NODE_SET_PROTOTYPE_METHOD(ctor, "release", Release);
+ Nan::SetPrototypeMethod(ctor, "row", Row);
Nan::SetPrototypeMethod(ctor, "col", Col);
Nan::SetPrototypeMethod(ctor, "pixelRow", PixelRow);
Nan::SetPrototypeMethod(ctor, "pixelCol", PixelCol);
Nan::SetPrototypeMethod(ctor, "empty", Empty);
Nan::SetPrototypeMethod(ctor, "get", Get);
Nan::SetPrototypeMethod(ctor, "set", Set);
Nan::SetPrototypeMethod(ctor, "put", Put);
Nan::SetPrototypeMethod(ctor, "brightness", Brightness);
Nan::SetPrototypeMethod(ctor, "normalize", Normalize);
Nan::SetPrototypeMethod(ctor, "getData", GetData);
Nan::SetPrototypeMethod(ctor, "pixel", Pixel);
Nan::SetPrototypeMethod(ctor, "width", Width);
Nan::SetPrototypeMethod(ctor, "height", Height);
Nan::SetPrototypeMethod(ctor, "size", Size);
Nan::SetPrototypeMethod(ctor, "clone", Clone);
Nan::SetPrototypeMethod(ctor, "crop", Crop);
Nan::SetPrototypeMethod(ctor, "toBuffer", ToBuffer);
Nan::SetPrototypeMethod(ctor, "toBufferAsync", ToBufferAsync);
Nan::SetPrototypeMethod(ctor, "ellipse", Ellipse);
Nan::SetPrototypeMethod(ctor, "rectangle", Rectangle);
Nan::SetPrototypeMethod(ctor, "line", Line);
Nan::SetPrototypeMethod(ctor, "fillPoly", FillPoly);
Nan::SetPrototypeMethod(ctor, "save", Save);
Nan::SetPrototypeMethod(ctor, "saveAsync", SaveAsync);
Nan::SetPrototypeMethod(ctor, "resize", Resize);
Nan::SetPrototypeMethod(ctor, "rotate", Rotate);
Nan::SetPrototypeMethod(ctor, "copyTo", CopyTo);
Nan::SetPrototypeMethod(ctor, "pyrDown", PyrDown);
Nan::SetPrototypeMethod(ctor, "pyrUp", PyrUp);
Nan::SetPrototypeMethod(ctor, "channels", Channels);
Nan::SetPrototypeMethod(ctor, "convertGrayscale", ConvertGrayscale);
Nan::SetPrototypeMethod(ctor, "convertHSVscale", ConvertHSVscale);
Nan::SetPrototypeMethod(ctor, "gaussianBlur", GaussianBlur);
Nan::SetPrototypeMethod(ctor, "medianBlur", MedianBlur);
Nan::SetPrototypeMethod(ctor, "bilateralFilter", BilateralFilter);
Nan::SetPrototypeMethod(ctor, "copy", Copy);
Nan::SetPrototypeMethod(ctor, "flip", Flip);
Nan::SetPrototypeMethod(ctor, "roi", ROI);
Nan::SetPrototypeMethod(ctor, "ptr", Ptr);
Nan::SetPrototypeMethod(ctor, "absDiff", AbsDiff);
Nan::SetPrototypeMethod(ctor, "addWeighted", AddWeighted);
Nan::SetPrototypeMethod(ctor, "bitwiseXor", BitwiseXor);
Nan::SetPrototypeMethod(ctor, "bitwiseNot", BitwiseNot);
Nan::SetPrototypeMethod(ctor, "bitwiseAnd", BitwiseAnd);
Nan::SetPrototypeMethod(ctor, "countNonZero", CountNonZero);
Nan::SetPrototypeMethod(ctor, "canny", Canny);
Nan::SetPrototypeMethod(ctor, "dilate", Dilate);
Nan::SetPrototypeMethod(ctor, "erode", Erode);
Nan::SetPrototypeMethod(ctor, "findContours", FindContours);
Nan::SetPrototypeMethod(ctor, "drawContour", DrawContour);
Nan::SetPrototypeMethod(ctor, "drawAllContours", DrawAllContours);
Nan::SetPrototypeMethod(ctor, "goodFeaturesToTrack", GoodFeaturesToTrack);
Nan::SetPrototypeMethod(ctor, "houghLinesP", HoughLinesP);
Nan::SetPrototypeMethod(ctor, "crop", Crop);
Nan::SetPrototypeMethod(ctor, "houghCircles", HoughCircles);
Nan::SetPrototypeMethod(ctor, "inRange", inRange);
Nan::SetPrototypeMethod(ctor, "adjustROI", AdjustROI);
Nan::SetPrototypeMethod(ctor, "locateROI", LocateROI);
Nan::SetPrototypeMethod(ctor, "threshold", Threshold);
Nan::SetPrototypeMethod(ctor, "adaptiveThreshold", AdaptiveThreshold);
Nan::SetPrototypeMethod(ctor, "meanStdDev", MeanStdDev);
Nan::SetPrototypeMethod(ctor, "cvtColor", CvtColor);
Nan::SetPrototypeMethod(ctor, "split", Split);
Nan::SetPrototypeMethod(ctor, "merge", Merge);
Nan::SetPrototypeMethod(ctor, "equalizeHist", EqualizeHist);
Nan::SetPrototypeMethod(ctor, "floodFill", FloodFill);
Nan::SetPrototypeMethod(ctor, "matchTemplate", MatchTemplate);
Nan::SetPrototypeMethod(ctor, "templateMatches", TemplateMatches);
Nan::SetPrototypeMethod(ctor, "minMaxLoc", MinMaxLoc);
Nan::SetPrototypeMethod(ctor, "pushBack", PushBack);
Nan::SetPrototypeMethod(ctor, "putText", PutText);
Nan::SetPrototypeMethod(ctor, "getPerspectiveTransform", GetPerspectiveTransform);
Nan::SetPrototypeMethod(ctor, "warpPerspective", WarpPerspective);
Nan::SetMethod(ctor, "Zeros", Zeros);
Nan::SetMethod(ctor, "Ones", Ones);
Nan::SetMethod(ctor, "Eye", Eye);
Nan::SetPrototypeMethod(ctor, "copyWithMask", CopyWithMask);
Nan::SetPrototypeMethod(ctor, "setWithMask", SetWithMask);
Nan::SetPrototypeMethod(ctor, "meanWithMask", MeanWithMask);
Nan::SetPrototypeMethod(ctor, "shift", Shift);
Nan::SetPrototypeMethod(ctor, "release", Release);
- target->Set(NanNew("Matrix"), ctor->GetFunction());
+ target->Set(Nan::New("Matrix").ToLocalChecked(), ctor->GetFunction());
- NanScope();
if (args.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new");
+ Nan::HandleScope scope;
if (info.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new");
- if (args.Length() == 0) {
+ if (info.Length() == 0) {
- } else if (args.Length() == 2 && args[0]->IsInt32() && args[1]->IsInt32()) {
mat = new Matrix(args[0]->IntegerValue(), args[1]->IntegerValue());
} else if (args.Length() == 3 && args[0]->IsInt32() && args[1]->IsInt32()
&& args[2]->IsInt32()) {
mat = new Matrix(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue());
} else if (args.Length() == 4 && args[0]->IsInt32() && args[1]->IsInt32() &&
args[2]->IsInt32() && args[3]->IsArray()) {
} else { // if (args.Length() == 5) {
Matrix *other = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
int x = args[1]->IntegerValue();
int y = args[2]->IntegerValue();
int w = args[3]->IntegerValue();
int h = args[4]->IntegerValue();
+ } else if (info.Length() == 2 && info[0]->IsInt32() && info[1]->IsInt32()) {
mat = new Matrix(info[0]->IntegerValue(), info[1]->IntegerValue());
} else if (info.Length() == 3 && info[0]->IsInt32() && info[1]->IsInt32()
&& info[2]->IsInt32()) {
mat = new Matrix(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue());
} else if (info.Length() == 4 && info[0]->IsInt32() && info[1]->IsInt32() &&
info[2]->IsInt32() && info[3]->IsArray()) {
} else { // if (info.Length() == 5) {
Matrix *other = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
int x = info[1]->IntegerValue();
int y = info[2]->IntegerValue();
int w = info[3]->IntegerValue();
int h = info[4]->IntegerValue();
- mat->Wrap(args.Holder());
NanReturnValue(args.Holder());
+ mat->Wrap(info.Holder());
info.GetReturnValue().Set(info.Holder());
- ObjectWrap() {
+ Nan::ObjectWrap() {
- ObjectWrap() {
+ Nan::ObjectWrap() {
- ObjectWrap() {
+ Nan::ObjectWrap() {
- ObjectWrap() {
+ Nan::ObjectWrap() {
- NanThrowError("Only 1-3 channels are supported");
+ Nan::ThrowError("Only 1-3 channels are supported");
- NanReturnValue(NanNew<Boolean>(self->mat.empty()));
+ info.GetReturnValue().Set(Nan::New<Boolean>(self->mat.empty()));
- int y = args[0]->IntegerValue();
int x = args[1]->IntegerValue();
+ int y = info[0]->IntegerValue();
int x = info[1]->IntegerValue();
- if (args.Length() == 3) {
Local < Object > objColor = args[2]->ToObject();
+ if (info.Length() == 3) {
Local < Object > objColor = info[2]->ToObject();
- NanReturnValue(args[2]->ToObject());
+ info.GetReturnValue().Set(info[2]->ToObject());
- v8::Local < v8::Array > arr = NanNew<v8::Array>(3);
arr->Set(0, NanNew<Number>(intensity[0]));
arr->Set(1, NanNew<Number>(intensity[1]));
arr->Set(2, NanNew<Number>(intensity[2]));
NanReturnValue(arr);
+ v8::Local < v8::Array > arr = Nan::New<v8::Array>(3);
arr->Set(0, Nan::New<Number>(intensity[0]));
arr->Set(1, Nan::New<Number>(intensity[1]));
arr->Set(2, Nan::New<Number>(intensity[2]));
info.GetReturnValue().Set(arr);
- NanReturnValue(NanNew<Number>(intensity));
+ info.GetReturnValue().Set(Nan::New<Number>(intensity));
- NanReturnUndefined();
+ return;
- // NanReturnValue(NanNew<Number>(val));
+ // info.GetReturnValue().Set(Nan::New<Number>(val));
- int i = args[0]->IntegerValue();
int j = args[1]->IntegerValue();
+ int i = info[0]->IntegerValue();
int j = info[1]->IntegerValue();
- NanReturnValue(NanNew<Number>(val));
+ info.GetReturnValue().Set(Nan::New<Number>(val));
- int i = args[0]->IntegerValue();
int j = args[1]->IntegerValue();
double val = args[2]->NumberValue();
+ int i = info[0]->IntegerValue();
int j = info[1]->IntegerValue();
double val = info[2]->NumberValue();
- if (args.Length() == 4) {
self->mat.at<cv::Vec3b>(i, j)[args[3]->NumberValue()] = val;
} else if (args.Length() == 3) {
+ if (info.Length() == 4) {
self->mat.at<cv::Vec3b>(i, j)[info[3]->NumberValue()] = val;
} else if (info.Length() == 3) {
- NanThrowTypeError("Invalid number of arguments");
+ Nan::ThrowTypeError("Invalid number of arguments");
- NanReturnUndefined();
+ return;
- if (!Buffer::HasInstance(args[0])) {
NanThrowTypeError("Not a buffer");
+ if (!Buffer::HasInstance(info[0])) {
Nan::ThrowTypeError("Not a buffer");
- const char* buffer_data = Buffer::Data(args[0]);
size_t buffer_length = Buffer::Length(args[0]);
+ const char* buffer_data = Buffer::Data(info[0]);
size_t buffer_length = Buffer::Length(info[0]);
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- Local<Object> buf = NanNewBufferHandle(size);
+ Local<Object> buf = Nan::NewBuffer(size).ToLocalChecked();
- v8::Local<v8::Object> globalObj = NanGetCurrentContext()->Global();
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(NanNew<String>("Buffer")));
v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>((unsigned) size), NanNew<v8::Integer>(0)};
+ v8::Local<v8::Object> globalObj = Nan::GetCurrentContext()->Global();
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
v8::Handle<v8::Value> constructorArgs[3] = {buf, Nan::New<v8::Integer>((unsigned) size), Nan::New<v8::Integer>(0)};
- NanReturnValue(actualBuffer);
+ info.GetReturnValue().Set(actualBuffer);
- NanScope();
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Nan::HandleScope scope;
Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if (args.Length() == 2) {
+ if (info.Length() == 2) {
- NanThrowError("those channels are not supported");
+ Nan::ThrowError("those channels are not supported");
- double alpha = args[0]->NumberValue();
int beta = args[1]->IntegerValue();
+ double alpha = info[0]->NumberValue();
int beta = info[1]->IntegerValue();
- if (args.Length() == 1) {
int diff = args[0]->IntegerValue();
+ if (info.Length() == 1) {
int diff = info[0]->IntegerValue();
- NanReturnValue(NanNew("Insufficient or wrong arguments"));
+ info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- if (!args[0]->IsNumber()) {
NanThrowTypeError("min is required (argument 1)");
+ if (!info[0]->IsNumber()) {
Nan::ThrowTypeError("min is required (argument 1)");
- if (!args[1]->IsNumber()) {
NanThrowTypeError("max is required (argument 2)");
+ if (!info[1]->IsNumber()) {
Nan::ThrowTypeError("max is required (argument 2)");
- if (args[2]->IsNumber()) {
type = args[2]->Uint32Value();
+ if (info[2]->IsNumber()) {
type = info[2]->Uint32Value();
- NanThrowTypeError("type value must be NORM_INF=1, NORM_L1=2, NORM_L2=4,"
+ Nan::ThrowTypeError("type value must be NORM_INF=1, NORM_L1=2, NORM_L2=4,"
- if (args[3]->IsNumber()) {
dtype = args[3]->IntegerValue();
+ if (info[3]->IsNumber()) {
dtype = info[3]->IntegerValue();
- double min = args[0]->NumberValue();
double max = args[1]->NumberValue();
+ double min = info[0]->NumberValue();
double max = info[1]->NumberValue();
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if (args[4]->IsObject()) {
Matrix *mmask = ObjectWrap::Unwrap<Matrix>(args[4]->ToObject());
+ if (info[4]->IsObject()) {
Matrix *mmask = Nan::ObjectWrap::Unwrap<Matrix>(info[4]->ToObject());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- v8::Local < v8::Array > arr = NanNew<Array>(2);
arr->Set(0, NanNew<Number>(self->mat.size().height));
arr->Set(1, NanNew<Number>(self->mat.size().width));
+ v8::Local < v8::Array > arr = Nan::New<Array>(2);
arr->Set(0, Nan::New<Number>(self->mat.size().height));
arr->Set(1, Nan::New<Number>(self->mat.size().width));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
- Matrix *m = ObjectWrap::Unwrap<Matrix>(im_h);
+ Matrix *m = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
- NanReturnValue(im_h);
+ info.GetReturnValue().Set(im_h);
- if ((args.Length() == 4) && (args[0]->IsNumber()) && (args[1]->IsNumber())
&& (args[2]->IsNumber()) && (args[3]->IsNumber())) {
+ if ((info.Length() == 4) && (info[0]->IsNumber()) && (info[1]->IsNumber())
&& (info[2]->IsNumber()) && (info[3]->IsNumber())) {
- int x = args[0]->IntegerValue();
int y = args[1]->IntegerValue();
int width = args[2]->IntegerValue();
int height = args[3]->IntegerValue();
+ int x = info[0]->IntegerValue();
int y = info[1]->IntegerValue();
int width = info[2]->IntegerValue();
int height = info[3]->IntegerValue();
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m = ObjectWrap::Unwrap<Matrix>(im_h);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
- NanReturnValue(im_h);
+ info.GetReturnValue().Set(im_h);
- NanReturnValue(NanNew("Insufficient or wrong arguments"));
+ info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked());
- int y = args[0]->IntegerValue();
v8::Local < v8::Array > arr = NanNew<Array>(width);
+ int y = info[0]->IntegerValue();
v8::Local < v8::Array > arr = Nan::New<Array>(width);
- arr->Set(x, NanNew<Number>(v));
+ arr->Set(x, Nan::New<Number>(v));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- int y = args[0]->IntegerValue();
v8::Local < v8::Array > arr = NanNew<Array>(width * 3);
+ int y = info[0]->IntegerValue();
v8::Local < v8::Array > arr = Nan::New<Array>(width * 3);
- arr->Set(offset, NanNew<Number>((double) pixel.val[0]));
arr->Set(offset + 1, NanNew<Number>((double) pixel.val[1]));
arr->Set(offset + 2, NanNew<Number>((double) pixel.val[2]));
+ arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- int x = args[0]->IntegerValue();
v8::Local < v8::Array > arr = NanNew<Array>(height);
+ int x = info[0]->IntegerValue();
v8::Local < v8::Array > arr = Nan::New<Array>(height);
- arr->Set(y, NanNew<Number>(v));
+ arr->Set(y, Nan::New<Number>(v));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- int x = args[0]->IntegerValue();
v8::Local < v8::Array > arr = NanNew<Array>(height * 3);
+ int x = info[0]->IntegerValue();
v8::Local < v8::Array > arr = Nan::New<Array>(height * 3);
- arr->Set(offset, NanNew<Number>((double) pixel.val[0]));
arr->Set(offset + 1, NanNew<Number>((double) pixel.val[1]));
arr->Set(offset + 2, NanNew<Number>((double) pixel.val[2]));
+ arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- NanReturnValue(NanNew<Number>(self->mat.size().width));
+ info.GetReturnValue().Set(Nan::New<Number>(self->mat.size().width));
- NanReturnValue(NanNew<Number>(self->mat.size().height));
+ info.GetReturnValue().Set(Nan::New<Number>(self->mat.size().height));
- NanReturnValue(NanNew<Number>(self->mat.channels()));
+ info.GetReturnValue().Set(Nan::New<Number>(self->mat.channels()));
- if ((args.Length() > 0) && (args[0]->IsFunction())) {
return Matrix::ToBufferAsync(args);
+ if ((info.Length() > 0) && (info[0]->IsFunction())) {
return Matrix::ToBufferAsync(info);
- if ((args.Length() > 0) && (args[0]->IsObject())) {
+ if ((info.Length() > 0) && (info[0]->IsObject())) {
- v8::Handle < v8::Object > options = v8::Handle<v8::Object>::Cast(args[0]);
+ v8::Handle < v8::Object > options = v8::Handle<v8::Object>::Cast(info[0]);
- if (options->Has(NanNew<String>("ext"))) {
+ if (options->Has(Nan::New<String>("ext").ToLocalChecked())) {
- options->Get(NanNew<String>("ext"))->ToString());
+ options->Get(Nan::New<String>("ext").ToLocalChecked())->ToString());
- if (options->Has(NanNew<String>("jpegQuality"))) {
+ if (options->Has(Nan::New<String>("jpegQuality").ToLocalChecked())) {
- options->Get(NanNew<String>("jpegQuality"))->IntegerValue();
+ options->Get(Nan::New<String>("jpegQuality").ToLocalChecked())->IntegerValue();
- if (options->Has(NanNew<String>("pngCompression"))) {
+ if (options->Has(Nan::New<String>("pngCompression").ToLocalChecked())) {
- options->Get(NanNew<String>("pngCompression"))->IntegerValue();
+ options->Get(Nan::New<String>("pngCompression").ToLocalChecked())->IntegerValue();
- Local < Object > buf = NanNewBufferHandle(vec.size());
+ Local < Object > buf = Nan::NewBuffer(vec.size()).ToLocalChecked();
- v8::Local < v8::Object > globalObj = NanGetCurrentContext()->Global();
+ v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global();
- > ::Cast(globalObj->Get(NanNew<String>("Buffer")));
+ > ::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
- {buf, NanNew<v8::Integer>((unsigned)vec.size()), NanNew<v8::Integer>(0)};
+ {buf, Nan::New<v8::Integer>((unsigned)vec.size()), Nan::New<v8::Integer>(0)};
- NanReturnValue(actualBuffer);
+ info.GetReturnValue().Set(actualBuffer);
- class AsyncToBufferWorker: public NanAsyncWorker {
+ class AsyncToBufferWorker: public Nan::AsyncWorker {
- AsyncToBufferWorker(NanCallback *callback, Matrix* matrix, string ext,
+ AsyncToBufferWorker(Nan::Callback *callback, Matrix* matrix, string ext,
- NanAsyncWorker(callback),
+ Nan::AsyncWorker(callback),
- NanScope();
+ Nan::HandleScope scope;
- Local<Object> buf = NanNewBufferHandle(res.size());
+ Local<Object> buf = Nan::NewBuffer(res.size()).ToLocalChecked();
- v8::Local<v8::Object> globalObj = NanGetCurrentContext()->Global();
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(NanNew<String>("Buffer")));
v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>((unsigned)res.size()), NanNew<v8::Integer>(0)};
+ v8::Local<v8::Object> globalObj = Nan::GetCurrentContext()->Global();
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
v8::Handle<v8::Value> constructorArgs[3] = {buf, Nan::New<v8::Integer>((unsigned)res.size()), Nan::New<v8::Integer>(0)};
- NanNull(),
+ Nan::Null(),
- if ((args.Length() > 1) && (args[1]->IsObject())) {
+ if ((info.Length() > 1) && (info[1]->IsObject())) {
- v8::Handle < v8::Object > options = v8::Handle<v8::Object>::Cast(args[1]);
+ v8::Handle < v8::Object > options = v8::Handle<v8::Object>::Cast(info[1]);
- if (options->Has(NanNew<String>("ext"))) {
+ if (options->Has(Nan::New<String>("ext").ToLocalChecked())) {
- options->Get(NanNew<String>("ext"))->ToString());
+ options->Get(Nan::New<String>("ext").ToLocalChecked())->ToString());
- if (options->Has(NanNew<String>("jpegQuality"))) {
+ if (options->Has(Nan::New<String>("jpegQuality").ToLocalChecked())) {
- options->Get(NanNew<String>("jpegQuality"))->IntegerValue();
+ options->Get(Nan::New<String>("jpegQuality").ToLocalChecked())->IntegerValue();
- if (options->Has(NanNew<String>("pngCompression"))) {
+ if (options->Has(Nan::New<String>("pngCompression").ToLocalChecked())) {
- options->Get(NanNew<String>("pngCompression"))->IntegerValue();
+ options->Get(Nan::New<String>("pngCompression").ToLocalChecked())->IntegerValue();
- NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params));
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params));
- NanReturnUndefined();
+ return;
- if (args[0]->IsObject()) {
v8::Handle < v8::Object > options = v8::Handle<v8::Object>::Cast(args[0]);
if (options->Has(NanNew<String>("center"))) {
+ if (info[0]->IsObject()) {
v8::Handle < v8::Object > options = v8::Handle<v8::Object>::Cast(info[0]);
if (options->Has(Nan::New<String>("center").ToLocalChecked())) {
- options->Get(NanNew<String>("center"))->ToObject();
x = center->Get(NanNew<String>("x"))->Uint32Value();
y = center->Get(NanNew<String>("y"))->Uint32Value();
+ options->Get(Nan::New<String>("center").ToLocalChecked())->ToObject();
x = center->Get(Nan::New<String>("x").ToLocalChecked())->Uint32Value();
y = center->Get(Nan::New<String>("y").ToLocalChecked())->Uint32Value();
- if (options->Has(NanNew<String>("axes"))) {
Local < Object > axes = options->Get(NanNew<String>("axes"))->ToObject();
width = axes->Get(NanNew<String>("width"))->Uint32Value();
height = axes->Get(NanNew<String>("height"))->Uint32Value();
+ if (options->Has(Nan::New<String>("axes").ToLocalChecked())) {
Local < Object > axes = options->Get(Nan::New<String>("axes").ToLocalChecked())->ToObject();
width = axes->Get(Nan::New<String>("width").ToLocalChecked())->Uint32Value();
height = axes->Get(Nan::New<String>("height").ToLocalChecked())->Uint32Value();
- if (options->Has(NanNew<String>("thickness"))) {
thickness = options->Get(NanNew<String>("thickness"))->Uint32Value();
+ if (options->Has(Nan::New<String>("thickness").ToLocalChecked())) {
thickness = options->Get(Nan::New<String>("thickness").ToLocalChecked())->Uint32Value();
- if (options->Has(NanNew<String>("angle"))) {
angle = options->Get(NanNew<String>("angle"))->NumberValue();
+ if (options->Has(Nan::New<String>("angle").ToLocalChecked())) {
angle = options->Get(Nan::New<String>("angle").ToLocalChecked())->NumberValue();
- if (options->Has(NanNew<String>("startAngle"))) {
startAngle = options->Get(NanNew<String>("startAngle"))->NumberValue();
+ if (options->Has(Nan::New<String>("startAngle").ToLocalChecked())) {
startAngle = options->Get(Nan::New<String>("startAngle").ToLocalChecked())->NumberValue();
- if (options->Has(NanNew<String>("endAngle"))) {
endAngle = options->Get(NanNew<String>("endAngle"))->NumberValue();
+ if (options->Has(Nan::New<String>("endAngle").ToLocalChecked())) {
endAngle = options->Get(Nan::New<String>("endAngle").ToLocalChecked())->NumberValue();
- if (options->Has(NanNew<String>("lineType"))) {
lineType = options->Get(NanNew<String>("lineType"))->Uint32Value();
+ if (options->Has(Nan::New<String>("lineType").ToLocalChecked())) {
lineType = options->Get(Nan::New<String>("lineType").ToLocalChecked())->Uint32Value();
- if (options->Has(NanNew<String>("shift"))) {
shift = options->Get(NanNew<String>("shift"))->Uint32Value();
+ if (options->Has(Nan::New<String>("shift").ToLocalChecked())) {
shift = options->Get(Nan::New<String>("shift").ToLocalChecked())->Uint32Value();
- if (options->Has(NanNew<String>("color"))) {
+ if (options->Has(Nan::New<String>("color").ToLocalChecked())) {
- options->Get(NanNew<String>("color"))->ToObject();
+ options->Get(Nan::New<String>("color").ToLocalChecked())->ToObject();
- x = args[0]->Uint32Value();
y = args[1]->Uint32Value();
width = args[2]->Uint32Value();
height = args[3]->Uint32Value();
+ x = info[0]->Uint32Value();
y = info[1]->Uint32Value();
width = info[2]->Uint32Value();
height = info[3]->Uint32Value();
- if (args[4]->IsArray()) {
Local < Object > objColor = args[4]->ToObject();
+ if (info[4]->IsArray()) {
Local < Object > objColor = info[4]->ToObject();
- if (args[5]->IntegerValue())
thickness = args[5]->IntegerValue();
+ if (info[5]->IntegerValue())
thickness = info[5]->IntegerValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- if (args[0]->IsArray() && args[1]->IsArray()) {
Local < Object > xy = args[0]->ToObject();
Local < Object > width_height = args[1]->ToObject();
+ if (info[0]->IsArray() && info[1]->IsArray()) {
Local < Object > xy = info[0]->ToObject();
Local < Object > width_height = info[1]->ToObject();
- if (args[2]->IsArray()) {
Local < Object > objColor = args[2]->ToObject();
+ if (info[2]->IsArray()) {
Local < Object > objColor = info[2]->ToObject();
- if (args[3]->IntegerValue())
thickness = args[3]->IntegerValue();
+ if (info[3]->IntegerValue())
thickness = info[3]->IntegerValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- if (args[0]->IsArray() && args[1]->IsArray()) {
Local < Object > xy1 = args[0]->ToObject();
Local < Object > xy2 = args[1]->ToObject();
+ if (info[0]->IsArray() && info[1]->IsArray()) {
Local < Object > xy1 = info[0]->ToObject();
Local < Object > xy2 = info[1]->ToObject();
- if (args[2]->IsArray()) {
Local < Object > objColor = args[2]->ToObject();
+ if (info[2]->IsArray()) {
Local < Object > objColor = info[2]->ToObject();
- if (args[3]->IntegerValue())
thickness = args[3]->IntegerValue();
+ if (info[3]->IntegerValue())
thickness = info[3]->IntegerValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- if (args[0]->IsArray()) {
Local < Array > polyArray = Local < Array > ::Cast(args[0]->ToObject());
+ if (info[0]->IsArray()) {
Local < Array > polyArray = Local < Array > ::Cast(info[0]->ToObject());
- if (args[1]->IsArray()) {
Local<Object> objColor = args[1]->ToObject();
+ if (info[1]->IsArray()) {
Local<Object> objColor = info[1]->ToObject();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- if (args.Length() > 1) {
return SaveAsync(args);
+ if (info.Length() > 1) {
return SaveAsync(info);
- if (!args[0]->IsString()) {
NanThrowTypeError("filename required");
+ if (!info[0]->IsString()) {
Nan::ThrowTypeError("filename required");
- NanAsciiString filename(args[0]);
+ Nan::Utf8String filename(info[0]);
- NanReturnValue(NanNew<Number>(res));
+ info.GetReturnValue().Set(Nan::New<Number>(res));
- class AsyncSaveWorker: public NanAsyncWorker {
+ class AsyncSaveWorker: public Nan::AsyncWorker {
- AsyncSaveWorker(NanCallback *callback, Matrix* matrix, char* filename) :
NanAsyncWorker(callback),
+ AsyncSaveWorker(Nan::Callback *callback, Matrix* matrix, char* filename) :
Nan::AsyncWorker(callback),
- NanScope();
+ Nan::HandleScope scope;
- NanNull(),
NanNew<Number>(res)
+ Nan::Null(),
Nan::New<Number>(res)
- if (!args[0]->IsString()) {
NanThrowTypeError("filename required");
+ if (!info[0]->IsString()) {
Nan::ThrowTypeError("filename required");
- NanAsciiString filename(args[0]);
+ Nan::Utf8String filename(info[0]);
- NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename));
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename));
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- int w = args[0]->Uint32Value();
int h = args[1]->Uint32Value();
int type = (args.Length() > 2) ? args[2]->IntegerValue() : CV_64FC1;
+ int w = info[0]->Uint32Value();
int h = info[1]->Uint32Value();
int type = (info.Length() > 2) ? info[2]->IntegerValue() : CV_64FC1;
- Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h);
+ Local<Object> im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
- NanReturnValue(im_h);
+ info.GetReturnValue().Set(im_h);
- NanScope();
+ Nan::HandleScope scope;
- int w = args[0]->Uint32Value();
int h = args[1]->Uint32Value();
int type = (args.Length() > 2) ? args[2]->IntegerValue() : CV_64FC1;
+ int w = info[0]->Uint32Value();
int h = info[1]->Uint32Value();
int type = (info.Length() > 2) ? info[2]->IntegerValue() : CV_64FC1;
- Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h);
+ Local<Object> im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
- NanReturnValue(im_h);
+ info.GetReturnValue().Set(im_h);
- NanScope();
+ Nan::HandleScope scope;
- int w = args[0]->Uint32Value();
int h = args[1]->Uint32Value();
int type = (args.Length() > 2) ? args[2]->IntegerValue() : CV_64FC1;
+ int w = info[0]->Uint32Value();
int h = info[1]->Uint32Value();
int type = (info.Length() > 2) ? info[2]->IntegerValue() : CV_64FC1;
- Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h);
+ Local<Object> im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
- NanReturnValue(im_h);
+ info.GetReturnValue().Set(im_h);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanThrowError("Image is no 3-channel");
+ Nan::ThrowError("Image is no 3-channel");
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanThrowError("Image is no 3-channel");
+ Nan::ThrowError("Image is no 3-channel");
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if (args.Length() < 1) {
+ if (info.Length() < 1) {
- if (!args[0]->IsArray()) {
NanThrowTypeError("'ksize' argument must be a 2 double array");
+ if (!info[0]->IsArray()) {
Nan::ThrowTypeError("'ksize' argument must be a 2 double array");
- Local<Object> array = args[0]->ToObject();
+ Local<Object> array = info[0]->ToObject();
- NanThrowTypeError("'ksize' argument must be a 2 double array");
+ Nan::ThrowTypeError("'ksize' argument must be a 2 double array");
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if (args[0]->IsNumber()) {
ksize = args[0]->IntegerValue();
+ if (info[0]->IsNumber()) {
ksize = info[0]->IntegerValue();
- NanThrowTypeError("'ksize' argument must be a positive odd integer");
+ Nan::ThrowTypeError("'ksize' argument must be a positive odd integer");
- NanThrowTypeError("'ksize' argument must be a positive odd integer");
+ Nan::ThrowTypeError("'ksize' argument must be a positive odd integer");
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if (args.Length() != 0) {
if (args.Length() < 3 || args.Length() > 4) {
NanThrowTypeError("BilateralFilter takes 0, 3, or 4 arguments");
+ if (info.Length() != 0) {
if (info.Length() < 3 || info.Length() > 4) {
Nan::ThrowTypeError("BilateralFilter takes 0, 3, or 4 arguments");
- d = args[0]->IntegerValue();
sigmaColor = args[1]->NumberValue();
sigmaSpace = args[2]->NumberValue();
if (args.Length() == 4) {
borderType = args[3]->IntegerValue();
+ d = info[0]->IntegerValue();
sigmaColor = info[1]->NumberValue();
sigmaSpace = info[2]->NumberValue();
if (info.Length() == 4) {
borderType = info[3]->IntegerValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(img_to_return);
- NanReturnValue(img_to_return);
+ info.GetReturnValue().Set(img_to_return);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if ( args.Length() < 1 || !args[0]->IsInt32() ) {
NanThrowTypeError("Flip requires an integer flipCode argument "
+ if ( info.Length() < 1 || !info[0]->IsInt32() ) {
Nan::ThrowTypeError("Flip requires an integer flipCode argument "
- int flipCode = args[0]->ToInt32()->Value();
+ int flipCode = info[0]->ToInt32()->Value();
- Local<Object> img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+ Local<Object> img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(img_to_return);
- NanReturnValue(img_to_return);
+ info.GetReturnValue().Set(img_to_return);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- if ( args.Length() != 4 ) {
NanThrowTypeError("ROI requires x,y,w,h arguments");
+ if ( info.Length() != 4 ) {
Nan::ThrowTypeError("ROI requires x,y,w,h arguments");
- Local<Object> img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+ Local<Object> img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(img_to_return);
- int x = args[0]->IntegerValue();
int y = args[1]->IntegerValue();
int w = args[2]->IntegerValue();
int h = args[3]->IntegerValue();
+ int x = info[0]->IntegerValue();
int y = info[1]->IntegerValue();
int w = info[2]->IntegerValue();
int h = info[3]->IntegerValue();
- NanReturnValue(img_to_return);
+ info.GetReturnValue().Set(img_to_return);
- NanScope();
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
int line = args[0]->Uint32Value();
+ Nan::HandleScope scope;
Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
int line = info[0]->Uint32Value();
- Local<Object> return_buffer = NanNewBufferHandle((char*)data, self->mat.step);
NanReturnValue( return_buffer );
// NanReturnUndefined();
+ Local<Object> return_buffer = Nan::NewBuffer((char*)data, self->mat.step).ToLocalChecked();
info.GetReturnValue().Set( return_buffer );
// return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Matrix *src1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
Matrix *src2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Matrix *src1 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
Matrix *src2 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Matrix *src1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
Matrix *src2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Matrix *src1 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
Matrix *src2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
- float alpha = args[1]->NumberValue();
float beta = args[3]->NumberValue();
+ float alpha = info[1]->NumberValue();
float beta = info[3]->NumberValue();
- NanThrowError(err_msg);
+ Nan::ThrowError(err_msg);
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Matrix *src1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
Matrix *src2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Matrix *src1 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
Matrix *src2 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- if (args.Length() == 3) {
Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+ if (info.Length() == 3) {
Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Matrix *dst = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
if (args.Length() == 2) {
Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Matrix *dst = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
if (info.Length() == 2) {
Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Matrix *src1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
Matrix *src2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
if (args.Length() == 3) {
Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Matrix *src1 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
Matrix *src2 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
if (info.Length() == 3) {
Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanReturnValue(NanNew<Number>(count));
+ info.GetReturnValue().Set(Nan::New<Number>(count));
- NanScope();
+ Nan::HandleScope scope;
- //Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ //Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
int lowThresh = args[0]->NumberValue();
int highThresh = args[1]->NumberValue();
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
int lowThresh = info[0]->NumberValue();
int highThresh = info[1]->NumberValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
int niters = args[0]->NumberValue();
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
int niters = info[0]->NumberValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
int niters = args[0]->NumberValue();
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
int niters = info[0]->NumberValue();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- NanScope();
+ Nan::HandleScope scope;
- if (args.Length() > 0) {
if (args[0]->IsNumber()) mode = args[0]->IntegerValue();
+ if (info.Length() > 0) {
if (info[0]->IsNumber()) mode = info[0]->IntegerValue();
- if (args.Length() > 1) {
if (args[1]->IsNumber()) chain = args[1]->IntegerValue();
+ if (info.Length() > 1) {
if (info[1]->IsNumber()) chain = info[1]->IntegerValue();
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Local<Object> conts_to_return= NanNew(Contour::constructor)->GetFunction()->NewInstance();
Contour *contours = ObjectWrap::Unwrap<Contour>(conts_to_return);
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Local<Object> conts_to_return= Nan::New(Contour::constructor)->GetFunction()->NewInstance();
Contour *contours = Nan::ObjectWrap::Unwrap<Contour>(conts_to_return);
- NanReturnValue(conts_to_return);
+ info.GetReturnValue().Set(conts_to_return);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Contour *cont = ObjectWrap::Unwrap<Contour>(args[0]->ToObject());
int pos = args[1]->NumberValue();
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Contour *cont = Nan::ObjectWrap::Unwrap<Contour>(info[0]->ToObject());
int pos = info[1]->NumberValue();
- if (args[2]->IsArray()) {
Local<Object> objColor = args[2]->ToObject();
+ if (info[2]->IsArray()) {
Local<Object> objColor = info[2]->ToObject();
- int thickness = args.Length() < 4 ? 1 : args[3]->NumberValue();
+ int thickness = info.Length() < 4 ? 1 : info[3]->NumberValue();
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Contour *cont = ObjectWrap::Unwrap<Contour>(args[0]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Contour *cont = Nan::ObjectWrap::Unwrap<Contour>(info[0]->ToObject());
- if (args[1]->IsArray()) {
Local<Object> objColor = args[1]->ToObject();
+ if (info[1]->IsArray()) {
Local<Object> objColor = info[1]->ToObject();
- int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue();
+ int thickness = info.Length() < 3 ? 1 : info[2]->NumberValue();
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- v8::Local<v8::Array> arr = NanNew<Array>(corners.size());
+ v8::Local<v8::Array> arr = Nan::New<Array>(corners.size());
- v8::Local<v8::Array> pt = NanNew<Array>(2);
pt->Set(0, NanNew<Number>((double) corners[i].x));
pt->Set(1, NanNew<Number>((double) corners[i].y));
+ v8::Local<v8::Array> pt = Nan::New<Array>(2);
pt->Set(0, Nan::New<Number>((double) corners[i].x));
pt->Set(1, Nan::New<Number>((double) corners[i].y));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
double rho = args.Length() < 1 ? 1 : args[0]->NumberValue();
double theta = args.Length() < 2 ? CV_PI/180 : args[1]->NumberValue();
int threshold = args.Length() < 3 ? 80 : args[2]->Uint32Value();
double minLineLength = args.Length() < 4 ? 30 : args[3]->NumberValue();
double maxLineGap = args.Length() < 5 ? 10 : args[4]->NumberValue();
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
double rho = info.Length() < 1 ? 1 : info[0]->NumberValue();
double theta = info.Length() < 2 ? CV_PI/180 : info[1]->NumberValue();
int threshold = info.Length() < 3 ? 80 : info[2]->Uint32Value();
double minLineLength = info.Length() < 4 ? 30 : info[3]->NumberValue();
double maxLineGap = info.Length() < 5 ? 10 : info[4]->NumberValue();
- v8::Local<v8::Array> arr = NanNew<Array>(lines.size());
+ v8::Local<v8::Array> arr = Nan::New<Array>(lines.size());
- v8::Local<v8::Array> pt = NanNew<Array>(4);
pt->Set(0, NanNew<Number>((double) lines[i][0]));
pt->Set(1, NanNew<Number>((double) lines[i][1]));
pt->Set(2, NanNew<Number>((double) lines[i][2]));
pt->Set(3, NanNew<Number>((double) lines[i][3]));
+ v8::Local<v8::Array> pt = Nan::New<Array>(4);
pt->Set(0, Nan::New<Number>((double) lines[i][0]));
pt->Set(1, Nan::New<Number>((double) lines[i][1]));
pt->Set(2, Nan::New<Number>((double) lines[i][2]));
pt->Set(3, Nan::New<Number>((double) lines[i][3]));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- double dp = args.Length() < 1 ? 1 : args[0]->NumberValue();
double minDist = args.Length() < 2 ? 1 : args[1]->NumberValue();
double higherThreshold = args.Length() < 3 ? 100 : args[2]->NumberValue();
double accumulatorThreshold = args.Length() < 4 ? 100 : args[3]->NumberValue();
int minRadius = args.Length() < 5 ? 0 : args[4]->Uint32Value();
int maxRadius = args.Length() < 6 ? 0 : args[5]->Uint32Value();
+ double dp = info.Length() < 1 ? 1 : info[0]->NumberValue();
double minDist = info.Length() < 2 ? 1 : info[1]->NumberValue();
double higherThreshold = info.Length() < 3 ? 100 : info[2]->NumberValue();
double accumulatorThreshold = info.Length() < 4 ? 100 : info[3]->NumberValue();
int minRadius = info.Length() < 5 ? 0 : info[4]->Uint32Value();
int maxRadius = info.Length() < 6 ? 0 : info[5]->Uint32Value();
- v8::Local<v8::Array> arr = NanNew<Array>(circles.size());
+ v8::Local<v8::Array> arr = Nan::New<Array>(circles.size());
- v8::Local<v8::Array> pt = NanNew<Array>(3);
pt->Set(0, NanNew<Number>((double) circles[i][0])); // center x
pt->Set(1, NanNew<Number>((double) circles[i][1]));// center y
pt->Set(2, NanNew<Number>((double) circles[i][2]));// radius
+ v8::Local<v8::Array> pt = Nan::New<Array>(3);
pt->Set(0, Nan::New<Number>((double) circles[i][0])); // center x
pt->Set(1, Nan::New<Number>((double) circles[i][1]));// center y
pt->Set(2, Nan::New<Number>((double) circles[i][2]));// radius
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- NanScope();
+ Nan::HandleScope scope;
- int x = args[0]->Uint32Value();
int y = args[1]->Uint32Value();
+ int x = info[0]->Uint32Value();
int y = info[1]->Uint32Value();
- int interpolation = (args.Length() < 3) ? (int)cv::INTER_LINEAR : args[2]->Uint32Value();
+ int interpolation = (info.Length() < 3) ? (int)cv::INTER_LINEAR : info[2]->Uint32Value();
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- float angle = args[0]->ToNumber()->Value();
+ float angle = info[0]->ToNumber()->Value();
- && (args.Length() == 1);
+ && (info.Length() == 1);
- if (!angle2) {NanReturnUndefined();}
+ if (!angle2) {return;}
- NanReturnUndefined();
+ return;
- int x = args[1]->IsUndefined() ? round(self->mat.size().width / 2) :
args[1]->Uint32Value();
int y = args[1]->IsUndefined() ? round(self->mat.size().height / 2) :
args[2]->Uint32Value();
+ int x = info[1]->IsUndefined() ? round(self->mat.size().width / 2) :
info[1]->Uint32Value();
int y = info[1]->IsUndefined() ? round(self->mat.size().height / 2) :
info[2]->Uint32Value();
- NanReturnUndefined();
+ return;
- NanReturnUndefined();
+ return;
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanThrowError(String::New("Image is no 3-channel"));*/
+ Nan::ThrowError(String::New("Image is no 3-channel"));*/
- if (args[0]->IsArray() && args[1]->IsArray()) {
Local<Object> args_lowerb = args[0]->ToObject();
Local<Object> args_upperb = args[1]->ToObject();
+ if (info[0]->IsArray() && info[1]->IsArray()) {
Local<Object> args_lowerb = info[0]->ToObject();
Local<Object> args_upperb = info[1]->ToObject();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- int dtop = args[0]->Uint32Value();
int dbottom = args[1]->Uint32Value();
int dleft = args[2]->Uint32Value();
int dright = args[3]->Uint32Value();
+ int dtop = info[0]->Uint32Value();
int dbottom = info[1]->Uint32Value();
int dleft = info[2]->Uint32Value();
int dright = info[3]->Uint32Value();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- v8::Local < v8::Array > arr = NanNew<Array>(4);
arr->Set(0, NanNew<Number>(wholeSize.width));
arr->Set(1, NanNew<Number>(wholeSize.height));
arr->Set(2, NanNew<Number>(ofs.x));
arr->Set(3, NanNew<Number>(ofs.y));
+ v8::Local < v8::Array > arr = Nan::New<Array>(4);
arr->Set(0, Nan::New<Number>(wholeSize.width));
arr->Set(1, Nan::New<Number>(wholeSize.height));
arr->Set(2, Nan::New<Number>(ofs.x));
arr->Set(3, Nan::New<Number>(ofs.y));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- double threshold = args[0]->NumberValue();
double maxVal = args[1]->NumberValue();
+ double threshold = info[0]->NumberValue();
double maxVal = info[1]->NumberValue();
- if (args.Length() == 3) {
// typ = args[2]->IntegerValue();
NanAsciiString typstr(args[2]);
+ if (info.Length() == 3) {
// typ = info[2]->IntegerValue();
Nan::Utf8String typstr(info[2]);
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(img_to_return);
- NanReturnValue(img_to_return);
+ info.GetReturnValue().Set(img_to_return);
- double maxVal = args[0]->NumberValue();
double adaptiveMethod = args[1]->NumberValue();
double thresholdType = args[2]->NumberValue();
double blockSize = args[3]->NumberValue();
double C = args[4]->NumberValue();
+ double maxVal = info[0]->NumberValue();
double adaptiveMethod = info[1]->NumberValue();
double thresholdType = info[2]->NumberValue();
double blockSize = info[3]->NumberValue();
double C = info[4]->NumberValue();
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(img_to_return);
- NanReturnValue(img_to_return);
+ info.GetReturnValue().Set(img_to_return);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- Local<Object> mean = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m_mean = ObjectWrap::Unwrap<Matrix>(mean);
Local<Object> stddev = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m_stddev = ObjectWrap::Unwrap<Matrix>(stddev);
+ Local<Object> mean = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m_mean = Nan::ObjectWrap::Unwrap<Matrix>(mean);
Local<Object> stddev = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m_stddev = Nan::ObjectWrap::Unwrap<Matrix>(stddev);
- Local<Object> data = NanNew<Object>();
data->Set(NanNew<String>("mean"), mean);
data->Set(NanNew<String>("stddev"), stddev);
+ Local<Object> data = Nan::New<Object>();
data->Set(Nan::New<String>("mean").ToLocalChecked(), mean);
data->Set(Nan::New<String>("stddev").ToLocalChecked(), stddev);
- NanReturnValue(data);
+ info.GetReturnValue().Set(data);
- NanScope();
+ Nan::HandleScope scope;
- Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix * self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- Matrix *dest = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *dest = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- int x = args[1]->IntegerValue();
+ int x = info[1]->IntegerValue();
- int y = args[2]->IntegerValue();
+ int y = info[2]->IntegerValue();
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix * self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- v8::String::Utf8Value str (args[0]->ToString());
+ v8::String::Utf8Value str (info[0]->ToString());
- NanThrowTypeError("Conversion code is unsupported");
+ Nan::ThrowTypeError("Conversion code is unsupported");
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix * self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- v8::Local<v8::Array> arrChannels = NanNew<Array>(size);
+ v8::Local<v8::Array> arrChannels = Nan::New<Array>(size);
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix * m = ObjectWrap::Unwrap<Matrix>(matObject);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix * m = Nan::ObjectWrap::Unwrap<Matrix>(matObject);
- NanReturnValue(arrChannels);
+ info.GetReturnValue().Set(arrChannels);
- NanScope();
+ Nan::HandleScope scope;
- Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
if (!args[0]->IsArray()) {
NanThrowTypeError("The argument must be an array");
+ Matrix * self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
if (!info[0]->IsArray()) {
Nan::ThrowTypeError("The argument must be an array");
- v8::Handle<v8::Array> jsChannels = v8::Handle<v8::Array>::Cast(args[0]);
+ v8::Handle<v8::Array> jsChannels = v8::Handle<v8::Array>::Cast(info[0]);
- Matrix * matObject = ObjectWrap::Unwrap<Matrix>(jsChannels->Get(i)->ToObject());
+ Matrix * matObject = Nan::ObjectWrap::Unwrap<Matrix>(jsChannels->Get(i)->ToObject());
- NanReturnUndefined();
+ return;
- NanScope();
Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Nan::HandleScope scope;
Matrix * self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanReturnUndefined();
+ return;
- // obj->Get(NanNew<String>("x"))
+ // obj->Get(Nan::New<String>("x").ToLocalChecked())
- if (args.Length() < 1 || !args[0]->IsObject()) {
+ if (info.Length() < 1 || !info[0]->IsObject()) {
- Local < Object > obj = args[0]->ToObject();
+ Local < Object > obj = info[0]->ToObject();
- setPoint(obj->Get(NanNew<String>("seedPoint"))->ToObject()),
setColor(obj->Get(NanNew<String>("newColor"))->ToObject()),
obj->Get(NanNew<String>("rect"))->IsUndefined() ?
0 : setRect(obj->Get(NanNew<String>("rect"))->ToObject(), rect),
setColor(obj->Get(NanNew<String>("loDiff"))->ToObject()),
setColor(obj->Get(NanNew<String>("upDiff"))->ToObject()), 4);
+ setPoint(obj->Get(Nan::New<String>("seedPoint").ToLocalChecked())->ToObject()),
setColor(obj->Get(Nan::New<String>("newColor").ToLocalChecked())->ToObject()),
obj->Get(Nan::New<String>("rect").ToLocalChecked())->IsUndefined() ?
0 : setRect(obj->Get(Nan::New<String>("rect").ToLocalChecked())->ToObject(), rect),
setColor(obj->Get(Nan::New<String>("loDiff").ToLocalChecked())->ToObject()),
setColor(obj->Get(Nan::New<String>("upDiff").ToLocalChecked())->ToObject()), 4);
- NanReturnValue(NanNew<Number>(ret));
+ info.GetReturnValue().Set(Nan::New<Number>(ret));
- (args.Length() >= 1) ? args[0]->IsNumber() : false;
+ (info.Length() >= 1) ? info[0]->IsNumber() : false;
- (args.Length() >= 2) ? args[1]->IsNumber() : false;
double min_probability = filter_min_probability ? args[0]->NumberValue() : 0;
double max_probability = filter_max_probability ? args[1]->NumberValue() : 0;
int limit = (args.Length() >= 3) ? args[2]->IntegerValue() : 0;
bool ascending = (args.Length() >= 4) ? args[3]->BooleanValue() : false;
int min_x_distance = (args.Length() >= 5) ? args[4]->IntegerValue() : 0;
int min_y_distance = (args.Length() >= 6) ? args[5]->IntegerValue() : 0;
+ (info.Length() >= 2) ? info[1]->IsNumber() : false;
double min_probability = filter_min_probability ? info[0]->NumberValue() : 0;
double max_probability = filter_max_probability ? info[1]->NumberValue() : 0;
int limit = (info.Length() >= 3) ? info[2]->IntegerValue() : 0;
bool ascending = (info.Length() >= 4) ? info[3]->BooleanValue() : false;
int min_x_distance = (info.Length() >= 5) ? info[4]->IntegerValue() : 0;
int min_y_distance = (info.Length() >= 6) ? info[5]->IntegerValue() : 0;
- v8::Local < v8::Array > probabilites_array = NanNew<v8::Array>(limit);
+ v8::Local < v8::Array > probabilites_array = Nan::New<v8::Array>(limit);
- Local<Value> x_value = NanNew<Number>(pt.x);
Local<Value> y_value = NanNew<Number>(pt.y);
Local<Value> probability_value = NanNew<Number>(probability);
+ Local<Value> x_value = Nan::New<Number>(pt.x);
Local<Value> y_value = Nan::New<Number>(pt.y);
Local<Value> probability_value = Nan::New<Number>(probability);
- Local < Object > probability_object = NanNew<Object>();
probability_object->Set(NanNew<String>("x"), x_value);
probability_object->Set(NanNew<String>("y"), y_value);
probability_object->Set(NanNew<String>("probability"), probability_value);
+ Local < Object > probability_object = Nan::New<Object>();
probability_object->Set(Nan::New<String>("x").ToLocalChecked(), x_value);
probability_object->Set(Nan::New<String>("y").ToLocalChecked(), y_value);
probability_object->Set(Nan::New<String>("probability").ToLocalChecked(), probability_value);
- NanReturnValue(probabilites_array);
+ info.GetReturnValue().Set(probabilites_array);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- v8::String::Utf8Value args0(args[0]->ToString());
+ v8::String::Utf8Value args0(info[0]->ToString());
- Local<Object> out = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m_out = ObjectWrap::Unwrap<Matrix>(out);
+ Local<Object> out = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *m_out = Nan::ObjectWrap::Unwrap<Matrix>(out);
- int method = (args.Length() < 2) ? (int)cv::TM_CCORR_NORMED : args[1]->Uint32Value();
+ int method = (info.Length() < 2) ? (int)cv::TM_CCORR_NORMED : info[1]->Uint32Value();
- NanReturnValue(out);
+ info.GetReturnValue().Set(out);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- Local<Value> v_minVal = NanNew<Number>(minVal);
Local<Value> v_maxVal = NanNew<Number>(maxVal);
Local<Value> v_minLoc_x = NanNew<Number>(minLoc.x);
Local<Value> v_minLoc_y = NanNew<Number>(minLoc.y);
Local<Value> v_maxLoc_x = NanNew<Number>(maxLoc.x);
Local<Value> v_maxLoc_y = NanNew<Number>(maxLoc.y);
+ Local<Value> v_minVal = Nan::New<Number>(minVal);
Local<Value> v_maxVal = Nan::New<Number>(maxVal);
Local<Value> v_minLoc_x = Nan::New<Number>(minLoc.x);
Local<Value> v_minLoc_y = Nan::New<Number>(minLoc.y);
Local<Value> v_maxLoc_x = Nan::New<Number>(maxLoc.x);
Local<Value> v_maxLoc_y = Nan::New<Number>(maxLoc.y);
- Local<Object> o_minLoc = NanNew<Object>();
o_minLoc->Set(NanNew<String>("x"), v_minLoc_x);
o_minLoc->Set(NanNew<String>("y"), v_minLoc_y);
+ Local<Object> o_minLoc = Nan::New<Object>();
o_minLoc->Set(Nan::New<String>("x").ToLocalChecked(), v_minLoc_x);
o_minLoc->Set(Nan::New<String>("y").ToLocalChecked(), v_minLoc_y);
- Local<Object> o_maxLoc = NanNew<Object>();
o_maxLoc->Set(NanNew<String>("x"), v_maxLoc_x);
o_maxLoc->Set(NanNew<String>("y"), v_maxLoc_y);
+ Local<Object> o_maxLoc = Nan::New<Object>();
o_maxLoc->Set(Nan::New<String>("x").ToLocalChecked(), v_maxLoc_x);
o_maxLoc->Set(Nan::New<String>("y").ToLocalChecked(), v_maxLoc_y);
- Local<Object> result = NanNew<Object>();
result->Set(NanNew<String>("minVal"), v_minVal);
result->Set(NanNew<String>("maxVal"), v_maxVal);
result->Set(NanNew<String>("minLoc"), o_minLoc);
result->Set(NanNew<String>("maxLoc"), o_maxLoc);
+ Local<Object> result = Nan::New<Object>();
result->Set(Nan::New<String>("minVal").ToLocalChecked(), v_minVal);
result->Set(Nan::New<String>("maxVal").ToLocalChecked(), v_maxVal);
result->Set(Nan::New<String>("minLoc").ToLocalChecked(), o_minLoc);
result->Set(Nan::New<String>("maxLoc").ToLocalChecked(), o_maxLoc);
- NanReturnValue(result);
+ info.GetReturnValue().Set(result);
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
Matrix *m_input = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Matrix *m_input = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- NanReturnValue(args.This());
+ info.GetReturnValue().Set(info.This());
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
NanAsciiString textString(args[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
Nan::Utf8String textString(info[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152
- int x = args[1]->IntegerValue();
int y = args[2]->IntegerValue();
+ int x = info[1]->IntegerValue();
int y = info[2]->IntegerValue();
- NanAsciiString fontString(args[3]);
+ Nan::Utf8String fontString(info[3]);
- if (args[4]->IsArray()) {
Local<Object> objColor = args[4]->ToObject();
+ if (info[4]->IsArray()) {
Local<Object> objColor = info[4]->ToObject();
- double scale = args.Length() < 6 ? 1 : args[5]->NumberValue();
double thickness = args.Length() < 7 ? 1 : args[6]->NumberValue();
+ double scale = info.Length() < 6 ? 1 : info[5]->NumberValue();
double thickness = info.Length() < 7 ? 1 : info[6]->NumberValue();
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- // extract quad args
Local<Object> srcArray = args[0]->ToObject();
Local<Object> tgtArray = args[1]->ToObject();
+ // extract quad info
Local<Object> srcArray = info[0]->ToObject();
Local<Object> tgtArray = info[1]->ToObject();
- Local<Object> xfrm = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *xfrmmat = ObjectWrap::Unwrap<Matrix>(xfrm);
+ Local<Object> xfrm = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *xfrmmat = Nan::ObjectWrap::Unwrap<Matrix>(xfrm);
- NanReturnValue(xfrm);
+ info.GetReturnValue().Set(xfrm);
- Matrix *xfrm = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *xfrm = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- int width = args[1]->IntegerValue();
int height = args[2]->IntegerValue();
+ int width = info[1]->IntegerValue();
int height = info[2]->IntegerValue();
- if (args[3]->IsArray()) {
Local < Object > objColor = args[3]->ToObject();
+ if (info[3]->IsArray()) {
Local < Object > objColor = info[3]->ToObject();
- NanReturnNull();
+ info.GetReturnValue().Set(Nan::Null());
- Matrix *dest = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *dest = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- NanReturnUndefined();
+ return;
- Local < Object > valArray = args[0]->ToObject();
+ Local < Object > valArray = info[0]->ToObject();
- Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- NanReturnUndefined();
+ return;
- Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- v8::Local < v8::Array > arr = NanNew<Array>(3);
arr->Set(0, NanNew<Number>(means[0]));
arr->Set(1, NanNew<Number>(means[1]));
arr->Set(2, NanNew<Number>(means[2]));
+ v8::Local < v8::Array > arr = Nan::New<Array>(3);
arr->Set(0, Nan::New<Number>(means[0]));
arr->Set(1, Nan::New<Number>(means[1]));
arr->Set(2, Nan::New<Number>(means[2]));
- NanReturnValue(arr);
+ info.GetReturnValue().Set(arr);
- double tx = args[0]->NumberValue();
double ty = args[1]->NumberValue();
+ double tx = info[0]->NumberValue();
double ty = info[1]->NumberValue();
- // get the integer values of args
+ // get the integer values of info
- NanReturnUndefined();
+ return;
- NanScope();
+ Nan::HandleScope scope;
- Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+ Matrix *self = Nan::ObjectWrap::Unwrap<Matrix>(info.This());
- NanReturnUndefined();
+ return;
- v8::Persistent<FunctionTemplate> Point::constructor;
+ Nan::Persistent<FunctionTemplate> Point::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Point::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(Point::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("Point"));
+ ctor->SetClassName(Nan::New("Point").ToLocalChecked());
- proto->SetAccessor(NanNew("x"), GetX, RaiseImmutable);
proto->SetAccessor(NanNew("y"), GetY, RaiseImmutable);
+ Nan::SetAccessor(proto, Nan::New("x").ToLocalChecked(), GetX, RaiseImmutable);
Nan::SetAccessor(proto, Nan::New("y").ToLocalChecked(), GetY, RaiseImmutable);
- NODE_SET_PROTOTYPE_METHOD(ctor, "dot", Dot);
+ Nan::SetPrototypeMethod(ctor, "dot", Dot);
- target->Set(NanNew("Point"), ctor->GetFunction());
+ target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
return NanThrowTypeError("Cannot Instantiate without new");
+ if (info.This()->InternalFieldCount() == 0) {
return Nan::ThrowTypeError("Cannot Instantiate without new");
- if (args[0]->IsNumber()) {
x = args[0]->NumberValue();
+ if (info[0]->IsNumber()) {
x = info[0]->NumberValue();
- if (args[1]->IsNumber()) {
y = args[1]->NumberValue();
+ if (info[1]->IsNumber()) {
y = info[1]->NumberValue();
- pt->Wrap(args.This());
NanReturnValue(args.This());
+ pt->Wrap(info.This());
info.GetReturnValue().Set(info.This());
- NanScope();
Point *pt = ObjectWrap::Unwrap<Point>(args.This());
NanReturnValue(NanNew<Number>(pt->point.x));
+ Nan::HandleScope scope;
Point *pt = Nan::ObjectWrap::Unwrap<Point>(info.This());
info.GetReturnValue().Set(Nan::New<Number>(pt->point.x));
- NanScope();
Point *pt = ObjectWrap::Unwrap<Point>(args.This());
NanReturnValue(NanNew<Number>(pt->point.y));
+ Nan::HandleScope scope;
Point *pt = Nan::ObjectWrap::Unwrap<Point>(info.This());
info.GetReturnValue().Set(Nan::New<Number>(pt->point.y));
- NanThrowTypeError("Point is immutable");
+ Nan::ThrowTypeError("Point is immutable");
- NanScope();
Point *p1 = ObjectWrap::Unwrap<Point>(args.This());
Point *p2 = ObjectWrap::Unwrap<Point>(args[0]->ToObject());
+ Nan::HandleScope scope;
Point *p1 = Nan::ObjectWrap::Unwrap<Point>(info.This());
Point *p2 = Nan::ObjectWrap::Unwrap<Point>(info[0]->ToObject());
- NanReturnValue(NanNew<Number>(p1->point.x * p2->point.x + p1->point.y * p2->point.y));
+ info.GetReturnValue().Set(Nan::New<Number>(p1->point.x * p2->point.x + p1->point.y * p2->point.y));
- ObjectWrap() {
+ Nan::ObjectWrap() {
- class Point: public node::ObjectWrap {
+ class Point: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- v8::Persistent<FunctionTemplate> StereoBM::constructor;
+ Nan::Persistent<FunctionTemplate> StereoBM::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoBM::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoBM::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("StereoBM"));
+ ctor->SetClassName(Nan::New("StereoBM").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute);
+ Nan::SetPrototypeMethod(ctor, "compute", Compute);
- ctor->Set(NanNew<String>("BASIC_PRESET"), NanNew<Integer>((int)cv::StereoBM::BASIC_PRESET));
ctor->Set(NanNew<String>("FISH_EYE_PRESET"), NanNew<Integer>((int)cv::StereoBM::FISH_EYE_PRESET));
ctor->Set(NanNew<String>("NARROW_PRESET"), NanNew<Integer>((int)cv::StereoBM::NARROW_PRESET));
+ ctor->Set(Nan::New<String>("BASIC_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::BASIC_PRESET));
ctor->Set(Nan::New<String>("FISH_EYE_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::FISH_EYE_PRESET));
ctor->Set(Nan::New<String>("NARROW_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::NARROW_PRESET));
- target->Set(NanNew("StereoBM"), ctor->GetFunction());
+ target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new");
+ if (info.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new");
- if (args.Length() == 0) {
+ if (info.Length() == 0) {
- } else if (args.Length() == 1) {
+ } else if (info.Length() == 1) {
- stereo = new StereoBM(args[0]->IntegerValue());
} else if (args.Length() == 2) {
+ stereo = new StereoBM(info[0]->IntegerValue());
} else if (info.Length() == 2) {
- stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue());
+ stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue());
- stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
+ stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
- args[2]->IntegerValue());
+ info[2]->IntegerValue());
- stereo->Wrap(args.Holder());
NanReturnValue(args.Holder());
+ stereo->Wrap(info.Holder());
info.GetReturnValue().Set(info.Holder());
- ObjectWrap(),
+ Nan::ObjectWrap(),
- Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- if (args.Length() > 2) {
type = args[2]->IntegerValue();
+ if (info.Length() > 2) {
type = info[2]->IntegerValue();
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap);
- NanReturnValue(disparityWrap);
+ info.GetReturnValue().Set(disparityWrap);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- v8::Persistent<FunctionTemplate> StereoSGBM::constructor;
+ Nan::Persistent<FunctionTemplate> StereoSGBM::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoSGBM::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoSGBM::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("StereoSGBM"));
+ ctor->SetClassName(Nan::New("StereoSGBM").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute);
+ Nan::SetPrototypeMethod(ctor, "compute", Compute);
- target->Set(NanNew("StereoSGBM"), ctor->GetFunction());
+ target->Set(Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new");
+ if (info.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new");
- if (args.Length() == 0) {
+ if (info.Length() == 0) {
- if (args.Length() >= 3) {
switch (args.Length()) {
+ if (info.Length() >= 3) {
switch (info.Length()) {
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
args[5]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
info[5]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(),
args[8]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(),
info[8]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(),
args[8]->IntegerValue(), args[9]->IntegerValue());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(),
info[8]->IntegerValue(), info[9]->IntegerValue());
- stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(),
args[8]->IntegerValue(), args[9]->IntegerValue(), args[10]->ToBoolean()->Value());
+ stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(),
info[8]->IntegerValue(), info[9]->IntegerValue(), info[10]->ToBoolean()->Value());
- NanThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize");
NanReturnUndefined();
+ Nan::ThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize");
return;
- stereo->Wrap(args.Holder());
NanReturnValue(args.Holder());
+ stereo->Wrap(info.Holder());
info.GetReturnValue().Set(info.Holder());
- ObjectWrap(),
+ Nan::ObjectWrap(),
- ObjectWrap(),
+ Nan::ObjectWrap(),
- Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap);
- NanReturnValue(disparityWrap);
+ info.GetReturnValue().Set(disparityWrap);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- v8::Persistent<FunctionTemplate> StereoGC::constructor;
+ Nan::Persistent<FunctionTemplate> StereoGC::constructor;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoGC::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoGC::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("StereoGC"));
+ ctor->SetClassName(Nan::New("StereoGC").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute);
+ Nan::SetPrototypeMethod(ctor, "compute", Compute);
- target->Set(NanNew("StereoGC"), ctor->GetFunction());
+ target->Set(Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0)
NanThrowTypeError("Cannot instantiate without new");
+ if (info.This()->InternalFieldCount() == 0)
Nan::ThrowTypeError("Cannot instantiate without new");
- if (args.Length() == 0) {
+ if (info.Length() == 0) {
- } else if (args.Length() == 1) {
+ } else if (info.Length() == 1) {
- stereo = new StereoGC(args[0]->IntegerValue());
+ stereo = new StereoGC(info[0]->IntegerValue());
- stereo = new StereoGC(args[0]->IntegerValue(), args[1]->IntegerValue());
+ stereo = new StereoGC(info[0]->IntegerValue(), info[1]->IntegerValue());
- stereo->Wrap(args.Holder());
NanReturnValue(args.Holder());
+ stereo->Wrap(info.Holder());
info.GetReturnValue().Set(info.Holder());
- ObjectWrap() {
+ Nan::ObjectWrap() {
- Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+ Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
- Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+ Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
- NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap);
+ Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap);
- NanReturnValue(disparityWrap);
+ info.GetReturnValue().Set(disparityWrap);
- NanThrowError(err_msg);
NanReturnUndefined();
+ Nan::ThrowError(err_msg);
return;
- class StereoBM: public node::ObjectWrap {
+ class StereoBM: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- class StereoSGBM: public node::ObjectWrap {
+ class StereoSGBM: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- class StereoGC: public node::ObjectWrap {
+ class StereoGC: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- v8::Persistent<FunctionTemplate> VideoCaptureWrap::constructor;
+ Nan::Persistent<FunctionTemplate> VideoCaptureWrap::constructor;
- Persistent<Function> cb;
+ Nan::Persistent<Function> cb;
- NanScope();
+ Nan::HandleScope scope;
- Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(VideoCaptureWrap::New);
NanAssignPersistent(constructor, ctor);
+ Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(VideoCaptureWrap::New);
constructor.Reset(ctor);
- ctor->SetClassName(NanNew("VideoCapture"));
+ ctor->SetClassName(Nan::New("VideoCapture").ToLocalChecked());
- NODE_SET_PROTOTYPE_METHOD(ctor, "read", Read);
NODE_SET_PROTOTYPE_METHOD(ctor, "setWidth", SetWidth);
NODE_SET_PROTOTYPE_METHOD(ctor, "setHeight", SetHeight);
NODE_SET_PROTOTYPE_METHOD(ctor, "setPosition", SetPosition);
NODE_SET_PROTOTYPE_METHOD(ctor, "close", Close);
NODE_SET_PROTOTYPE_METHOD(ctor, "ReadSync", ReadSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "grab", Grab);
NODE_SET_PROTOTYPE_METHOD(ctor, "retrieve", Retrieve);
+ Nan::SetPrototypeMethod(ctor, "read", Read);
Nan::SetPrototypeMethod(ctor, "setWidth", SetWidth);
Nan::SetPrototypeMethod(ctor, "setHeight", SetHeight);
Nan::SetPrototypeMethod(ctor, "setPosition", SetPosition);
Nan::SetPrototypeMethod(ctor, "close", Close);
Nan::SetPrototypeMethod(ctor, "ReadSync", ReadSync);
Nan::SetPrototypeMethod(ctor, "grab", Grab);
Nan::SetPrototypeMethod(ctor, "retrieve", Retrieve);
- target->Set(NanNew("VideoCapture"), ctor->GetFunction());
+ target->Set(Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction());
- NanScope();
+ Nan::HandleScope scope;
- if (args.This()->InternalFieldCount() == 0)
return NanThrowTypeError("Cannot Instantiate without new");
+ if (info.This()->InternalFieldCount() == 0)
return Nan::ThrowTypeError("Cannot Instantiate without new");
- if (args[0]->IsNumber()) {
v = new VideoCaptureWrap(args[0]->NumberValue());
+ if (info[0]->IsNumber()) {
v = new VideoCaptureWrap(info[0]->NumberValue());
- v = new VideoCaptureWrap(std::string(*NanAsciiString(args[0]->ToString())));
+ v = new VideoCaptureWrap(std::string(*Nan::Utf8String(info[0]->ToString())));
- v->Wrap(args.This());
+ v->Wrap(info.This());
- NanReturnValue(args.This());
+ info.GetReturnValue().Set(info.This());
- NanScope();
+ Nan::HandleScope scope;
- NanThrowError("Camera could not be opened");
+ Nan::ThrowError("Camera could not be opened");
- NanScope();
+ Nan::HandleScope scope;
- NanThrowError("Video file could not be opened (opencv reqs. non relative paths)");
+ Nan::ThrowError("Video file could not be opened (opencv reqs. non relative paths)");
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- if(args.Length() != 1)
NanReturnUndefined();
+ if(info.Length() != 1)
return;
- int w = args[0]->IntegerValue();
+ int w = info[0]->IntegerValue();
- NanReturnUndefined();
+ return;
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- if(args.Length() != 1)
NanReturnUndefined();
+ if(info.Length() != 1)
return;
- int h = args[0]->IntegerValue();
+ int h = info[0]->IntegerValue();
- NanReturnUndefined();
+ return;
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- if(args.Length() != 1)
NanReturnUndefined();
+ if(info.Length() != 1)
return;
- int pos = args[0]->IntegerValue();
+ int pos = info[0]->IntegerValue();
- NanReturnUndefined();
+ return;
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- NanReturnUndefined();
+ return;
- class AsyncVCWorker: public NanAsyncWorker {
+ class AsyncVCWorker: public Nan::AsyncWorker {
- AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc,
+ AsyncVCWorker(Nan::Callback *callback, VideoCaptureWrap* vc,
- NanAsyncWorker(callback),
+ Nan::AsyncWorker(callback),
- NanScope();
+ Nan::HandleScope scope;
- Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
+ Local<Object> im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_to_return);
- NanNull()
+ Nan::Null()
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncVCWorker(callback, v));
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v));
- NanReturnUndefined();
+ return;
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
+ Local<Object> im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_to_return);
- NanReturnValue(im_to_return);
+ info.GetReturnValue().Set(im_to_return);
- class AsyncGrabWorker: public NanAsyncWorker {
+ class AsyncGrabWorker: public Nan::AsyncWorker {
- AsyncGrabWorker(NanCallback *callback, VideoCaptureWrap* vc) :
NanAsyncWorker(callback),
+ AsyncGrabWorker(Nan::Callback *callback, VideoCaptureWrap* vc) :
Nan::AsyncWorker(callback),
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncGrabWorker(callback, v));
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncGrabWorker(callback, v));
- NanReturnUndefined();
+ return;
- NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
+ Nan::HandleScope scope;
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
- NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel));
+ Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel));
- NanReturnUndefined();
+ return;
- class VideoCaptureWrap: public node::ObjectWrap {
+ class VideoCaptureWrap: public Nan::ObjectWrap {
- static Persistent<FunctionTemplate> constructor;
+ static Nan::Persistent<FunctionTemplate> constructor;
- NanScope();
+ Nan::HandleScope scope;
Please review changes in Node API for buffer module used in these files:
[Docs]
SlowBuffer or smalloc as the parent backing.63da0dfBuffer.concat() now always creates a new buffer, even if only called with one element.
SlowBuffer has been repurposed to return a Buffer instance who's parent backing is not pooled.456942aBuffer.prototype.toJSON()'s output is no longer the same as an array. Instead it is an object specifically tagged as a buffer, which can be recovered by passing it to (a new overload of) the Buffer constructor.840a29fBuffer.prototype.parent is now a getter that points to buffer.buffer if the buffer's size is greater than zero.63da0dfBuffer.prototype.offset is now a read-only getter that returns buffer.byteOffset.63da0dfBuffer.prototype.fill() now accepts multi-character strings and will fill with the entire passed value. Additionally, fill() now returns its buffer and can be chained.57ed3daBuffer.prototype._charsWritten no longer is written to, nor exists.ccda6bbImplementation changes in V8 have caused subtle impacts how buffers work with encodings in certain cases.
(new Buffer('text\0!', 'ascii')).toString() outputs 'text !' in 0.10 and 'text\u0000!' in 0.12.Please review changes in Node API for process module used in these files:
[Docs]
beforeExit time.'exit' and begins shutting down, it will emit a 'beforeExit' event. Code that is run in the 'beforeExit' event can schedule async operations that will hold the event loop open, unlike 'exit' where it is too late to async operations.a2eeb43process.kill() now throws errors on non-numeric input.
process.maxTickDepth has been removed, allowing process.nextTick() to starve I/O indefinitely.setImmediate() in 0.10.setImmediate() over process.NextTick(). setImmediate() likely does what you are hoping for (a more efficient setTimeout(..., 0)), and runs after this tick's I/O. process.nextTick() does not actually run in the "next" tick anymore and will block I/O as if it were a synchronous operation.0761c90, 9a6c085process.send() is now always asynchronous, where previously it was blocking on Unix.
In node 0.10.x, exit from a fatal signal was accomplished by a signal handler in
node which called exit(128 + signo). So for SIGINT (signal 2), a node process
observing the exit of a spawned node process would observe that process exiting 130,
but no signal would be noted (see waitid(2) for more information on how a process
waiting for another determines if the waitee exited due to a signal). In node
0.12.x, a node process observing the exit of a spawned child node process will
see a null code, and a 'SIGINT' as the signal.
Here is a pair of test programs which illustrates the difference.
$ cat sleeper.js
setTimeout(function () {}, 300000)
$ cat test.js
var cp = require("child_process")
var p = cp.spawn("node", ["sleeper.js"])
p.on('exit', function (code, signal) {
console.log("code=" + code + ", signal=" + signal)
})
setTimeout(function () { p.kill('SIGINT') }, 2000)
On node 0.10 this produces:
$ node test.js
code=130, signal=null
On node 0.12+ this produces:
$ node test.js
code=null, signal=SIGINT
This can be a subtle porting issue for multi-process node environments which care
about signals (such as test harnesses). This change was introduced by
c61b0e9—main: Handle SIGINT properly.
Please review changes in Node API for util module used in these files:
[Docs]
util.is*() (isArray() ... isUndefined()) type-checking functions were added in 0.12 but are scheduled for deprecation. Please use user-land solutions instead.Symbol.toStringTag.util.format() to receive several changes:-0 is now displayed as such, instead of as 0.b3e4fc6instanceof Error is now formatted as an error.684dd28%j specifier.2cd7adcinspect functions now receive any arguments passed to util.inspect.07774e67d14dd9896b2aa:util.p(), util.debug(), util.error() — Use console.error() instead.util.print(), util.puts() — Use console.log() instead.util.exec() — Now found at child_process.exec().util.pump() — Use ReadableStream.prototype.pipe() instead.