From fd40071640b112523b11367a4b6504f6169565c9 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Tue, 29 Sep 2015 12:59:06 -0500 Subject: [PATCH 1/9] prep --- .gitignore | 1 + package.json | 6 +++--- vagrant/Vagrantfile | 31 +++++++++++++++++++++++++++++++ vagrant/scripts/setup-node.sh | 6 ++++++ vagrant/setup.sh | 31 +++++++++++++++++++++++++++++++ vagrant/user.sh | 26 ++++++++++++++++++++++++++ 6 files changed, 98 insertions(+), 3 deletions(-) create mode 100644 vagrant/Vagrantfile create mode 100755 vagrant/scripts/setup-node.sh create mode 100755 vagrant/setup.sh create mode 100755 vagrant/user.sh diff --git a/.gitignore b/.gitignore index 160a3a9..ef08044 100755 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ out*.jpg out*.png examples/*.avi examples/tmp/* +vagrant/.vagrant diff --git a/package.json b/package.json index 226053a..88dda82 100644 --- a/package.json +++ b/package.json @@ -3,9 +3,9 @@ "description": "Node Bindings to OpenCV", "author": "Peter Braden ", "dependencies": { - "buffers": "0.1.1", - "nan": "^1.7.0", - "node-pre-gyp": "^0.6.4" + "buffers": "^0.1.1", + "nan": "^2.0.9", + "node-pre-gyp": "^0.6.11" }, "version": "3.2.0", "devDependencies": { diff --git a/vagrant/Vagrantfile b/vagrant/Vagrantfile new file mode 100644 index 0000000..ad5f0f0 --- /dev/null +++ b/vagrant/Vagrantfile @@ -0,0 +1,31 @@ +VAGRANTFILE_API_VERSION = "2" + +Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| + + # Using Ubuntu Trusty (14.04) for now + config.vm.box = "ubuntu/trusty64" + + # Give Box it's own IP + config.vm.network "private_network", ip: "192.168.35.111" + + # Would you rather use port forwarding? comment out that last line and add these: + # config.vm.network :forwarded_port, guest: 80, host: 8888 + # config.vm.network :forwarded_port, guest: 3000, host: 3000 #common port for node, etc + + # Sync parent folder. Clone this repo into project folder. + # I Like to work this way so I don't have vagrant files running all over my code. + # Parent folder will have the name of your app + config.vm.synced_folder "../", "/home/vagrant/"+File.basename(File.expand_path('..')) + + # EDIT THE SCRIPT REFERENCED BELOW TO + config.vm.provision "shell", path: "setup.sh" + + config.vm.provider "virtualbox" do |v| + #NAME THE VM -- You'll probably want to rename this box on a per-project basis. + #For now, it should inherit the name of the parent folder + v.name = "VDK - " + File.basename(File.expand_path('..')) + + # 512 is pretty tight to run Node.js on, if you're in to that sort of thing. I've boosted this. + v.memory = 1024 + end +end diff --git a/vagrant/scripts/setup-node.sh b/vagrant/scripts/setup-node.sh new file mode 100755 index 0000000..de3bbb2 --- /dev/null +++ b/vagrant/scripts/setup-node.sh @@ -0,0 +1,6 @@ +apt-get install gcc make build-essential -y +apt-get install -y curl +apt-get install -y git +curl --silent --location https://deb.nodesource.com/setup_4.x | sudo bash - +apt-get install -y nodejs + diff --git a/vagrant/setup.sh b/vagrant/setup.sh new file mode 100755 index 0000000..e51e282 --- /dev/null +++ b/vagrant/setup.sh @@ -0,0 +1,31 @@ +#!/bin/bash +apt-get update +apt-get upgrade -y + +#INSTALL BASE +chmod +x "/vagrant/scripts/base.sh" +$include "/vagrant/scripts/base.sh" + +#COMMENT OUT OR IN LINES AS APPROPRIATE +INCLUDED_TECH=() +INCLUDED_TECH+=("node") +#INCLUDED_TECH+=("mongodb") +#INCLUDED_TECH+=("meteor") +#INCLUDED_TECH+=("redis") +#INCLUDED_TECH+=("apache") +#INCLUDED_TECH+=("nginx") +#INCLUDED_TECH+=("mysql") +#INCLUDED_TECH+=("php") + +SCRIPT_LOCATION="/vagrant/scripts/setup-" + +for i in ${INCLUDED_TECH[@]}; do + chmod +x "${SCRIPT_LOCATION}${i}.sh" + $include "${SCRIPT_LOCATION}${i}.sh" +done + +echo "Base Setup Done!" +ls +#INSTALL USER +chmod +x "/vagrant/user.sh" +$include "/vagrant/user.sh" \ No newline at end of file diff --git a/vagrant/user.sh b/vagrant/user.sh new file mode 100755 index 0000000..fb22639 --- /dev/null +++ b/vagrant/user.sh @@ -0,0 +1,26 @@ +export REPO_FOLDER="node-opencv" +cd /home/vagrant/$REPO_FOLDER +apt-get install -y cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev +mkdir opencv_lib +cd /home/vagrant/$REPO_FOLDER/opencv_lib/ +[ ! -f /home/vagrant/$REPO_FOLDER/opencv_lib/2.4.11.tar.gz ] && wget https://github.com/Itseez/opencv/archive/2.4.11.tar.gz && tar -zxvf2.4.11.tar.gz +cd opencv-2.4.11 +mkdir release +cd release +echo "Removing any pre-installed ffmpeg and x264" +apt-get -y remove ffmpeg x264 libx264-dev +echo "Installing Dependenices" +apt-get -y install libopencv-dev +apt-get -y install build-essential checkinstall cmake pkg-config yasm +apt-get -y install libtiff4-dev libjpeg-dev libjasper-dev +apt-get -y install libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev libdc1394-22 libdc1394-utils libxine-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev +apt-get -y install python-dev python-numpy +apt-get -y install libtbb-dev +apt-get -y install libqt4-dev libgtk2.0-dev +apt-get -y install libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev +apt-get -y install x264 v4l-utils ffmpeg libx264-dev +apt-get -y install libgtk2.0-dev + +cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON .. +make install +cd /home/vagrant/$REPO_FOLDER/ From ea69fcc10b73a191e1d3dc6c9decdc1ebc8bc714 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Tue, 29 Sep 2015 13:39:49 -0500 Subject: [PATCH 2/9] conversion + build + test passed... so far --- src/BackgroundSubtractor.cc | 66 +- src/BackgroundSubtractor.h | 4 +- src/Calib3D.cc | 264 +++---- src/Calib3D.h | 2 +- src/CamShift.cc | 62 +- src/CamShift.h | 4 +- src/CascadeClassifierWrap.cc | 82 +- src/CascadeClassifierWrap.h | 4 +- src/Constants.cc | 12 +- src/Constants.h | 2 +- src/Contours.cc | 316 ++++---- src/Contours.h | 4 +- src/FaceRecognizer.cc | 112 +-- src/FaceRecognizer.h | 4 +- src/Features2d.cc | 28 +- src/Features2d.h | 4 +- src/HighGUI.cc | 54 +- src/HighGUI.h | 4 +- src/ImgProc.cc | 88 +-- src/ImgProc.h | 2 +- src/Matrix.cc | 1414 +++++++++++++++++----------------- src/Matrix.h | 58 +- src/OpenCV.cc | 40 +- src/OpenCV.h | 24 +- src/Point.cc | 60 +- src/Point.h | 4 +- src/Stereo.cc | 218 +++--- src/Stereo.h | 12 +- src/VideoCaptureWrap.cc | 156 ++-- src/VideoCaptureWrap.h | 4 +- src/init.cc | 2 +- vagrant/user.sh | 2 + 32 files changed, 1557 insertions(+), 1555 deletions(-) mode change 100755 => 100644 src/CascadeClassifierWrap.cc mode change 100755 => 100644 src/CascadeClassifierWrap.h mode change 100755 => 100644 src/Contours.cc mode change 100755 => 100644 src/Contours.h mode change 100755 => 100644 src/Matrix.cc mode change 100755 => 100644 src/Matrix.h mode change 100755 => 100644 src/OpenCV.cc mode change 100755 => 100644 src/OpenCV.h mode change 100755 => 100644 src/Point.cc mode change 100755 => 100644 src/Point.h mode change 100755 => 100644 src/VideoCaptureWrap.cc mode change 100755 => 100644 src/VideoCaptureWrap.h mode change 100755 => 100644 src/init.cc diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index af242b8..7bf1741 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -5,60 +5,60 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) -Persistent BackgroundSubtractorWrap::constructor; +Nan::Persistent BackgroundSubtractorWrap::constructor; void BackgroundSubtractorWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(BackgroundSubtractorWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(BackgroundSubtractorWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); } NAN_METHOD(BackgroundSubtractorWrap::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } // Create MOG by default cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); - pt->Wrap(args.This()); + pt->Wrap(info.This()); - NanReturnValue(args.This()); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) { - NanScope(); + Nan::HandleScope scope; // int history = 200; // int nmixtures = 5; // double backgroundRatio = 0.7; // double noiseSigma = 0; // - // if(args.Length() > 1){ + // if(info.Length() > 1){ // INT_FROM_ARGS(history, 0) // INT_FROM_ARGS(nmixtures, 1) // DOUBLE_FROM_ARGS(backgroundRatio, 2) // DOUBLE_FROM_ARGS(noiseSigma, 3) // } - Local n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } // Fetch foreground mask @@ -67,32 +67,32 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { REQ_FUN_ARG(1, cb); Local argv[2]; - 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; } try { Local fgMask = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(fgMask); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(fgMask); cv::Mat mat; - 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()); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); mat = cv::imdecode(*mbuf, -1); //mbuf->release(); } else { - Matrix *_img = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *_img = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); mat = (_img->mat).clone(); } if (mat.empty()) { - return NanThrowTypeError("Error loading file"); + return Nan::ThrowTypeError("Error loading file"); } cv::Mat _fgMask; @@ -101,20 +101,20 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { img->mat = _fgMask; mat.release(); - argv[0] = NanNull(); + argv[0] = Nan::Null(); argv[1] = fgMask; TryCatch try_catch; - cb->Call(NanGetCurrentContext()->Global(), 2, argv); + cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - NanReturnUndefined(); + return; } catch (cv::Exception& e) { const char* err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/BackgroundSubtractor.h b/src/BackgroundSubtractor.h index 67d51c5..b237699 100644 --- a/src/BackgroundSubtractor.h +++ b/src/BackgroundSubtractor.h @@ -4,11 +4,11 @@ #include -class BackgroundSubtractorWrap: public node::ObjectWrap { +class BackgroundSubtractorWrap: public Nan::ObjectWrap { public: cv::Ptr subtractor; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Calib3D.cc b/src/Calib3D.cc index 1242f40..a49ed31 100644 --- a/src/Calib3D.cc +++ b/src/Calib3D.cc @@ -3,15 +3,15 @@ inline Local matrixFromMat(cv::Mat &input) { Local matrixWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *matrix = ObjectWrap::Unwrap(matrixWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *matrix = Nan::ObjectWrap::Unwrap(matrixWrap); matrix->mat = input; return matrixWrap; } inline cv::Mat matFromMatrix(Handle matrix) { - Matrix* m = ObjectWrap::Unwrap(matrix->ToObject()); + Matrix* m = Nan::ObjectWrap::Unwrap(matrix->ToObject()); return m->mat; } @@ -38,8 +38,8 @@ inline std::vector points2fFromArray(Handle array) { for (unsigned int i = 0; i < pointsArray->Length(); i++) { Local pt = pointsArray->Get(i)->ToObject(); points.push_back( - cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value())); + cv::Point2f(pt->Get(Nan::New("x").ToLocalChecked())->ToNumber()->Value(), + pt->Get(Nan::New("y").ToLocalChecked())->ToNumber()->Value())); } } else { JSTHROW_TYPE("Points not a valid array"); @@ -56,9 +56,9 @@ inline std::vector points3fFromArray(Handle array) { for (unsigned int i = 0; i < pointsArray->Length(); i++) { Local pt = pointsArray->Get(i)->ToObject(); points.push_back( - cv::Point3f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value(), - pt->Get(NanNew("z"))->ToNumber()->Value())); + cv::Point3f(pt->Get(Nan::New("x").ToLocalChecked())->ToNumber()->Value(), + pt->Get(Nan::New("y").ToLocalChecked())->ToNumber()->Value(), + pt->Get(Nan::New("z").ToLocalChecked())->ToNumber()->Value())); } } else { JSTHROW_TYPE("Must pass array of object points for each frame") @@ -100,35 +100,35 @@ inline std::vector > points3fFromArrayOfArrays( } void Calib3D::Init(Handle target) { - Persistent inner; - Local obj = NanNew(); - NanAssignPersistent(inner, obj); + Nan::Persistent inner; + Local obj = Nan::New(); + 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); } // cv::findChessboardCorners NAN_METHOD(Calib3D::FindChessboardCorners) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments from javascript // Arg 0 is the image - cv::Mat mat = matFromMatrix(args[0]); + cv::Mat mat = matFromMatrix(info[0]); // Arg 1 is the pattern size - cv::Size patternSize = sizeFromArray(args[1]); + cv::Size patternSize = sizeFromArray(info[1]); // Arg 2 would normally be the flags, ignoring this for now and using the // default flags @@ -138,77 +138,77 @@ NAN_METHOD(Calib3D::FindChessboardCorners) { bool found = cv::findChessboardCorners(mat, patternSize, corners); // Make the return value - Local ret = NanNew(); - ret->Set(NanNew("found"), NanNew(found)); + Local ret = Nan::New(); + ret->Set(Nan::New("found").ToLocalChecked(), Nan::New(found)); - Local cornersArray = NanNew(corners.size()); + Local cornersArray = Nan::New(corners.size()); for (unsigned int i = 0; i < corners.size(); i++) { - Local point_data = NanNew(); - point_data->Set(NanNew("x"), NanNew(corners[i].x)); - point_data->Set(NanNew("y"), NanNew(corners[i].y)); + Local point_data = Nan::New(); + point_data->Set(Nan::New("x").ToLocalChecked(), Nan::New(corners[i].x)); + point_data->Set(Nan::New("y").ToLocalChecked(), Nan::New(corners[i].y)); - cornersArray->Set(NanNew(i), point_data); + cornersArray->Set(Nan::New(i), point_data); } - ret->Set(NanNew("corners"), cornersArray); + ret->Set(Nan::New("corners").ToLocalChecked(), cornersArray); - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::drawChessboardCorners NAN_METHOD(Calib3D::DrawChessboardCorners) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the image - cv::Mat mat = matFromMatrix(args[0]); + cv::Mat mat = matFromMatrix(info[0]); // Arg 1 is the pattern size - cv::Size patternSize = sizeFromArray(args[1]); + cv::Size patternSize = sizeFromArray(info[1]); // Arg 2 is the corners array - std::vector corners = points2fFromArray(args[2]); + std::vector corners = points2fFromArray(info[2]); // Arg 3, pattern found boolean - bool patternWasFound = args[3]->ToBoolean()->Value(); + bool patternWasFound = info[3]->ToBoolean()->Value(); // Draw the corners cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound); // Return the passed image, now with corners drawn on it - NanReturnValue(args[0]); + info.GetReturnValue().Set(info[0]); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::calibrateCamera NAN_METHOD(Calib3D::CalibrateCamera) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0, the array of object points, an array of arrays std::vector > objectPoints = - points3fFromArrayOfArrays(args[0]); + points3fFromArrayOfArrays(info[0]); // Arg 1, the image points, another array of arrays std::vector > imagePoints = - points2fFromArrayOfArrays(args[1]); + points2fFromArrayOfArrays(info[1]); // Arg 2, the image size - cv::Size imageSize = sizeFromArray(args[2]); + cv::Size imageSize = sizeFromArray(info[2]); // Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, // skipping for now @@ -223,48 +223,48 @@ NAN_METHOD(Calib3D::CalibrateCamera) { dist, rvecs, tvecs); // make the return values - Local ret = NanNew(); + Local ret = Nan::New(); // Reprojection error - ret->Set(NanNew("reprojectionError"), NanNew(error)); + ret->Set(Nan::New("reprojectionError").ToLocalChecked(), Nan::New(error)); // K Local KMatrixWrap = matrixFromMat(K); - ret->Set(NanNew("K"), KMatrixWrap); + ret->Set(Nan::New("K").ToLocalChecked(), KMatrixWrap); // dist Local distMatrixWrap = matrixFromMat(dist); - ret->Set(NanNew("distortion"), distMatrixWrap); + ret->Set(Nan::New("distortion").ToLocalChecked(), distMatrixWrap); // Per frame R and t, skiping for now // Return - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::solvePnP NAN_METHOD(Calib3D::SolvePnP) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0, the array of object points - std::vector objectPoints = points3fFromArray(args[0]); + std::vector objectPoints = points3fFromArray(info[0]); // Arg 1, the image points - std::vector imagePoints = points2fFromArray(args[1]); + std::vector imagePoints = points2fFromArray(info[1]); // Arg 2, the camera matrix - cv::Mat K = matFromMatrix(args[2]); + cv::Mat K = matFromMatrix(info[2]); // Arg 3, the distortion coefficients - cv::Mat dist = matFromMatrix(args[3]); + cv::Mat dist = matFromMatrix(info[3]); // Arg 4, use extrinsic guess, skipped for now @@ -276,47 +276,47 @@ NAN_METHOD(Calib3D::SolvePnP) { cv::solvePnP(objectPoints, imagePoints, K, dist, rvec, tvec); // make the return values - Local ret = NanNew(); + Local ret = Nan::New(); // rvec Local rMatrixWrap = matrixFromMat(rvec); - ret->Set(NanNew("rvec"), rMatrixWrap); + ret->Set(Nan::New("rvec").ToLocalChecked(), rMatrixWrap); // tvec Local tMatrixWrap = matrixFromMat(tvec); - ret->Set(NanNew("tvec"), tMatrixWrap); + ret->Set(Nan::New("tvec").ToLocalChecked(), tMatrixWrap); // Return - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::getOptimalNewCameraMAtrix NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the original camera matrix - cv::Mat Kin = matFromMatrix(args[0]); + cv::Mat Kin = matFromMatrix(info[0]); // Arg 1 is the distortion coefficients - cv::Mat dist = matFromMatrix(args[1]); + cv::Mat dist = matFromMatrix(info[1]); // Arg 2, the image size - cv::Size imageSize = sizeFromArray(args[2]); + cv::Size imageSize = sizeFromArray(info[2]); // Arg 3 is the alpha free scaling parameter - double alpha = args[3]->ToNumber()->Value(); + double alpha = info[3]->ToNumber()->Value(); // Arg 4, the new image size - cv::Size newImageSize = sizeFromArray(args[4]); + cv::Size newImageSize = sizeFromArray(info[4]); // Arg 5, valid ROI, skip for now // Arg 6, center principal point, skip for now @@ -329,46 +329,46 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { Local KMatrixWrap = matrixFromMat(Kout); // Return the new K matrix - NanReturnValue(KMatrixWrap); + info.GetReturnValue().Set(KMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::stereoCalibrate NAN_METHOD(Calib3D::StereoCalibrate) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0, the array of object points, an array of arrays std::vector > objectPoints = - points3fFromArrayOfArrays(args[0]); + points3fFromArrayOfArrays(info[0]); // Arg 1, the image points1, another array of arrays std::vector > imagePoints1 = - points2fFromArrayOfArrays(args[1]); + points2fFromArrayOfArrays(info[1]); // Arg 2, the image points2, another array of arrays =( std::vector > imagePoints2 = - points2fFromArrayOfArrays(args[2]); + points2fFromArrayOfArrays(info[2]); // Arg 3 is the image size (follows the PYTHON api not the C++ api since all // following arguments are optional or outputs) - cv::Size imageSize = sizeFromArray(args[3]); + cv::Size imageSize = sizeFromArray(info[3]); // Arg 4,5,6,7 is the camera matrix and distortion coefficients // (optional but must pass all 4 or none) cv::Mat k1, d1, k2, d2; - 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]); } // Last argument is flags, skipping for now @@ -381,7 +381,7 @@ NAN_METHOD(Calib3D::StereoCalibrate) { d2, imageSize, R, t, E, F); // make the return value - Local ret = NanNew(); + Local ret = Nan::New(); // Make the output arguments @@ -410,51 +410,51 @@ NAN_METHOD(Calib3D::StereoCalibrate) { Local FMatrixWrap = matrixFromMat(F); // Add to return object - ret->Set(NanNew("K1"), K1MatrixWrap); - ret->Set(NanNew("distortion1"), d1MatrixWrap); - ret->Set(NanNew("K2"), K2MatrixWrap); - ret->Set(NanNew("distortion2"), d2MatrixWrap); - ret->Set(NanNew("R"), RMatrixWrap); - ret->Set(NanNew("t"), tMatrixWrap); - ret->Set(NanNew("E"), EMatrixWrap); - ret->Set(NanNew("F"), FMatrixWrap); + ret->Set(Nan::New("K1").ToLocalChecked(), K1MatrixWrap); + ret->Set(Nan::New("distortion1").ToLocalChecked(), d1MatrixWrap); + ret->Set(Nan::New("K2").ToLocalChecked(), K2MatrixWrap); + ret->Set(Nan::New("distortion2").ToLocalChecked(), d2MatrixWrap); + ret->Set(Nan::New("R").ToLocalChecked(), RMatrixWrap); + ret->Set(Nan::New("t").ToLocalChecked(), tMatrixWrap); + ret->Set(Nan::New("E").ToLocalChecked(), EMatrixWrap); + ret->Set(Nan::New("F").ToLocalChecked(), FMatrixWrap); // Return - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::stereoRectify NAN_METHOD(Calib3D::StereoRectify) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg0, the first camera matrix - cv::Mat K1 = matFromMatrix(args[0]); + cv::Mat K1 = matFromMatrix(info[0]); // Arg1, the first distortion coefficients - cv::Mat d1 = matFromMatrix(args[1]); + cv::Mat d1 = matFromMatrix(info[1]); // Arg2, the second camera matrix - cv::Mat K2 = matFromMatrix(args[2]); + cv::Mat K2 = matFromMatrix(info[2]); // Arg3, the second distortion coefficients - cv::Mat d2 = matFromMatrix(args[3]); + cv::Mat d2 = matFromMatrix(info[3]); // Arg4, the image size - cv::Size imageSize = sizeFromArray(args[4]); + cv::Size imageSize = sizeFromArray(info[4]); // arg5, the intercamera rotation matrix - cv::Mat R = matFromMatrix(args[5]); + cv::Mat R = matFromMatrix(info[5]); // Arg6, the intercamera translation vector - cv::Mat t = matFromMatrix(args[6]); + cv::Mat t = matFromMatrix(info[6]); // Arg8, flags, skipping for now @@ -469,76 +469,76 @@ NAN_METHOD(Calib3D::StereoRectify) { cv::stereoRectify(K1, d1, K2, d2, imageSize, R, t, R1, R2, P1, P2, Q); // Make the return object - Local ret = NanNew(); + Local ret = Nan::New(); - ret->Set(NanNew("R1"), matrixFromMat(R1)); - ret->Set(NanNew("R2"), matrixFromMat(R2)); - ret->Set(NanNew("P1"), matrixFromMat(P1)); - ret->Set(NanNew("P2"), matrixFromMat(P2)); - ret->Set(NanNew("Q"), matrixFromMat(Q)); + ret->Set(Nan::New("R1").ToLocalChecked(), matrixFromMat(R1)); + ret->Set(Nan::New("R2").ToLocalChecked(), matrixFromMat(R2)); + ret->Set(Nan::New("P1").ToLocalChecked(), matrixFromMat(P1)); + ret->Set(Nan::New("P2").ToLocalChecked(), matrixFromMat(P2)); + ret->Set(Nan::New("Q").ToLocalChecked(), matrixFromMat(Q)); // Return the rectification parameters - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::computeCorrespondEpilines NAN_METHOD(Calib3D::ComputeCorrespondEpilines) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg0, the image points - std::vector points = points2fFromArray(args[0]); + std::vector points = points2fFromArray(info[0]); // Arg1, the image index (1 or 2) - int whichImage = int(args[1]->ToNumber()->Value()); + int whichImage = int(info[1]->ToNumber()->Value()); // Arg2, the fundamental matrix - cv::Mat F = matFromMatrix(args[2]); + cv::Mat F = matFromMatrix(info[2]); // compute the lines std::vector lines; cv::computeCorrespondEpilines(points, whichImage, F, lines); // Convert the lines to an array of objects (ax + by + c = 0) - Local linesArray = NanNew(lines.size()); + Local linesArray = Nan::New(lines.size()); for(unsigned int i = 0; i < lines.size(); i++) { - Local line_data = NanNew(); - line_data->Set(NanNew("a"), NanNew(lines[i][0])); - line_data->Set(NanNew("b"), NanNew(lines[i][1])); - line_data->Set(NanNew("c"), NanNew(lines[i][2])); + Local line_data = Nan::New(); + line_data->Set(Nan::New("a").ToLocalChecked(), Nan::New(lines[i][0])); + line_data->Set(Nan::New("b").ToLocalChecked(), Nan::New(lines[i][1])); + line_data->Set(Nan::New("c").ToLocalChecked(), Nan::New(lines[i][2])); - linesArray->Set(NanNew(i), line_data); + linesArray->Set(Nan::New(i), line_data); } // Return the lines - NanReturnValue(linesArray); + info.GetReturnValue().Set(linesArray); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::reprojectImageTo3D NAN_METHOD(Calib3D::ReprojectImageTo3D) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg0, the disparity image - cv::Mat disparity = matFromMatrix(args[0]); + cv::Mat disparity = matFromMatrix(info[0]); // Arg1, the depth-to-disparity transformation Q - cv::Mat Q = matFromMatrix(args[1]); + cv::Mat Q = matFromMatrix(info[1]); // Arg 2, handle missing values, skipped for now @@ -551,10 +551,10 @@ NAN_METHOD(Calib3D::ReprojectImageTo3D) { // Wrap the depth image Local depthImageMatrix = matrixFromMat(depthImage); - NanReturnValue(depthImageMatrix); + info.GetReturnValue().Set(depthImageMatrix); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/Calib3D.h b/src/Calib3D.h index a2f89f5..9617757 100644 --- a/src/Calib3D.h +++ b/src/Calib3D.h @@ -6,7 +6,7 @@ /** * Implementation of calib3d.hpp functions */ -class Calib3D: public node::ObjectWrap { +class Calib3D: public Nan::ObjectWrap { public: static void Init(Handle target); static NAN_METHOD(FindChessboardCorners); diff --git a/src/CamShift.cc b/src/CamShift.cc index 8468783..5e08324 100644 --- a/src/CamShift.cc +++ b/src/CamShift.cc @@ -8,38 +8,38 @@ #define CHANNEL_VALUE 2 -Persistent TrackedObject::constructor; +Nan::Persistent TrackedObject::constructor; void TrackedObject::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(TrackedObject::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(TrackedObject::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("TrackedObject")); + ctor->SetClassName(Nan::New("TrackedObject").ToLocalChecked()); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); } NAN_METHOD(TrackedObject::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } - Matrix* m = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Rect r; int channel = CHANNEL_HUE; - if (args[1]->IsArray()) { - Local v8rec = args[1]->ToObject(); + if (info[1]->IsArray()) { + Local v8rec = info[1]->ToObject(); r = cv::Rect( v8rec->Get(0)->IntegerValue(), v8rec->Get(1)->IntegerValue(), @@ -49,11 +49,11 @@ NAN_METHOD(TrackedObject::New) { JSTHROW_TYPE("Must pass rectangle to track") } - if (args[2]->IsObject()) { - Local opts = args[2]->ToObject(); + if (info[2]->IsObject()) { + Local 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()); std::string cc = std::string(*c); if (cc == "hue" || cc == "h") { @@ -72,8 +72,8 @@ NAN_METHOD(TrackedObject::New) { TrackedObject *to = new TrackedObject(m->mat, r, channel); - to->Wrap(args.This()); - NanReturnValue(args.This()); + to->Wrap(info.This()); + info.GetReturnValue().Set(info.This()); } void update_chann_image(TrackedObject* t, cv::Mat image) { @@ -117,17 +117,17 @@ TrackedObject::TrackedObject(cv::Mat image, cv::Rect rect, int chan) { NAN_METHOD(TrackedObject::Track) { SETUP_FUNCTION(TrackedObject) - 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(args[0]->ToObject()); + Matrix *im = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::RotatedRect r; if ((self->prev_rect.x < 0) || (self->prev_rect.y < 0) || (self->prev_rect.width <= 1) || (self->prev_rect.height <= 1)) { - return NanThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); + return Nan::ThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); } update_chann_image(self, im->mat); @@ -155,21 +155,21 @@ NAN_METHOD(TrackedObject::Track) { self->prev_rect = backup_prev_rect; } - v8::Local arr = NanNew(4); + v8::Local arr = Nan::New(4); - arr->Set(0, NanNew(bounds.x)); - arr->Set(1, NanNew(bounds.y)); - arr->Set(2, NanNew(bounds.x + bounds.width)); - arr->Set(3, NanNew(bounds.y + bounds.height)); + arr->Set(0, Nan::New(bounds.x)); + arr->Set(1, Nan::New(bounds.y)); + arr->Set(2, Nan::New(bounds.x + bounds.width)); + arr->Set(3, Nan::New(bounds.y + bounds.height)); /* cv::Point2f pts[4]; r.points(pts); for (int i = 0; i < 8; i += 2) { - arr->Set(i, NanNew(pts[i].x)); - arr->Set(i + 1, NanNew(pts[i].y)); + arr->Set(i, Nan::New(pts[i].x)); + arr->Set(i + 1, Nan::New(pts[i].y)); } */ - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } diff --git a/src/CamShift.h b/src/CamShift.h index f43be0c..ac049f3 100644 --- a/src/CamShift.h +++ b/src/CamShift.h @@ -1,7 +1,7 @@ #include "OpenCV.h" -class TrackedObject: public node::ObjectWrap { +class TrackedObject: public Nan::ObjectWrap { public: int channel; cv::Mat hsv; @@ -12,7 +12,7 @@ public: cv::Mat hist; cv::Rect prev_rect; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc old mode 100755 new mode 100644 index 64fae09..c3dce38 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -3,50 +3,50 @@ #include "Matrix.h" #include -Persistent CascadeClassifierWrap::constructor; +Nan::Persistent CascadeClassifierWrap::constructor; void CascadeClassifierWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew (CascadeClassifierWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New (CascadeClassifierWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("CascadeClassifier")); + ctor->SetClassName(Nan::New("CascadeClassifier").ToLocalChecked()); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); } NAN_METHOD(CascadeClassifierWrap::New) { - 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() ); } CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName) { std::string filename; - filename = std::string(*NanAsciiString(fileName->ToString())); + filename = std::string(*Nan::Utf8String(fileName->ToString())); if (!cc.load(filename.c_str())) { - NanThrowTypeError("Error loading file"); + Nan::ThrowTypeError("Error loading file"); } } -class AsyncDetectMultiScale: public NanAsyncWorker { +class AsyncDetectMultiScale: public Nan::AsyncWorker { public: - AsyncDetectMultiScale(NanCallback *callback, CascadeClassifierWrap *cc, + AsyncDetectMultiScale(Nan::Callback *callback, CascadeClassifierWrap *cc, Matrix* im, double scale, int neighbors, int minw, int minh) : - NanAsyncWorker(callback), + Nan::AsyncWorker(callback), cc(cc), im(im), scale(scale), @@ -79,22 +79,22 @@ public: } void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; // this->matrix->Unref(); Handle < Value > argv[2]; - v8::Local < v8::Array > arr = NanNew < v8::Array > (this->res.size()); + v8::Local < v8::Array > arr = Nan::New < v8::Array > (this->res.size()); for (unsigned int i = 0; i < this->res.size(); i++) { - v8::Local < v8::Object > x = NanNew(); - 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(); + 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)); arr->Set(i, x); } - argv[0] = NanNull(); + argv[0] = Nan::Null(); argv[1] = arr; TryCatch try_catch; @@ -115,37 +115,37 @@ private: }; NAN_METHOD(CascadeClassifierWrap::DetectMultiScale) { - NanScope(); + Nan::HandleScope scope; - CascadeClassifierWrap *self = ObjectWrap::Unwrap (args.This()); + CascadeClassifierWrap *self = Nan::ObjectWrap::Unwrap (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()); REQ_FUN_ARG(1, cb); double scale = 1.1; - if (args.Length() > 2 && args[2]->IsNumber()) { - scale = args[2]->NumberValue(); + if (info.Length() > 2 && info[2]->IsNumber()) { + scale = info[2]->NumberValue(); } int neighbors = 2; - if (args.Length() > 3 && args[3]->IsInt32()) { - neighbors = args[3]->IntegerValue(); + if (info.Length() > 3 && info[3]->IsInt32()) { + neighbors = info[3]->IntegerValue(); } int minw = 30; int minh = 30; - 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()); + Nan::Callback *callback = new Nan::Callback(cb.As()); - NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, + Nan::AsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, neighbors, minw, minh)); - NanReturnUndefined(); + return; } diff --git a/src/CascadeClassifierWrap.h b/src/CascadeClassifierWrap.h old mode 100755 new mode 100644 index 060ca3f..c0016d9 --- a/src/CascadeClassifierWrap.h +++ b/src/CascadeClassifierWrap.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class CascadeClassifierWrap: public node::ObjectWrap { +class CascadeClassifierWrap: public Nan::ObjectWrap { public: cv::CascadeClassifier cc; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Constants.cc b/src/Constants.cc index 1ed9904..5d9fa22 100644 --- a/src/Constants.cc +++ b/src/Constants.cc @@ -2,15 +2,15 @@ #include "Constants.h" #define CONST(C) \ - obj->Set(NanNew(#C), NanNew(C)); + obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New(C)); #define CONST_ENUM(C) \ - obj->Set(NanNew(#C), NanNew((int)(cv::C))); + obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New((int)(cv::C))); void Constants::Init(Handle target) { - Persistent inner; - Local obj = NanNew(); - NanAssignPersistent(inner, obj); + Nan::Persistent inner; + Local obj = Nan::New(); + inner.Reset(obj); CONST(CV_8U); CONST(CV_8S); @@ -72,7 +72,7 @@ void Constants::Init(Handle target) { CONST_ENUM(NORM_RELATIVE); CONST_ENUM(NORM_TYPE_MASK); - target->Set(NanNew("Constants"), obj); + target->Set(Nan::New("Constants").ToLocalChecked(), obj); } #undef CONST diff --git a/src/Constants.h b/src/Constants.h index c7bb6c6..9bb818e 100644 --- a/src/Constants.h +++ b/src/Constants.h @@ -1,6 +1,6 @@ #include "OpenCV.h" -class Constants: public node::ObjectWrap { +class Constants: public Nan::ObjectWrap { public: static void Init(Handle target); }; diff --git a/src/Contours.cc b/src/Contours.cc old mode 100755 new mode 100644 index 9705ff0..f8eb726 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -4,337 +4,337 @@ #include -v8::Persistent Contour::constructor; +Nan::Persistent Contour::constructor; void Contour::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Class/contructor - Local ctor = NanNew(Contour::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(Contour::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("Contours")); + ctor->SetClassName(Nan::New("Contours").ToLocalChecked()); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); }; NAN_METHOD(Contour::New) { - 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"); } Contour *contours; contours = new Contour; - contours->Wrap(args.Holder()); - NanReturnValue(args.Holder()); + contours->Wrap(info.Holder()); + info.GetReturnValue().Set(info.Holder()); } Contour::Contour() : - ObjectWrap() { + Nan::ObjectWrap() { } NAN_METHOD(Contour::Point) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); - int index = args[1]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); + int index = info[1]->NumberValue(); cv::Point point = self->contours[pos][index]; - Local data = NanNew(); - data->Set(NanNew("x"), NanNew(point.x)); - data->Set(NanNew("y"), NanNew(point.y)); + Local data = Nan::New(); + data->Set(Nan::New("x").ToLocalChecked(), Nan::New(point.x)); + data->Set(Nan::New("y").ToLocalChecked(), Nan::New(point.y)); - NanReturnValue(data); + info.GetReturnValue().Set(data); } NAN_METHOD(Contour::Points) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); vector points = self->contours[pos]; - Local data = NanNew(points.size()); + Local data = Nan::New(points.size()); for (std::vector::size_type i = 0; i != points.size(); i++) { - Local point_data = NanNew(); - point_data->Set(NanNew("x"), NanNew(points[i].x)); - point_data->Set(NanNew("y"), NanNew(points[i].y)); + Local point_data = Nan::New(); + point_data->Set(Nan::New("x").ToLocalChecked(), Nan::New(points[i].x)); + point_data->Set(Nan::New("y").ToLocalChecked(), Nan::New(points[i].y)); data->Set(i, point_data); } - NanReturnValue(data); + info.GetReturnValue().Set(data); } // FIXME: this should better be called "Length" as ``Contours`` is an Array like // structure also, this would allow to use ``Size`` for the function returning // the number of corners in the contour for better consistency with OpenCV. NAN_METHOD(Contour::Size) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - NanReturnValue(NanNew(self->contours.size())); + info.GetReturnValue().Set(Nan::New(self->contours.size())); } NAN_METHOD(Contour::CornerCount) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); - NanReturnValue(NanNew(self->contours[pos].size())); + info.GetReturnValue().Set(Nan::New(self->contours[pos].size())); } NAN_METHOD(Contour::Area) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); - // NanReturnValue(NanNew(contourArea(self->contours))); - NanReturnValue(NanNew(contourArea(cv::Mat(self->contours[pos])))); + // info.GetReturnValue().Set(Nan::New(contourArea(self->contours))); + info.GetReturnValue().Set(Nan::New(contourArea(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::ArcLength) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); - bool isClosed = args[1]->BooleanValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); + bool isClosed = info[1]->BooleanValue(); - NanReturnValue(NanNew(arcLength(cv::Mat(self->contours[pos]), isClosed))); + info.GetReturnValue().Set(Nan::New(arcLength(cv::Mat(self->contours[pos]), isClosed))); } NAN_METHOD(Contour::ApproxPolyDP) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); - double epsilon = args[1]->NumberValue(); - bool isClosed = args[2]->BooleanValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); + double epsilon = info[1]->NumberValue(); + bool isClosed = info[2]->BooleanValue(); cv::Mat approxed; approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed); approxed.copyTo(self->contours[pos]); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Contour::ConvexHull) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = args[0]->NumberValue(); - bool clockwise = args[1]->BooleanValue(); + int pos = info[0]->NumberValue(); + bool clockwise = info[1]->BooleanValue(); cv::Mat hull; cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise); hull.copyTo(self->contours[pos]); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Contour::BoundingRect) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos])); - Local rect = NanNew(); + Local rect = Nan::New(); - rect->Set(NanNew("x"), NanNew(bounding.x)); - rect->Set(NanNew("y"), NanNew(bounding.y)); - rect->Set(NanNew("width"), NanNew(bounding.width)); - rect->Set(NanNew("height"), NanNew(bounding.height)); + rect->Set(Nan::New("x").ToLocalChecked(), Nan::New(bounding.x)); + rect->Set(Nan::New("y").ToLocalChecked(), Nan::New(bounding.y)); + rect->Set(Nan::New("width").ToLocalChecked(), Nan::New(bounding.width)); + rect->Set(Nan::New("height").ToLocalChecked(), Nan::New(bounding.height)); - NanReturnValue(rect); + info.GetReturnValue().Set(rect); } NAN_METHOD(Contour::MinAreaRect) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos])); - Local rect = NanNew(); - rect->Set(NanNew("angle"), NanNew(minimum.angle)); + Local rect = Nan::New(); + rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New(minimum.angle)); - Local size = NanNew(); - size->Set(NanNew("height"), NanNew(minimum.size.height)); - size->Set(NanNew("width"), NanNew(minimum.size.width)); - rect->Set(NanNew("size"), size); + Local size = Nan::New(); + size->Set(Nan::New("height").ToLocalChecked(), Nan::New(minimum.size.height)); + size->Set(Nan::New("width").ToLocalChecked(), Nan::New(minimum.size.width)); + rect->Set(Nan::New("size").ToLocalChecked(), size); - Local center = NanNew(); - center->Set(NanNew("x"), NanNew(minimum.center.x)); - center->Set(NanNew("y"), NanNew(minimum.center.y)); + Local center = Nan::New(); + center->Set(Nan::New("x").ToLocalChecked(), Nan::New(minimum.center.x)); + center->Set(Nan::New("y").ToLocalChecked(), Nan::New(minimum.center.y)); - v8::Local points = NanNew(4); + v8::Local points = Nan::New(4); cv::Point2f rect_points[4]; minimum.points(rect_points); for (unsigned int i=0; i<4; i++) { - Local point = NanNew(); - point->Set(NanNew("x"), NanNew(rect_points[i].x)); - point->Set(NanNew("y"), NanNew(rect_points[i].y)); + Local point = Nan::New(); + point->Set(Nan::New("x").ToLocalChecked(), Nan::New(rect_points[i].x)); + point->Set(Nan::New("y").ToLocalChecked(), Nan::New(rect_points[i].y)); points->Set(i, point); } - rect->Set(NanNew("points"), points); + rect->Set(Nan::New("points").ToLocalChecked(), points); - NanReturnValue(rect); + info.GetReturnValue().Set(rect); } NAN_METHOD(Contour::FitEllipse) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); if (self->contours[pos].size() >= 5) { // Minimum number for an ellipse cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos])); - Local jsEllipse = NanNew(); - jsEllipse->Set(NanNew("angle"), NanNew(ellipse.angle)); + Local jsEllipse = Nan::New(); + jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New(ellipse.angle)); - Local size = NanNew(); - size->Set(NanNew("height"), NanNew(ellipse.size.height)); - size->Set(NanNew("width"), NanNew(ellipse.size.width)); - jsEllipse->Set(NanNew("size"), size); + Local size = Nan::New(); + size->Set(Nan::New("height").ToLocalChecked(), Nan::New(ellipse.size.height)); + size->Set(Nan::New("width").ToLocalChecked(), Nan::New(ellipse.size.width)); + jsEllipse->Set(Nan::New("size").ToLocalChecked(), size); - Local center = NanNew(); - center->Set(NanNew("x"), NanNew(ellipse.center.x)); - center->Set(NanNew("y"), NanNew(ellipse.center.y)); - jsEllipse->Set(NanNew("center"), center); + Local center = Nan::New(); + center->Set(Nan::New("x").ToLocalChecked(), Nan::New(ellipse.center.x)); + center->Set(Nan::New("y").ToLocalChecked(), Nan::New(ellipse.center.y)); + jsEllipse->Set(Nan::New("center").ToLocalChecked(), center); - NanReturnValue(jsEllipse); + info.GetReturnValue().Set(jsEllipse); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Contour::IsConvex) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); - NanReturnValue(NanNew(isContourConvex(cv::Mat(self->contours[pos])))); + info.GetReturnValue().Set(Nan::New(isContourConvex(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::Moments) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); // Get the moments cv::Moments mu = moments( self->contours[pos], false ); - Local res = NanNew(); + Local res = Nan::New(); - res->Set(NanNew("m00"), NanNew(mu.m00)); - res->Set(NanNew("m10"), NanNew(mu.m10)); - res->Set(NanNew("m01"), NanNew(mu.m01)); - res->Set(NanNew("m11"), NanNew(mu.m11)); + res->Set(Nan::New("m00").ToLocalChecked(), Nan::New(mu.m00)); + res->Set(Nan::New("m10").ToLocalChecked(), Nan::New(mu.m10)); + res->Set(Nan::New("m01").ToLocalChecked(), Nan::New(mu.m01)); + res->Set(Nan::New("m11").ToLocalChecked(), Nan::New(mu.m11)); - NanReturnValue(res); + info.GetReturnValue().Set(res); } NAN_METHOD(Contour::Hierarchy) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->IntegerValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->IntegerValue(); cv::Vec4i hierarchy = self->hierarchy[pos]; - Local res = NanNew(4); + Local res = Nan::New(4); - res->Set(0, NanNew(hierarchy[0])); - res->Set(1, NanNew(hierarchy[1])); - res->Set(2, NanNew(hierarchy[2])); - res->Set(3, NanNew(hierarchy[3])); + res->Set(0, Nan::New(hierarchy[0])); + res->Set(1, Nan::New(hierarchy[1])); + res->Set(2, Nan::New(hierarchy[2])); + res->Set(3, Nan::New(hierarchy[3])); - NanReturnValue(res); + info.GetReturnValue().Set(res); } NAN_METHOD(Contour::Serialize) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - Local contours_data = NanNew(self->contours.size()); + Local contours_data = Nan::New(self->contours.size()); for (std::vector::size_type i = 0; i != self->contours.size(); i++) { vector points = self->contours[i]; - Local contour_data = NanNew(points.size()); + Local contour_data = Nan::New(points.size()); for (std::vector::size_type j = 0; j != points.size(); j++) { - Local point_data = NanNew(2); - point_data->Set(0, NanNew(points[j].x)); - point_data->Set(1, NanNew(points[j].y)); + Local point_data = Nan::New(2); + point_data->Set(0, Nan::New(points[j].x)); + point_data->Set(1, Nan::New(points[j].y)); contour_data->Set(j, point_data); } contours_data->Set(i, contour_data); } - Local hierarchy_data = NanNew(self->hierarchy.size()); + Local hierarchy_data = Nan::New(self->hierarchy.size()); for (std::vector::size_type i = 0; i != self->hierarchy.size(); i++) { - Local contour_data = NanNew(4); - contour_data->Set(0, NanNew(self->hierarchy[i][0])); - contour_data->Set(1, NanNew(self->hierarchy[i][1])); - contour_data->Set(2, NanNew(self->hierarchy[i][2])); - contour_data->Set(3, NanNew(self->hierarchy[i][3])); + Local contour_data = Nan::New(4); + contour_data->Set(0, Nan::New(self->hierarchy[i][0])); + contour_data->Set(1, Nan::New(self->hierarchy[i][1])); + contour_data->Set(2, Nan::New(self->hierarchy[i][2])); + contour_data->Set(3, Nan::New(self->hierarchy[i][3])); hierarchy_data->Set(i, contour_data); } - Local data = NanNew(); - data->Set(NanNew("contours"), contours_data); - data->Set(NanNew("hierarchy"), hierarchy_data); + Local data = Nan::New(); + data->Set(Nan::New("contours").ToLocalChecked(), contours_data); + data->Set(Nan::New("hierarchy").ToLocalChecked(), hierarchy_data); - NanReturnValue(data); + info.GetReturnValue().Set(data); } NAN_METHOD(Contour::Deserialize) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - Handle data = Handle::Cast(args[0]); + Handle data = Handle::Cast(info[0]); - Handle contours_data = Handle::Cast(data->Get(NanNew("contours"))); - Handle hierarchy_data = Handle::Cast(data->Get(NanNew("hierarchy"))); + Handle contours_data = Handle::Cast(data->Get(Nan::New("contours").ToLocalChecked())); + Handle hierarchy_data = Handle::Cast(data->Get(Nan::New("hierarchy").ToLocalChecked())); vector > contours_res; int contours_length = contours_data->Length(); @@ -369,5 +369,5 @@ NAN_METHOD(Contour::Deserialize) { self->contours = contours_res; self->hierarchy = hierarchy_res; - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } diff --git a/src/Contours.h b/src/Contours.h old mode 100755 new mode 100644 index bd442ea..b1a496a --- a/src/Contours.h +++ b/src/Contours.h @@ -2,13 +2,13 @@ using namespace std; -class Contour: public node::ObjectWrap { +class Contour: public Nan::ObjectWrap { public: cv::Mat mat; vector > contours; vector hierarchy; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc index 3814d45..1b2eb82 100644 --- a/src/FaceRecognizer.cc +++ b/src/FaceRecognizer.cc @@ -14,11 +14,11 @@ cv::Mat fromMatrixOrFilename(Local v) { cv::Mat im; if (v->IsString()) { - std::string filename = std::string(*NanAsciiString(v->ToString())); + std::string filename = std::string(*Nan::Utf8String(v->ToString())); im = cv::imread(filename); // std::cout<< im.size(); } else { - Matrix *img = ObjectWrap::Unwrap(v->ToObject()); + Matrix *img = Nan::ObjectWrap::Unwrap(v->ToObject()); im = img->mat; } return im; @@ -27,36 +27,36 @@ cv::Mat fromMatrixOrFilename(Local v) { void AsyncPredict(uv_work_t *req); void AfterAsyncPredict(uv_work_t *req); -Persistent FaceRecognizerWrap::constructor; +Nan::Persistent FaceRecognizerWrap::constructor; void FaceRecognizerWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(FaceRecognizerWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(FaceRecognizerWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); }; NAN_METHOD(FaceRecognizerWrap::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } @@ -64,12 +64,12 @@ NAN_METHOD(FaceRecognizerWrap::New) { cv::Ptr f = cv::createLBPHFaceRecognizer(1, 8, 8, 8, 80.0); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); - pt->Wrap(args.This()); - NanReturnValue(args.This()); + pt->Wrap(info.This()); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { - NanScope(); + Nan::HandleScope scope; int radius = 1; int neighbors = 8; @@ -83,17 +83,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { INT_FROM_ARGS(grid_y, 3) DOUBLE_FROM_ARGS(threshold, 4) - Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createLBPHFaceRecognizer(radius, neighbors, grid_x, grid_y, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } NAN_METHOD(FaceRecognizerWrap::CreateEigen) { - NanScope(); + Nan::HandleScope scope; int components = 0; double threshold = DBL_MAX; @@ -101,17 +101,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateEigen) { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createEigenFaceRecognizer(components, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } NAN_METHOD(FaceRecognizerWrap::CreateFisher) { - NanScope(); + Nan::HandleScope scope; int components = 0; double threshold = DBL_MAX; @@ -119,14 +119,14 @@ NAN_METHOD(FaceRecognizerWrap::CreateFisher) { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createFisherFaceRecognizer(components, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, @@ -135,16 +135,16 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, typ = type; } -Handle UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, +Handle UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info, cv::vector* images, cv::vector* labels) { - if (args.Length() < 1 || !args[0]->IsArray()) { + if (info.Length() < 1 || !info[0]->IsArray()) { JSTHROW("FaceRecognizer.train takes a list of [ label, image] tuples") } // Iterate through [[label, image], ...] etc, and add matrix / label to vectors - // const Local tuples = v8::Array::Cast(*args[0]); - const Local tuples = Local::Cast(args[0]); + // const Local tuples = v8::Array::Cast(*info[0]); + const Local tuples = Local::Cast(info[0]); const uint32_t length = tuples->Length(); for (uint32_t i=0; i UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, labels->push_back(label); images->push_back(im); } - return NanUndefined(); + return Nan::Undefined(); } NAN_METHOD(FaceRecognizerWrap::TrainSync) { @@ -176,14 +176,14 @@ NAN_METHOD(FaceRecognizerWrap::TrainSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(args, &images, &labels); + Handle exception = UnwrapTrainingData(info, &images, &labels); if (!exception->IsUndefined()) { - NanReturnValue(exception); // FIXME: not too sure about returning exceptions like this + info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this } self->rec->train(images, labels); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::UpdateSync) { @@ -199,20 +199,20 @@ NAN_METHOD(FaceRecognizerWrap::UpdateSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(args, &images, &labels); + Handle exception = UnwrapTrainingData(info, &images, &labels); if (!exception->IsUndefined()) { JSTHROW(exception); } self->rec->update(images, labels); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::PredictSync) { SETUP_FUNCTION(FaceRecognizerWrap) - cv::Mat im = fromMatrixOrFilename(args[0]); // TODO CHECK! + cv::Mat im = fromMatrixOrFilename(info[0]); // TODO CHECK! cv::cvtColor(im, im, CV_RGB2GRAY); // int predictedLabel = self->rec->predict(im); @@ -220,46 +220,46 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync) { double confidence = 0.0; self->rec->predict(im, predictedLabel, confidence); - v8::Local res = NanNew(); - res->Set(NanNew("id"), NanNew(predictedLabel)); - res->Set(NanNew("confidence"), NanNew(confidence)); + v8::Local res = Nan::New(); + res->Set(Nan::New("id").ToLocalChecked(), Nan::New(predictedLabel)); + res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New(confidence)); - NanReturnValue(res); + info.GetReturnValue().Set(res); } NAN_METHOD(FaceRecognizerWrap::SaveSync) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!args[0]->IsString()) { + if (!info[0]->IsString()) { JSTHROW("Save takes a filename") } - std::string filename = std::string(*NanAsciiString(args[0]->ToString())); + std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); self->rec->save(filename); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::LoadSync) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!args[0]->IsString()) { + if (!info[0]->IsString()) { JSTHROW("Load takes a filename") } - std::string filename = std::string(*NanAsciiString(args[0]->ToString())); + std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); self->rec->load(filename); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::GetMat) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!args[0]->IsString()) { + if (!info[0]->IsString()) { JSTHROW("getMat takes a key") } - std::string key = std::string(*NanAsciiString(args[0]->ToString())); + std::string key = std::string(*Nan::Utf8String(info[0]->ToString())); cv::Mat m = self->rec->getMat(key); - Local im = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im); + Local im = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im); img->mat = m; - NanReturnValue(im); + info.GetReturnValue().Set(im); } #endif // End version > 2.4 diff --git a/src/FaceRecognizer.h b/src/FaceRecognizer.h index d9bf2aa..6a19d10 100644 --- a/src/FaceRecognizer.h +++ b/src/FaceRecognizer.h @@ -4,12 +4,12 @@ #include "opencv2/contrib/contrib.hpp" -class FaceRecognizerWrap: public node::ObjectWrap { +class FaceRecognizerWrap: public Nan::ObjectWrap { public: cv::Ptr rec; int typ; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Features2d.cc b/src/Features2d.cc index e099275..ce09abc 100644 --- a/src/Features2d.cc +++ b/src/Features2d.cc @@ -6,15 +6,15 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) void Features::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - NODE_SET_METHOD(target, "ImageSimilarity", Similarity); + Nan::SetMethod(target, "ImageSimilarity", Similarity); } -class AsyncDetectSimilarity: public NanAsyncWorker { +class AsyncDetectSimilarity: public Nan::AsyncWorker { public: - AsyncDetectSimilarity(NanCallback *callback, cv::Mat image1, cv::Mat image2) : - NanAsyncWorker(callback), + AsyncDetectSimilarity(Nan::Callback *callback, cv::Mat image1, cv::Mat image2) : + Nan::AsyncWorker(callback), image1(image1), image2(image2), dissimilarity(0) { @@ -80,12 +80,12 @@ public: } void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; Handle argv[2]; - argv[0] = NanNull(); - argv[1] = NanNew(dissimilarity); + argv[0] = Nan::Null(); + argv[1] = Nan::New(dissimilarity); callback->Call(2, argv); } @@ -97,17 +97,17 @@ private: }; NAN_METHOD(Features::Similarity) { - NanScope(); + Nan::HandleScope scope; REQ_FUN_ARG(2, cb); - cv::Mat image1 = ObjectWrap::Unwrap(args[0]->ToObject())->mat; - cv::Mat image2 = ObjectWrap::Unwrap(args[1]->ToObject())->mat; + cv::Mat image1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject())->mat; + cv::Mat image2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject())->mat; - NanCallback *callback = new NanCallback(cb.As()); + Nan::Callback *callback = new Nan::Callback(cb.As()); - NanAsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); - NanReturnUndefined(); + Nan::AsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); + return; } #endif diff --git a/src/Features2d.h b/src/Features2d.h index 764bec8..600f646 100644 --- a/src/Features2d.h +++ b/src/Features2d.h @@ -5,9 +5,9 @@ #include #include -class Features: public node::ObjectWrap { +class Features: public Nan::ObjectWrap { public: - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(Similarity); diff --git a/src/HighGUI.cc b/src/HighGUI.cc index 6e09579..b43fb89 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -2,41 +2,41 @@ #include "OpenCV.h" #include "Matrix.h" -Persistent NamedWindow::constructor; +Nan::Persistent NamedWindow::constructor; void NamedWindow::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(NamedWindow::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(NamedWindow::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("NamedWindow")); + ctor->SetClassName(Nan::New("NamedWindow").ToLocalChecked()); // Prototype - 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()); }; NAN_METHOD(NamedWindow::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } NamedWindow* win; - 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()); } NamedWindow::NamedWindow(const std::string& name, int f) { @@ -47,38 +47,38 @@ NamedWindow::NamedWindow(const std::string& name, int f) { NAN_METHOD(NamedWindow::Show) { SETUP_FUNCTION(NamedWindow) - Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *im = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); try { cv::imshow(self->winname, im->mat); } catch (cv::Exception& e) { const char* err_msg = e.what(); - NanThrowError(err_msg); + Nan::ThrowError(err_msg); } - NanReturnValue(args.Holder()); + info.GetReturnValue().Set(info.Holder()); } NAN_METHOD(NamedWindow::Destroy) { SETUP_FUNCTION(NamedWindow) cv::destroyWindow(self->winname); - NanReturnValue(args.Holder()); + info.GetReturnValue().Set(info.Holder()); } NAN_METHOD(NamedWindow::BlockingWaitKey) { - NanScope(); + Nan::HandleScope scope; //SETUP_FUNCTION(NamedWindow) int time = 0; - if (args.Length() > 1) { - time = args[1]->IntegerValue(); + if (info.Length() > 1) { + time = info[1]->IntegerValue(); } else { - if (args.Length() > 0) { - time = args[0]->IntegerValue(); + if (info.Length() > 0) { + time = info[0]->IntegerValue(); } } int res = cv::waitKey(time); - NanReturnValue(NanNew(res)); + info.GetReturnValue().Set(Nan::New(res)); } diff --git a/src/HighGUI.h b/src/HighGUI.h index e88254b..9b7019a 100644 --- a/src/HighGUI.h +++ b/src/HighGUI.h @@ -1,11 +1,11 @@ #include "OpenCV.h" -class NamedWindow: public node::ObjectWrap { +class NamedWindow: public Nan::ObjectWrap { public: std::string winname; int flags; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/ImgProc.cc b/src/ImgProc.cc index 20f32c8..b84e20a 100644 --- a/src/ImgProc.cc +++ b/src/ImgProc.cc @@ -2,34 +2,34 @@ #include "Matrix.h" void ImgProc::Init(Handle target) { - Persistent inner; - Local obj = NanNew(); - NanAssignPersistent(inner, obj); + Nan::Persistent inner; + Local obj = Nan::New(); + 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); } // cv::undistort NAN_METHOD(ImgProc::Undistort) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat inputImage = m0->mat; // Arg 1 is the camera matrix - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat K = m1->mat; // Arg 2 is the distortion coefficents - Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::Mat dist = m2->mat; // Make an mat to hold the result image @@ -39,51 +39,51 @@ NAN_METHOD(ImgProc::Undistort) { cv::undistort(inputImage, outputImage, K, dist); // Wrap the output image - Local outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *outMatrix = ObjectWrap::Unwrap(outMatrixWrap); + Local outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *outMatrix = Nan::ObjectWrap::Unwrap(outMatrixWrap); outMatrix->mat = outputImage; // Return the output image - NanReturnValue(outMatrixWrap); + info.GetReturnValue().Set(outMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::initUndistortRectifyMap NAN_METHOD(ImgProc::InitUndistortRectifyMap) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Arg 0 is the camera matrix - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat K = m0->mat; // Arg 1 is the distortion coefficents - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat dist = m1->mat; // Arg 2 is the recification transformation - Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::Mat R = m2->mat; // Arg 3 is the new camera matrix - Matrix* m3 = ObjectWrap::Unwrap(args[3]->ToObject()); + Matrix* m3 = Nan::ObjectWrap::Unwrap(info[3]->ToObject()); cv::Mat newK = m3->mat; // Arg 4 is the image size cv::Size imageSize; - if (args[4]->IsArray()) { - Local v8sz = args[4]->ToObject(); + if (info[4]->IsArray()) { + Local v8sz = info[4]->ToObject(); imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); } else { JSTHROW_TYPE("Must pass image size"); } // Arg 5 is the first map type, skip for now - int m1type = args[5]->IntegerValue(); + int m1type = info[5]->IntegerValue(); // Make matrices to hold the output maps cv::Mat map1, map2; @@ -92,49 +92,49 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) { cv::initUndistortRectifyMap(K, dist, R, newK, imageSize, m1type, map1, map2); // Wrap the output maps - Local map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *map1Matrix = ObjectWrap::Unwrap(map1Wrap); + Local map1Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *map1Matrix = Nan::ObjectWrap::Unwrap(map1Wrap); map1Matrix->mat = map1; - Local map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *map2Matrix = ObjectWrap::Unwrap(map2Wrap); + Local map2Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *map2Matrix = Nan::ObjectWrap::Unwrap(map2Wrap); map2Matrix->mat = map2; // Make a return object with the two maps - Local ret = NanNew(); - ret->Set(NanNew("map1"), map1Wrap); - ret->Set(NanNew("map2"), map2Wrap); + Local ret = Nan::New(); + ret->Set(Nan::New("map1").ToLocalChecked(), map1Wrap); + ret->Set(Nan::New("map2").ToLocalChecked(), map2Wrap); // Return the maps - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::remap NAN_METHOD(ImgProc::Remap) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat inputImage = m0->mat; // Arg 1 is the first map - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat map1 = m1->mat; // Arg 2 is the second map - Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::Mat map2 = m2->mat; // Arg 3 is the interpolation mode - int interpolation = args[3]->IntegerValue(); + int interpolation = info[3]->IntegerValue(); // Args 4, 5 border settings, skipping for now @@ -145,15 +145,15 @@ NAN_METHOD(ImgProc::Remap) { cv::remap(inputImage, outputImage, map1, map2, interpolation); // Wrap the output image - Local outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *outMatrix = ObjectWrap::Unwrap(outMatrixWrap); + Local outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *outMatrix = Nan::ObjectWrap::Unwrap(outMatrixWrap); outMatrix->mat = outputImage; // Return the image - NanReturnValue(outMatrixWrap); + info.GetReturnValue().Set(outMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/ImgProc.h b/src/ImgProc.h index 8f7c504..a73220a 100644 --- a/src/ImgProc.h +++ b/src/ImgProc.h @@ -6,7 +6,7 @@ /** * Implementation of imgproc.hpp functions */ -class ImgProc: public node::ObjectWrap { +class ImgProc: public Nan::ObjectWrap { public: static void Init(Handle target); static NAN_METHOD(Undistort); diff --git a/src/Matrix.cc b/src/Matrix.cc old mode 100755 new mode 100644 index 3fec65b..83d1634 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -3,156 +3,156 @@ #include "OpenCV.h" #include -v8::Persistent Matrix::constructor; +Nan::Persistent Matrix::constructor; cv::Scalar setColor(Local objColor); cv::Point setPoint(Local objPoint); cv::Rect* setRect(Local objRect, cv::Rect &result); void Matrix::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; //Class - Local ctor = NanNew(Matrix::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(Matrix::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("Matrix")); + ctor->SetClassName(Nan::New("Matrix").ToLocalChecked()); // Prototype - 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()); }; NAN_METHOD(Matrix::New) { - 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"); } Matrix *mat; - if (args.Length() == 0) { + if (info.Length() == 0) { mat = new Matrix; - } 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(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(info[0]->ToObject()); + int x = info[1]->IntegerValue(); + int y = info[2]->IntegerValue(); + int w = info[3]->IntegerValue(); + int h = info[4]->IntegerValue(); mat = new Matrix(other->mat, cv::Rect(x, y, w, h)); } - mat->Wrap(args.Holder()); - NanReturnValue(args.Holder()); + mat->Wrap(info.Holder()); + info.GetReturnValue().Set(info.Holder()); } Matrix::Matrix() : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(); } Matrix::Matrix(int rows, int cols) : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(rows, cols, CV_32FC3); } Matrix::Matrix(int rows, int cols, int type) : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(rows, cols, type); } Matrix::Matrix(cv::Mat m, cv::Rect roi) : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(m, roi); } @@ -168,13 +168,13 @@ Matrix::Matrix(int rows, int cols, int type, Local scalarObj) { } else if (mat.channels() == 1) { mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue())); } else { - NanThrowError("Only 1-3 channels are supported"); + Nan::ThrowError("Only 1-3 channels are supported"); } } NAN_METHOD(Matrix::Empty) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.empty())); + info.GetReturnValue().Set(Nan::New(self->mat.empty())); } double Matrix::DblGet(cv::Mat mat, int i, int j) { @@ -205,13 +205,13 @@ double Matrix::DblGet(cv::Mat mat, int i, int j) { NAN_METHOD(Matrix::Pixel) { SETUP_FUNCTION(Matrix) - int y = args[0]->IntegerValue(); - int x = args[1]->IntegerValue(); + int y = info[0]->IntegerValue(); + int x = info[1]->IntegerValue(); // cv::Scalar scal = self->mat.at(y, x); - if (args.Length() == 3) { - Local < Object > objColor = args[2]->ToObject(); + if (info.Length() == 3) { + Local < Object > objColor = info[2]->ToObject(); if (self->mat.channels() == 3) { self->mat.at(y, x)[0] = @@ -223,48 +223,48 @@ NAN_METHOD(Matrix::Pixel) { } else if (self->mat.channels() == 1) self->mat.at(y, x) = (uchar) objColor->Get(0)->IntegerValue(); - NanReturnValue(args[2]->ToObject()); + info.GetReturnValue().Set(info[2]->ToObject()); } else { if (self->mat.channels() == 3) { cv::Vec3b intensity = self->mat.at(y, x); - v8::Local < v8::Array > arr = NanNew(3); - arr->Set(0, NanNew(intensity[0])); - arr->Set(1, NanNew(intensity[1])); - arr->Set(2, NanNew(intensity[2])); - NanReturnValue(arr); + v8::Local < v8::Array > arr = Nan::New(3); + arr->Set(0, Nan::New(intensity[0])); + arr->Set(1, Nan::New(intensity[1])); + arr->Set(2, Nan::New(intensity[2])); + info.GetReturnValue().Set(arr); } else if (self->mat.channels() == 1) { uchar intensity = self->mat.at(y, x); - NanReturnValue(NanNew(intensity)); + info.GetReturnValue().Set(Nan::New(intensity)); } } - NanReturnUndefined(); + return; // double val = Matrix::DblGet(t, i, j); - // NanReturnValue(NanNew(val)); + // info.GetReturnValue().Set(Nan::New(val)); } NAN_METHOD(Matrix::Get) { SETUP_FUNCTION(Matrix) - int i = args[0]->IntegerValue(); - int j = args[1]->IntegerValue(); + int i = info[0]->IntegerValue(); + int j = info[1]->IntegerValue(); double val = Matrix::DblGet(self->mat, i, j); - NanReturnValue(NanNew(val)); + info.GetReturnValue().Set(Nan::New(val)); } NAN_METHOD(Matrix::Set) { SETUP_FUNCTION(Matrix) - 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(); int vint = 0; - if (args.Length() == 4) { - self->mat.at(i, j)[args[3]->NumberValue()] = val; - } else if (args.Length() == 3) { + if (info.Length() == 4) { + self->mat.at(i, j)[info[3]->NumberValue()] = val; + } else if (info.Length() == 3) { switch (self->mat.type()) { case CV_32FC3: vint = static_cast(val + 0.5); @@ -278,10 +278,10 @@ NAN_METHOD(Matrix::Set) { } } else { - NanThrowTypeError("Invalid number of arguments"); + Nan::ThrowTypeError("Invalid number of arguments"); } - NanReturnUndefined(); + return; } // @author tualo @@ -290,39 +290,39 @@ NAN_METHOD(Matrix::Set) { NAN_METHOD(Matrix::Put) { SETUP_FUNCTION(Matrix) - 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]); memcpy(self->mat.data, buffer_data, buffer_length); - NanReturnUndefined(); + return; } // @author tualo // getData getting node buffer of image data NAN_METHOD(Matrix::GetData) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); int size = self->mat.rows * self->mat.cols * self->mat.elemSize1(); - Local buf = NanNewBufferHandle(size); + Local buf = Nan::NewBuffer(size).ToLocalChecked(); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, self->mat.data, size); - v8::Local globalObj = NanGetCurrentContext()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); - v8::Handle constructorArgs[3] = {buf, NanNew((unsigned) size), NanNew(0)}; + v8::Local globalObj = Nan::GetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); + v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned) size), Nan::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - NanReturnValue(actualBuffer); + info.GetReturnValue().Set(actualBuffer); } NAN_METHOD(Matrix::Brightness) { - NanScope(); - Matrix *self = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - if (args.Length() == 2) { + if (info.Length() == 2) { cv::Mat image; if (self->mat.channels() == 3) { @@ -331,12 +331,12 @@ NAN_METHOD(Matrix::Brightness) { cv::Mat myimg = self->mat; cv::cvtColor(myimg, image, CV_GRAY2RGB); } else { - NanThrowError("those channels are not supported"); + Nan::ThrowError("those channels are not supported"); } cv::Mat new_image = cv::Mat::zeros( image.size(), image.type() ); - double alpha = args[0]->NumberValue(); - int beta = args[1]->IntegerValue(); + double alpha = info[0]->NumberValue(); + int beta = info[1]->IntegerValue(); // Do the operation new_image(i,j) = alpha*image(i,j) + beta for (int y = 0; y < image.rows; y++ ) { @@ -356,56 +356,56 @@ NAN_METHOD(Matrix::Brightness) { gray.copyTo(self->mat); } } else { - if (args.Length() == 1) { - int diff = args[0]->IntegerValue(); + if (info.Length() == 1) { + int diff = info[0]->IntegerValue(); cv::Mat img = self->mat + diff; img.copyTo(self->mat); } else { - NanReturnValue(NanNew("Insufficient or wrong arguments")); + info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked()); } } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } // @author tualo // normalize wrapper NAN_METHOD(Matrix::Normalize) { - 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)"); } int type = cv::NORM_MINMAX; - if (args[2]->IsNumber()) { - type = args[2]->Uint32Value(); + if (info[2]->IsNumber()) { + type = info[2]->Uint32Value(); if ((type != cv::NORM_MINMAX) || (type != cv::NORM_INF) || (type != cv::NORM_L1) || (type != cv::NORM_L2) || (type != cv::NORM_L2SQR) || (type != cv::NORM_HAMMING) || (type != cv::NORM_HAMMING2) || (type != cv::NORM_RELATIVE) || (type != cv::NORM_TYPE_MASK)) { - 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," " NORM_L2SQR=5, NORM_HAMMING=6, NORM_HAMMING2=7, NORM_TYPE_MASK=7, " "NORM_RELATIVE=8, NORM_MINMAX=32 "); } } int dtype = -1; - 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(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); cv::Mat norm; cv::Mat mask; - if (args[4]->IsObject()) { - Matrix *mmask = ObjectWrap::Unwrap(args[4]->ToObject()); + if (info[4]->IsObject()) { + Matrix *mmask = Nan::ObjectWrap::Unwrap(info[4]->ToObject()); mask = mmask->mat; } @@ -413,52 +413,52 @@ NAN_METHOD(Matrix::Normalize) { norm.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Size) { SETUP_FUNCTION(Matrix) - v8::Local < v8::Array > arr = NanNew(2); - arr->Set(0, NanNew(self->mat.size().height)); - arr->Set(1, NanNew(self->mat.size().width)); + v8::Local < v8::Array > arr = Nan::New(2); + arr->Set(0, Nan::New(self->mat.size().height)); + arr->Set(1, Nan::New(self->mat.size().width)); - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Clone) { SETUP_FUNCTION(Matrix) Local < Object > im_h = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m = ObjectWrap::Unwrap(im_h); + Matrix *m = Nan::ObjectWrap::Unwrap(im_h); m->mat = self->mat.clone(); - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::Crop) { SETUP_FUNCTION(Matrix) - 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(); cv::Rect roi(x, y, width, height); Local < Object > im_h = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m = ObjectWrap::Unwrap(im_h); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m = Nan::ObjectWrap::Unwrap(im_h); m->mat = self->mat(roi); - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } else { - NanReturnValue(NanNew("Insufficient or wrong arguments")); + info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked()); } } @@ -466,89 +466,89 @@ NAN_METHOD(Matrix::Row) { SETUP_FUNCTION(Matrix) int width = self->mat.size().width; - int y = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(width); + int y = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(width); for (int x = 0; x < width; x++) { double v = Matrix::DblGet(self->mat, y, x); - arr->Set(x, NanNew(v)); + arr->Set(x, Nan::New(v)); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::PixelRow) { SETUP_FUNCTION(Matrix) int width = self->mat.size().width; - int y = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(width * 3); + int y = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(width * 3); for (int x = 0; x < width; x++) { cv::Vec3b pixel = self->mat.at(y, x); int offset = x * 3; - arr->Set(offset, NanNew((double) pixel.val[0])); - arr->Set(offset + 1, NanNew((double) pixel.val[1])); - arr->Set(offset + 2, NanNew((double) pixel.val[2])); + arr->Set(offset, Nan::New((double) pixel.val[0])); + arr->Set(offset + 1, Nan::New((double) pixel.val[1])); + arr->Set(offset + 2, Nan::New((double) pixel.val[2])); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Col) { SETUP_FUNCTION(Matrix) int height = self->mat.size().height; - int x = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(height); + int x = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(height); for (int y = 0; y < height; y++) { double v = Matrix::DblGet(self->mat, y, x); - arr->Set(y, NanNew(v)); + arr->Set(y, Nan::New(v)); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::PixelCol) { SETUP_FUNCTION(Matrix) int height = self->mat.size().height; - int x = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(height * 3); + int x = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(height * 3); for (int y = 0; y < height; y++) { cv::Vec3b pixel = self->mat.at(y, x); int offset = y * 3; - arr->Set(offset, NanNew((double) pixel.val[0])); - arr->Set(offset + 1, NanNew((double) pixel.val[1])); - arr->Set(offset + 2, NanNew((double) pixel.val[2])); + arr->Set(offset, Nan::New((double) pixel.val[0])); + arr->Set(offset + 1, Nan::New((double) pixel.val[1])); + arr->Set(offset + 2, Nan::New((double) pixel.val[2])); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Width) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.size().width)); + info.GetReturnValue().Set(Nan::New(self->mat.size().width)); } NAN_METHOD(Matrix::Height) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.size().height)); + info.GetReturnValue().Set(Nan::New(self->mat.size().height)); } NAN_METHOD(Matrix::Channels) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.channels())); + info.GetReturnValue().Set(Nan::New(self->mat.channels())); } NAN_METHOD(Matrix::ToBuffer) { SETUP_FUNCTION(Matrix) - if ((args.Length() > 0) && (args[0]->IsFunction())) { - return Matrix::ToBufferAsync(args); + if ((info.Length() > 0) && (info[0]->IsFunction())) { + return Matrix::ToBufferAsync(info); } // SergeMv changes @@ -564,25 +564,25 @@ NAN_METHOD(Matrix::ToBuffer) { std::vector params; // See if the options argument is passed - if ((args.Length() > 0) && (args[0]->IsObject())) { + if ((info.Length() > 0) && (info[0]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(args[0]); + v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); // If the extension (image format) is provided - if (options->Has(NanNew("ext"))) { + if (options->Has(Nan::New("ext").ToLocalChecked())) { v8::String::Utf8Value str( - options->Get(NanNew("ext"))->ToString()); + options->Get(Nan::New("ext").ToLocalChecked())->ToString()); optExt = *str; ext = (const char *) optExt.c_str(); } - if (options->Has(NanNew("jpegQuality"))) { + if (options->Has(Nan::New("jpegQuality").ToLocalChecked())) { int compression = - options->Get(NanNew("jpegQuality"))->IntegerValue(); + options->Get(Nan::New("jpegQuality").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(NanNew("pngCompression"))) { + if (options->Has(Nan::New("pngCompression").ToLocalChecked())) { int compression = - options->Get(NanNew("pngCompression"))->IntegerValue(); + options->Get(Nan::New("pngCompression").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } @@ -593,26 +593,26 @@ NAN_METHOD(Matrix::ToBuffer) { cv::imencode(ext, self->mat, vec, params); - Local < Object > buf = NanNewBufferHandle(vec.size()); + Local < Object > buf = Nan::NewBuffer(vec.size()).ToLocalChecked(); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, &vec[0], vec.size()); - v8::Local < v8::Object > globalObj = NanGetCurrentContext()->Global(); + v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global(); v8::Local < v8::Function > bufferConstructor = v8::Local < v8::Function - > ::Cast(globalObj->Get(NanNew("Buffer"))); + > ::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); v8::Handle constructorArgs[3] = - {buf, NanNew((unsigned)vec.size()), NanNew(0)}; + {buf, Nan::New((unsigned)vec.size()), Nan::New(0)}; v8::Local < v8::Object > actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - NanReturnValue(actualBuffer); + info.GetReturnValue().Set(actualBuffer); } -class AsyncToBufferWorker: public NanAsyncWorker { +class AsyncToBufferWorker: public Nan::AsyncWorker { public: - AsyncToBufferWorker(NanCallback *callback, Matrix* matrix, string ext, + AsyncToBufferWorker(Nan::Callback *callback, Matrix* matrix, string ext, vector params) : - NanAsyncWorker(callback), + Nan::AsyncWorker(callback), matrix(matrix), ext(ext), params(params) { @@ -629,19 +629,19 @@ public: } void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; - Local buf = NanNewBufferHandle(res.size()); + Local buf = Nan::NewBuffer(res.size()).ToLocalChecked(); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, &res[0], res.size()); - v8::Local globalObj = NanGetCurrentContext()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); - v8::Handle constructorArgs[3] = {buf, NanNew((unsigned)res.size()), NanNew(0)}; + v8::Local globalObj = Nan::GetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); + v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned)res.size()), Nan::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); Local argv[] = { - NanNull(), + Nan::Null(), actualBuffer }; @@ -669,34 +669,34 @@ NAN_METHOD(Matrix::ToBufferAsync) { std::vector params; // See if the options argument is passed - if ((args.Length() > 1) && (args[1]->IsObject())) { + if ((info.Length() > 1) && (info[1]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(args[1]); + v8::Handle < v8::Object > options = v8::Handle::Cast(info[1]); // If the extension (image format) is provided - if (options->Has(NanNew("ext"))) { + if (options->Has(Nan::New("ext").ToLocalChecked())) { v8::String::Utf8Value str( - options->Get(NanNew("ext"))->ToString()); + options->Get(Nan::New("ext").ToLocalChecked())->ToString()); std::string str2 = std::string(*str); ext = str2; } - if (options->Has(NanNew("jpegQuality"))) { + if (options->Has(Nan::New("jpegQuality").ToLocalChecked())) { int compression = - options->Get(NanNew("jpegQuality"))->IntegerValue(); + options->Get(Nan::New("jpegQuality").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(NanNew("pngCompression"))) { + if (options->Has(Nan::New("pngCompression").ToLocalChecked())) { int compression = - options->Get(NanNew("pngCompression"))->IntegerValue(); + options->Get(Nan::New("pngCompression").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } } - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Ellipse) { @@ -714,73 +714,73 @@ NAN_METHOD(Matrix::Ellipse) { int lineType = 8; int shift = 0; - if (args[0]->IsObject()) { - v8::Handle < v8::Object > options = v8::Handle::Cast(args[0]); - if (options->Has(NanNew("center"))) { + if (info[0]->IsObject()) { + v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); + if (options->Has(Nan::New("center").ToLocalChecked())) { Local < Object > center = - options->Get(NanNew("center"))->ToObject(); - x = center->Get(NanNew("x"))->Uint32Value(); - y = center->Get(NanNew("y"))->Uint32Value(); + options->Get(Nan::New("center").ToLocalChecked())->ToObject(); + x = center->Get(Nan::New("x").ToLocalChecked())->Uint32Value(); + y = center->Get(Nan::New("y").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("axes"))) { - Local < Object > axes = options->Get(NanNew("axes"))->ToObject(); - width = axes->Get(NanNew("width"))->Uint32Value(); - height = axes->Get(NanNew("height"))->Uint32Value(); + if (options->Has(Nan::New("axes").ToLocalChecked())) { + Local < Object > axes = options->Get(Nan::New("axes").ToLocalChecked())->ToObject(); + width = axes->Get(Nan::New("width").ToLocalChecked())->Uint32Value(); + height = axes->Get(Nan::New("height").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("thickness"))) { - thickness = options->Get(NanNew("thickness"))->Uint32Value(); + if (options->Has(Nan::New("thickness").ToLocalChecked())) { + thickness = options->Get(Nan::New("thickness").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("angle"))) { - angle = options->Get(NanNew("angle"))->NumberValue(); + if (options->Has(Nan::New("angle").ToLocalChecked())) { + angle = options->Get(Nan::New("angle").ToLocalChecked())->NumberValue(); } - if (options->Has(NanNew("startAngle"))) { - startAngle = options->Get(NanNew("startAngle"))->NumberValue(); + if (options->Has(Nan::New("startAngle").ToLocalChecked())) { + startAngle = options->Get(Nan::New("startAngle").ToLocalChecked())->NumberValue(); } - if (options->Has(NanNew("endAngle"))) { - endAngle = options->Get(NanNew("endAngle"))->NumberValue(); + if (options->Has(Nan::New("endAngle").ToLocalChecked())) { + endAngle = options->Get(Nan::New("endAngle").ToLocalChecked())->NumberValue(); } - if (options->Has(NanNew("lineType"))) { - lineType = options->Get(NanNew("lineType"))->Uint32Value(); + if (options->Has(Nan::New("lineType").ToLocalChecked())) { + lineType = options->Get(Nan::New("lineType").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("shift"))) { - shift = options->Get(NanNew("shift"))->Uint32Value(); + if (options->Has(Nan::New("shift").ToLocalChecked())) { + shift = options->Get(Nan::New("shift").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("color"))) { + if (options->Has(Nan::New("color").ToLocalChecked())) { Local < Object > objColor = - options->Get(NanNew("color"))->ToObject(); + options->Get(Nan::New("color").ToLocalChecked())->ToObject(); color = setColor(objColor); } } else { - 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(); color = setColor(objColor); } - if (args[5]->IntegerValue()) - thickness = args[5]->IntegerValue(); + if (info[5]->IntegerValue()) + thickness = info[5]->IntegerValue(); } cv::ellipse(self->mat, cv::Point(x, y), cv::Size(width, height), angle, startAngle, endAngle, color, thickness, lineType, shift); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Rectangle) { SETUP_FUNCTION(Matrix) - 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(); cv::Scalar color(0, 0, 255); - if (args[2]->IsArray()) { - Local < Object > objColor = args[2]->ToObject(); + if (info[2]->IsArray()) { + Local < Object > objColor = info[2]->ToObject(); color = setColor(objColor); } @@ -792,27 +792,27 @@ NAN_METHOD(Matrix::Rectangle) { int thickness = 1; - if (args[3]->IntegerValue()) - thickness = args[3]->IntegerValue(); + if (info[3]->IntegerValue()) + thickness = info[3]->IntegerValue(); cv::rectangle(self->mat, cv::Point(x, y), cv::Point(x + width, y + height), color, thickness); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Line) { SETUP_FUNCTION(Matrix) - 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(); cv::Scalar color(0, 0, 255); - if (args[2]->IsArray()) { - Local < Object > objColor = args[2]->ToObject(); + if (info[2]->IsArray()) { + Local < Object > objColor = info[2]->ToObject(); color = setColor(objColor); } @@ -824,20 +824,20 @@ NAN_METHOD(Matrix::Line) { int thickness = 1; - if (args[3]->IntegerValue()) - thickness = args[3]->IntegerValue(); + if (info[3]->IntegerValue()) + thickness = info[3]->IntegerValue(); cv::line(self->mat, cv::Point(x1, y1), cv::Point(x2, y2), color, thickness); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::FillPoly) { SETUP_FUNCTION(Matrix) - 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()); cv::Point **polygons = new cv::Point*[polyArray->Length()]; int *polySizes = new int[polyArray->Length()]; @@ -854,8 +854,8 @@ NAN_METHOD(Matrix::FillPoly) { } cv::Scalar color(0, 0, 255); - if (args[1]->IsArray()) { - Local objColor = args[1]->ToObject(); + if (info[1]->IsArray()) { + Local objColor = info[1]->ToObject(); color = setColor(objColor); } @@ -863,32 +863,32 @@ NAN_METHOD(Matrix::FillPoly) { polyArray->Length(), color); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Save) { SETUP_FUNCTION(Matrix) - 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]); int res = cv::imwrite(*filename, self->mat); - NanReturnValue(NanNew(res)); + info.GetReturnValue().Set(Nan::New(res)); } // All this is for async save, see here for nan example: // https://github.com/rvagg/nan/blob/c579ae858ae3208d7e702e8400042ba9d48fa64b/examples/async_pi_estimate/async.cc -class AsyncSaveWorker: public NanAsyncWorker { +class AsyncSaveWorker: public Nan::AsyncWorker { public: - AsyncSaveWorker(NanCallback *callback, Matrix* matrix, char* filename) : - NanAsyncWorker(callback), + AsyncSaveWorker(Nan::Callback *callback, Matrix* matrix, char* filename) : + Nan::AsyncWorker(callback), matrix(matrix), filename(filename) { } @@ -908,11 +908,11 @@ public: // this function will be run inside the main event loop // so it is safe to use V8 again void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; Local argv[] = { - NanNull(), - NanNew(res) + Nan::Null(), + Nan::New(res) }; TryCatch try_catch; @@ -931,71 +931,71 @@ private: NAN_METHOD(Matrix::SaveAsync) { SETUP_FUNCTION(Matrix) - if (!args[0]->IsString()) { - NanThrowTypeError("filename required"); + if (!info[0]->IsString()) { + Nan::ThrowTypeError("filename required"); } - NanAsciiString filename(args[0]); + Nan::Utf8String filename(info[0]); REQ_FUN_ARG(1, cb); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Zeros) { - 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 im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::zeros(w, h, type); img->mat = mat; - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::Ones) { - 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 im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::ones(w, h, type); img->mat = mat; - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::Eye) { - 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 im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::eye(w, h, type); img->mat = mat; - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::ConvertGrayscale) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); if (self->mat.channels() != 3) { - NanThrowError("Image is no 3-channel"); + Nan::ThrowError("Image is no 3-channel"); } cv::Mat gray; @@ -1003,15 +1003,15 @@ NAN_METHOD(Matrix::ConvertGrayscale) { cv::cvtColor(self->mat, gray, CV_BGR2GRAY); gray.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::ConvertHSVscale) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); if (self->mat.channels() != 3) { - NanThrowError("Image is no 3-channel"); + Nan::ThrowError("Image is no 3-channel"); } cv::Mat hsv; @@ -1019,29 +1019,29 @@ NAN_METHOD(Matrix::ConvertHSVscale) { cv::cvtColor(self->mat, hsv, CV_BGR2HSV); hsv.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::GaussianBlur) { - NanScope(); + Nan::HandleScope scope; cv::Size ksize; cv::Mat blurred; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - if (args.Length() < 1) { + if (info.Length() < 1) { ksize = cv::Size(5, 5); } else { - 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 array = args[0]->ToObject(); + Local array = info[0]->ToObject(); // TODO: Length check Local x = array->Get(0); Local y = array->Get(1); if (!x->IsNumber() || !y->IsNumber()) { - NanThrowTypeError("'ksize' argument must be a 2 double array"); + Nan::ThrowTypeError("'ksize' argument must be a 2 double array"); } ksize = cv::Size(x->NumberValue(), y->NumberValue()); } @@ -1049,49 +1049,49 @@ NAN_METHOD(Matrix::GaussianBlur) { cv::GaussianBlur(self->mat, blurred, ksize, 0); blurred.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::MedianBlur) { - NanScope(); + Nan::HandleScope scope; cv::Mat blurred; int ksize = 3; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - if (args[0]->IsNumber()) { - ksize = args[0]->IntegerValue(); + if (info[0]->IsNumber()) { + ksize = info[0]->IntegerValue(); if ((ksize % 2) == 0) { - NanThrowTypeError("'ksize' argument must be a positive odd integer"); + Nan::ThrowTypeError("'ksize' argument must be a positive odd integer"); } } else { - NanThrowTypeError("'ksize' argument must be a positive odd integer"); + Nan::ThrowTypeError("'ksize' argument must be a positive odd integer"); } cv::medianBlur(self->mat, blurred, ksize); blurred.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BilateralFilter) { - NanScope(); + Nan::HandleScope scope; cv::Mat filtered; int d = 15; double sigmaColor = 80; double sigmaSpace = 80; int borderType = cv::BORDER_DEFAULT; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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"); } else { - 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(); } } } @@ -1099,276 +1099,276 @@ NAN_METHOD(Matrix::BilateralFilter) { cv::bilateralFilter(self->mat, filtered, d, sigmaColor, sigmaSpace, borderType); filtered.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Copy) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); Local img_to_return = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::Flip) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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 " "(0 = X axis, positive = Y axis, negative = both axis)"); } - int flipCode = args[0]->ToInt32()->Value(); + int flipCode = info[0]->ToInt32()->Value(); - Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Local img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); cv::flip(self->mat, img->mat, flipCode); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::ROI) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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"); } // Although it's an image to return, it is in fact a pointer to ROI of parent matrix - Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Local img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(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(); cv::Mat roi(self->mat, cv::Rect(x,y,w,h)); img->mat = roi; - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::Ptr) { - NanScope(); - Matrix *self = ObjectWrap::Unwrap(args.This()); - int line = args[0]->Uint32Value(); + Nan::HandleScope scope; + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int line = info[0]->Uint32Value(); char* data = self->mat.ptr(line); // uchar* data = self->mat.data; // char *mydata = "Random raw data\0"; - Local return_buffer = NanNewBufferHandle((char*)data, self->mat.step); - NanReturnValue( return_buffer ); -// NanReturnUndefined(); + Local return_buffer = Nan::NewBuffer((char*)data, self->mat.step).ToLocalChecked(); + info.GetReturnValue().Set( return_buffer ); +// return; } NAN_METHOD(Matrix::AbsDiff) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::absdiff(src1->mat, src2->mat, self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::AddWeighted) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); - float alpha = args[1]->NumberValue(); - float beta = args[3]->NumberValue(); + float alpha = info[1]->NumberValue(); + float beta = info[3]->NumberValue(); int gamma = 0; try { cv::addWeighted(src1->mat, alpha, src2->mat, beta, gamma, self->mat); } catch(cv::Exception& e ) { const char* err_msg = e.what(); - NanThrowError(err_msg); + Nan::ThrowError(err_msg); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BitwiseXor) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); - if (args.Length() == 3) { - Matrix *mask = ObjectWrap::Unwrap(args[2]->ToObject()); + if (info.Length() == 3) { + Matrix *mask = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::bitwise_xor(src1->mat, src2->mat, self->mat, mask->mat); } else { cv::bitwise_xor(src1->mat, src2->mat, self->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BitwiseNot) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *dst = ObjectWrap::Unwrap(args[0]->ToObject()); - if (args.Length() == 2) { - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *dst = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + if (info.Length() == 2) { + Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::bitwise_not(self->mat, dst->mat, mask->mat); } else { cv::bitwise_not(self->mat, dst->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BitwiseAnd) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); - if (args.Length() == 3) { - Matrix *mask = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + if (info.Length() == 3) { + Matrix *mask = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::bitwise_and(src1->mat, src2->mat, self->mat, mask->mat); } else { cv::bitwise_and(src1->mat, src2->mat, self->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::CountNonZero) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); double count = (double)cv::countNonZero(self->mat); - NanReturnValue(NanNew(count)); + info.GetReturnValue().Set(Nan::New(count)); } /* NAN_METHOD(Matrix::Split) { - NanScope(); + Nan::HandleScope scope; - //Matrix *self = ObjectWrap::Unwrap(args.This()); + //Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } */ NAN_METHOD(Matrix::Canny) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - int lowThresh = args[0]->NumberValue(); - int highThresh = args[1]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int lowThresh = info[0]->NumberValue(); + int highThresh = info[1]->NumberValue(); cv::Canny(self->mat, self->mat, lowThresh, highThresh); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Dilate) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - int niters = args[0]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int niters = info[0]->NumberValue(); cv::dilate(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Erode) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - int niters = args[0]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int niters = info[0]->NumberValue(); cv::erode(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::FindContours) { - NanScope(); + Nan::HandleScope scope; int mode = CV_RETR_LIST; int chain = CV_CHAIN_APPROX_SIMPLE; - 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(args.This()); - Local conts_to_return= NanNew(Contour::constructor)->GetFunction()->NewInstance(); - Contour *contours = ObjectWrap::Unwrap(conts_to_return); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Local conts_to_return= Nan::New(Contour::constructor)->GetFunction()->NewInstance(); + Contour *contours = Nan::ObjectWrap::Unwrap(conts_to_return); cv::findContours(self->mat, contours->contours, contours->hierarchy, mode, chain); - NanReturnValue(conts_to_return); + info.GetReturnValue().Set(conts_to_return); } NAN_METHOD(Matrix::DrawContour) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); - int pos = args[1]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *cont = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + int pos = info[1]->NumberValue(); cv::Scalar color(0, 0, 255); - if (args[2]->IsArray()) { - Local objColor = args[2]->ToObject(); + if (info[2]->IsArray()) { + Local objColor = info[2]->ToObject(); color = setColor(objColor); } - int thickness = args.Length() < 4 ? 1 : args[3]->NumberValue(); + int thickness = info.Length() < 4 ? 1 : info[3]->NumberValue(); cv::drawContours(self->mat, cont->contours, pos, color, thickness); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::DrawAllContours) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *cont = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Scalar color(0, 0, 255); - if (args[1]->IsArray()) { - Local objColor = args[1]->ToObject(); + if (info[1]->IsArray()) { + Local objColor = info[1]->ToObject(); color = setColor(objColor); } - int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue(); + int thickness = info.Length() < 3 ? 1 : info[2]->NumberValue(); cv::drawContours(self->mat, cont->contours, -1, color, thickness); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::GoodFeaturesToTrack) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); std::vector corners; cv::Mat gray; @@ -1376,27 +1376,27 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) { equalizeHist(gray, gray); cv::goodFeaturesToTrack(gray, corners, 500, 0.01, 10); - v8::Local arr = NanNew(corners.size()); + v8::Local arr = Nan::New(corners.size()); for (unsigned int i=0; i pt = NanNew(2); - pt->Set(0, NanNew((double) corners[i].x)); - pt->Set(1, NanNew((double) corners[i].y)); + v8::Local pt = Nan::New(2); + pt->Set(0, Nan::New((double) corners[i].x)); + pt->Set(1, Nan::New((double) corners[i].y)); arr->Set(i, pt); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::HoughLinesP) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(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(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(); std::vector lines; cv::Mat gray; @@ -1405,31 +1405,31 @@ NAN_METHOD(Matrix::HoughLinesP) { // cv::Canny(gray, gray, 50, 200, 3); cv::HoughLinesP(gray, lines, rho, theta, threshold, minLineLength, maxLineGap); - v8::Local arr = NanNew(lines.size()); + v8::Local arr = Nan::New(lines.size()); for (unsigned int i=0; i pt = NanNew(4); - pt->Set(0, NanNew((double) lines[i][0])); - pt->Set(1, NanNew((double) lines[i][1])); - pt->Set(2, NanNew((double) lines[i][2])); - pt->Set(3, NanNew((double) lines[i][3])); + v8::Local pt = Nan::New(4); + pt->Set(0, Nan::New((double) lines[i][0])); + pt->Set(1, Nan::New((double) lines[i][1])); + pt->Set(2, Nan::New((double) lines[i][2])); + pt->Set(3, Nan::New((double) lines[i][3])); arr->Set(i, pt); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::HoughCircles) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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(); std::vector circles; cv::Mat gray; @@ -1439,17 +1439,17 @@ NAN_METHOD(Matrix::HoughCircles) { cv::HoughCircles(gray, circles, CV_HOUGH_GRADIENT, dp, minDist, higherThreshold, accumulatorThreshold, minRadius, maxRadius); - v8::Local arr = NanNew(circles.size()); + v8::Local arr = Nan::New(circles.size()); for (unsigned int i=0; i < circles.size(); i++) { - v8::Local pt = NanNew(3); - pt->Set(0, NanNew((double) circles[i][0])); // center x - pt->Set(1, NanNew((double) circles[i][1]));// center y - pt->Set(2, NanNew((double) circles[i][2]));// radius + v8::Local pt = Nan::New(3); + pt->Set(0, Nan::New((double) circles[i][0])); // center x + pt->Set(1, Nan::New((double) circles[i][1]));// center y + pt->Set(2, Nan::New((double) circles[i][2]));// radius arr->Set(i, pt); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } cv::Scalar setColor(Local objColor) { @@ -1486,10 +1486,10 @@ cv::Rect* setRect(Local objRect, cv::Rect &result) { } NAN_METHOD(Matrix::Resize) { - NanScope(); + Nan::HandleScope scope; - int x = args[0]->Uint32Value(); - int y = args[1]->Uint32Value(); + int x = info[0]->Uint32Value(); + int y = info[1]->Uint32Value(); /* CV_INTER_NN =0, CV_INTER_LINEAR =1, @@ -1497,35 +1497,35 @@ NAN_METHOD(Matrix::Resize) { CV_INTER_AREA =3, CV_INTER_LANCZOS4 =4 */ - 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(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); cv::Mat res = cv::Mat(x, y, CV_32FC3); cv::resize(self->mat, res, cv::Size(x, y), 0, 0, interpolation); ~self->mat; self->mat = res; - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Rotate) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); cv::Mat rotMatrix(2, 3, CV_32FC1); cv::Mat res; - float angle = args[0]->ToNumber()->Value(); + float angle = info[0]->ToNumber()->Value(); // Modification by SergeMv //------------- // If you provide only the angle argument and the angle is multiple of 90, then // we do a fast thing bool rightOrStraight = (ceil(angle) == angle) && (!((int)angle % 90)) - && (args.Length() == 1); + && (info.Length() == 1); if (rightOrStraight) { int angle2 = ((int)angle) % 360; - if (!angle2) {NanReturnUndefined();} + if (!angle2) {return;} if (angle2 < 0) {angle2 += 360;} // See if we do right angle rotation, we transpose the matrix: if (angle2 % 180) { @@ -1540,14 +1540,14 @@ NAN_METHOD(Matrix::Rotate) { // If clockwise, flip around the y-axis if (angle2 == 270) {mode = 1;} cv::flip(self->mat, self->mat, mode); - 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(); cv::Point center = cv::Point(x,y); rotMatrix = getRotationMatrix2D(center, angle, 1.0); @@ -1556,33 +1556,33 @@ NAN_METHOD(Matrix::Rotate) { ~self->mat; self->mat = res; - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::PyrDown) { SETUP_FUNCTION(Matrix) cv::pyrDown(self->mat, self->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::PyrUp) { SETUP_FUNCTION(Matrix) cv::pyrUp(self->mat, self->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::inRange) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); /*if (self->mat.channels() != 3) - 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 args_lowerb = args[0]->ToObject(); - Local args_upperb = args[1]->ToObject(); + if (info[0]->IsArray() && info[1]->IsArray()) { + Local args_lowerb = info[0]->ToObject(); + Local args_upperb = info[1]->ToObject(); cv::Scalar lowerb(0, 0, 0); cv::Scalar upperb(0, 0, 0); @@ -1595,19 +1595,19 @@ NAN_METHOD(Matrix::inRange) { mask.copyTo(self->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::AdjustROI) { SETUP_FUNCTION(Matrix) - 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(); self->mat.adjustROI(dtop, dbottom, dleft, dright); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::LocateROI) { @@ -1618,25 +1618,25 @@ NAN_METHOD(Matrix::LocateROI) { self->mat.locateROI(wholeSize, ofs); - v8::Local < v8::Array > arr = NanNew(4); - arr->Set(0, NanNew(wholeSize.width)); - arr->Set(1, NanNew(wholeSize.height)); - arr->Set(2, NanNew(ofs.x)); - arr->Set(3, NanNew(ofs.y)); + v8::Local < v8::Array > arr = Nan::New(4); + arr->Set(0, Nan::New(wholeSize.width)); + arr->Set(1, Nan::New(wholeSize.height)); + arr->Set(2, Nan::New(ofs.x)); + arr->Set(3, Nan::New(ofs.y)); - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Threshold) { SETUP_FUNCTION(Matrix) - double threshold = args[0]->NumberValue(); - double maxVal = args[1]->NumberValue(); + double threshold = info[0]->NumberValue(); + double maxVal = info[1]->NumberValue(); int typ = cv::THRESH_BINARY; - 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]); if (strcmp(*typstr, "Binary") == 0) { typ = 0; } @@ -1655,52 +1655,52 @@ NAN_METHOD(Matrix::Threshold) { } Local < Object > img_to_return = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); cv::threshold(self->mat, img->mat, threshold, maxVal, typ); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::AdaptiveThreshold) { SETUP_FUNCTION(Matrix) - 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(); Local < Object > img_to_return = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::MeanStdDev) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Local mean = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_mean = ObjectWrap::Unwrap(mean); - Local stddev = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_stddev = ObjectWrap::Unwrap(stddev); + Local mean = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_mean = Nan::ObjectWrap::Unwrap(mean); + Local stddev = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_stddev = Nan::ObjectWrap::Unwrap(stddev); cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat); - Local data = NanNew(); - data->Set(NanNew("mean"), mean); - data->Set(NanNew("stddev"), stddev); + Local data = Nan::New(); + data->Set(Nan::New("mean").ToLocalChecked(), mean); + data->Set(Nan::New("stddev").ToLocalChecked(), stddev); - NanReturnValue(data); + info.GetReturnValue().Set(data); } // @author SergeMv @@ -1713,34 +1713,34 @@ NAN_METHOD(Matrix::MeanStdDev) { // our.width + x <= destination.width (and the same for y and height) // both x and y must be >= 0 NAN_METHOD(Matrix::CopyTo) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); int width = self->mat.size().width; int height = self->mat.size().height; // param 0 - destination image: - Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *dest = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); // param 1 - x coord of the destination - int x = args[1]->IntegerValue(); + int x = info[1]->IntegerValue(); // param 2 - y coord of the destination - int y = args[2]->IntegerValue(); + int y = info[2]->IntegerValue(); cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height)); self->mat.copyTo(dstROI); - NanReturnUndefined(); + return; } // @author SergeMv // Does in-place color transformation // img.cvtColor('CV_BGR2YCrCb'); NAN_METHOD(Matrix::CvtColor) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); - v8::String::Utf8Value str (args[0]->ToString()); + v8::String::Utf8Value str (info[0]->ToString()); std::string str2 = std::string(*str); const char * sTransform = (const char *) str2.c_str(); int iTransform; @@ -1772,20 +1772,20 @@ NAN_METHOD(Matrix::CvtColor) { else if (!strcmp(sTransform, "CV_BayerGR2BGR")) {iTransform = CV_BayerGR2BGR;} else { iTransform = 0; // to avoid compiler warning - NanThrowTypeError("Conversion code is unsupported"); + Nan::ThrowTypeError("Conversion code is unsupported"); } cv::cvtColor(self->mat, self->mat, iTransform); - NanReturnUndefined(); + return; } // @author SergeMv // arrChannels = img.split(); NAN_METHOD(Matrix::Split) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); unsigned int size = self->mat.channels(); vector channels; @@ -1797,55 +1797,55 @@ NAN_METHOD(Matrix::Split) { cv::split(self->mat, channels); size = channels.size(); - v8::Local arrChannels = NanNew(size); + v8::Local arrChannels = Nan::New(size); for (unsigned int i = 0; i < size; i++) { Local matObject = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix * m = ObjectWrap::Unwrap(matObject); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix * m = Nan::ObjectWrap::Unwrap(matObject); m->mat = channels[i]; arrChannels->Set(i, matObject); } - NanReturnValue(arrChannels); + info.GetReturnValue().Set(arrChannels); } // @author SergeMv // img.merge(arrChannels); NAN_METHOD(Matrix::Merge) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); - if (!args[0]->IsArray()) { - NanThrowTypeError("The argument must be an array"); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); + if (!info[0]->IsArray()) { + Nan::ThrowTypeError("The argument must be an array"); } - v8::Handle jsChannels = v8::Handle::Cast(args[0]); + v8::Handle jsChannels = v8::Handle::Cast(info[0]); unsigned int L = jsChannels->Length(); vector vChannels(L); for (unsigned int i = 0; i < L; i++) { - Matrix * matObject = ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); + Matrix * matObject = Nan::ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); vChannels[i] = matObject->mat; } cv::merge(vChannels, self->mat); - NanReturnUndefined(); + return; } // @author SergeMv // Equalizes histogram // img.equalizeHist() NAN_METHOD(Matrix::EqualizeHist) { - NanScope(); - Matrix * self = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); cv::equalizeHist(self->mat, self->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::FloodFill) { SETUP_FUNCTION(Matrix) - // obj->Get(NanNew("x")) + // obj->Get(Nan::New("x").ToLocalChecked()) // int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int) /* mat.floodFill( {seedPoint: [1,1] , @@ -1855,22 +1855,22 @@ NAN_METHOD(Matrix::FloodFill) { upDiff:[10,100,70] }); */ - if (args.Length() < 1 || !args[0]->IsObject()) { + if (info.Length() < 1 || !info[0]->IsObject()) { // error } - Local < Object > obj = args[0]->ToObject(); + Local < Object > obj = info[0]->ToObject(); cv::Rect rect; int ret = cv::floodFill(self->mat, - setPoint(obj->Get(NanNew("seedPoint"))->ToObject()), - setColor(obj->Get(NanNew("newColor"))->ToObject()), - obj->Get(NanNew("rect"))->IsUndefined() ? - 0 : setRect(obj->Get(NanNew("rect"))->ToObject(), rect), - setColor(obj->Get(NanNew("loDiff"))->ToObject()), - setColor(obj->Get(NanNew("upDiff"))->ToObject()), 4); + setPoint(obj->Get(Nan::New("seedPoint").ToLocalChecked())->ToObject()), + setColor(obj->Get(Nan::New("newColor").ToLocalChecked())->ToObject()), + obj->Get(Nan::New("rect").ToLocalChecked())->IsUndefined() ? + 0 : setRect(obj->Get(Nan::New("rect").ToLocalChecked())->ToObject(), rect), + setColor(obj->Get(Nan::New("loDiff").ToLocalChecked())->ToObject()), + setColor(obj->Get(Nan::New("upDiff").ToLocalChecked())->ToObject()), 4); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } // @author olfox @@ -1880,15 +1880,15 @@ NAN_METHOD(Matrix::TemplateMatches) { SETUP_FUNCTION(Matrix) bool filter_min_probability = - (args.Length() >= 1) ? args[0]->IsNumber() : false; + (info.Length() >= 1) ? info[0]->IsNumber() : false; bool filter_max_probability = - (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; cv::Mat_ indices; @@ -1901,7 +1901,7 @@ NAN_METHOD(Matrix::TemplateMatches) { } cv::Mat hit_mask = cv::Mat::zeros(self->mat.size(), CV_64F); - v8::Local < v8::Array > probabilites_array = NanNew(limit); + v8::Local < v8::Array > probabilites_array = Nan::New(limit); cv::Mat_::const_iterator begin = self->mat.begin(); cv::Mat_::const_iterator it = indices.begin(); @@ -1955,37 +1955,37 @@ NAN_METHOD(Matrix::TemplateMatches) { cv::rectangle(hit_mask, top_left, bottom_right, color, CV_FILLED); } - Local x_value = NanNew(pt.x); - Local y_value = NanNew(pt.y); - Local probability_value = NanNew(probability); + Local x_value = Nan::New(pt.x); + Local y_value = Nan::New(pt.y); + Local probability_value = Nan::New(probability); - Local < Object > probability_object = NanNew(); - probability_object->Set(NanNew("x"), x_value); - probability_object->Set(NanNew("y"), y_value); - probability_object->Set(NanNew("probability"), probability_value); + Local < Object > probability_object = Nan::New(); + probability_object->Set(Nan::New("x").ToLocalChecked(), x_value); + probability_object->Set(Nan::New("y").ToLocalChecked(), y_value); + probability_object->Set(Nan::New("probability").ToLocalChecked(), probability_value); probabilites_array->Set(index, probability_object); index++; } - NanReturnValue(probabilites_array); + info.GetReturnValue().Set(probabilites_array); } // @author ytham // Match Template filter // Usage: output = input.matchTemplate("templateFileString", method); NAN_METHOD(Matrix::MatchTemplate) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - v8::String::Utf8Value args0(args[0]->ToString()); + v8::String::Utf8Value args0(info[0]->ToString()); std::string filename = std::string(*args0); cv::Mat templ; templ = cv::imread(filename, CV_8S); - Local out = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_out = ObjectWrap::Unwrap(out); + Local out = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_out = Nan::ObjectWrap::Unwrap(out); int cols = self->mat.cols - templ.cols + 1; int rows = self->mat.rows - templ.rows + 1; m_out->mat.create(cols, rows, CV_32FC1); @@ -1999,70 +1999,70 @@ NAN_METHOD(Matrix::MatchTemplate) { TM_CCOEFF_NORMED =5 */ - 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(); cv::matchTemplate(self->mat, templ, m_out->mat, method); - NanReturnValue(out); + info.GetReturnValue().Set(out); } // @author ytham // Min/Max location NAN_METHOD(Matrix::MinMaxLoc) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; cv::minMaxLoc(self->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); - Local v_minVal = NanNew(minVal); - Local v_maxVal = NanNew(maxVal); - Local v_minLoc_x = NanNew(minLoc.x); - Local v_minLoc_y = NanNew(minLoc.y); - Local v_maxLoc_x = NanNew(maxLoc.x); - Local v_maxLoc_y = NanNew(maxLoc.y); + Local v_minVal = Nan::New(minVal); + Local v_maxVal = Nan::New(maxVal); + Local v_minLoc_x = Nan::New(minLoc.x); + Local v_minLoc_y = Nan::New(minLoc.y); + Local v_maxLoc_x = Nan::New(maxLoc.x); + Local v_maxLoc_y = Nan::New(maxLoc.y); - Local o_minLoc = NanNew(); - o_minLoc->Set(NanNew("x"), v_minLoc_x); - o_minLoc->Set(NanNew("y"), v_minLoc_y); + Local o_minLoc = Nan::New(); + o_minLoc->Set(Nan::New("x").ToLocalChecked(), v_minLoc_x); + o_minLoc->Set(Nan::New("y").ToLocalChecked(), v_minLoc_y); - Local o_maxLoc = NanNew(); - o_maxLoc->Set(NanNew("x"), v_maxLoc_x); - o_maxLoc->Set(NanNew("y"), v_maxLoc_y); + Local o_maxLoc = Nan::New(); + o_maxLoc->Set(Nan::New("x").ToLocalChecked(), v_maxLoc_x); + o_maxLoc->Set(Nan::New("y").ToLocalChecked(), v_maxLoc_y); // Output result object - Local result = NanNew(); - result->Set(NanNew("minVal"), v_minVal); - result->Set(NanNew("maxVal"), v_maxVal); - result->Set(NanNew("minLoc"), o_minLoc); - result->Set(NanNew("maxLoc"), o_maxLoc); + Local result = Nan::New(); + result->Set(Nan::New("minVal").ToLocalChecked(), v_minVal); + result->Set(Nan::New("maxVal").ToLocalChecked(), v_maxVal); + result->Set(Nan::New("minLoc").ToLocalChecked(), o_minLoc); + result->Set(Nan::New("maxLoc").ToLocalChecked(), o_maxLoc); - NanReturnValue(result); + info.GetReturnValue().Set(result); } // @author ytham // Pushes some matrix (argument) the back of a matrix (self) NAN_METHOD(Matrix::PushBack) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *m_input = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *m_input = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); self->mat.push_back(m_input->mat); - NanReturnValue(args.This()); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(Matrix::PutText) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - NanAsciiString textString(args[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Nan::Utf8String textString(info[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 char *text = *textString;//(char *) malloc(textString.length() + 1); //strcpy(text, *textString); - 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]); char *font = *fontString;//(char *) malloc(fontString.length() + 1); //strcpy(font, *fontString); int constFont = cv::FONT_HERSHEY_SIMPLEX; @@ -2079,25 +2079,25 @@ NAN_METHOD(Matrix::PutText) { cv::Scalar color(0, 0, 255); - if (args[4]->IsArray()) { - Local objColor = args[4]->ToObject(); + if (info[4]->IsArray()) { + Local objColor = info[4]->ToObject(); color = setColor(objColor); } - 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(); cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, thickness); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::GetPerspectiveTransform) { - NanScope(); + Nan::HandleScope scope; // extract quad args - Local srcArray = args[0]->ToObject(); - Local tgtArray = args[1]->ToObject(); + Local srcArray = info[0]->ToObject(); + Local tgtArray = info[1]->ToObject(); std::vector src_corners(4); std::vector tgt_corners(4); @@ -2106,28 +2106,28 @@ NAN_METHOD(Matrix::GetPerspectiveTransform) { tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue(),tgtArray->Get(i*2+1)->IntegerValue()); } - Local xfrm = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *xfrmmat = ObjectWrap::Unwrap(xfrm); + Local xfrm = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *xfrmmat = Nan::ObjectWrap::Unwrap(xfrm); xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners); - NanReturnValue(xfrm); + info.GetReturnValue().Set(xfrm); } NAN_METHOD(Matrix::WarpPerspective) { SETUP_FUNCTION(Matrix) - Matrix *xfrm = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *xfrm = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - int width = args[1]->IntegerValue(); - int height = args[2]->IntegerValue(); + int width = info[1]->IntegerValue(); + int height = info[2]->IntegerValue(); int flags = cv::INTER_LINEAR; int borderMode = cv::BORDER_REPLICATE; cv::Scalar borderColor(0, 0, 255); - if (args[3]->IsArray()) { - Local < Object > objColor = args[3]->ToObject(); + if (info[3]->IsArray()) { + Local < Object > objColor = info[3]->ToObject(); borderColor = setColor(objColor); } @@ -2139,53 +2139,53 @@ NAN_METHOD(Matrix::WarpPerspective) { ~self->mat; self->mat = res; - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::CopyWithMask) { SETUP_FUNCTION(Matrix) // param 0 - destination image: - Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *dest = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); // param 1 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); self->mat.copyTo(dest->mat, mask->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::SetWithMask) { SETUP_FUNCTION(Matrix) // param 0 - target value: - Local < Object > valArray = args[0]->ToObject(); + Local < Object > valArray = info[0]->ToObject(); cv::Scalar newvals; newvals.val[0] = valArray->Get(0)->NumberValue(); newvals.val[1] = valArray->Get(1)->NumberValue(); newvals.val[2] = valArray->Get(2)->NumberValue(); // param 1 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); self->mat.setTo(newvals, mask->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::MeanWithMask) { SETUP_FUNCTION(Matrix) // param 0 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *mask = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Scalar means = cv::mean(self->mat, mask->mat); - v8::Local < v8::Array > arr = NanNew(3); - arr->Set(0, NanNew(means[0])); - arr->Set(1, NanNew(means[1])); - arr->Set(2, NanNew(means[2])); + v8::Local < v8::Array > arr = Nan::New(3); + arr->Set(0, Nan::New(means[0])); + arr->Set(1, Nan::New(means[1])); + arr->Set(2, Nan::New(means[2])); - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Shift) { @@ -2193,8 +2193,8 @@ NAN_METHOD(Matrix::Shift) { cv::Mat res; - 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 cv::Point2i deltai(ceil(tx), ceil(ty)); @@ -2227,14 +2227,14 @@ NAN_METHOD(Matrix::Shift) { ~self->mat; self->mat = res; - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Release) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); self->mat.release(); - NanReturnUndefined(); + return; } diff --git a/src/Matrix.h b/src/Matrix.h old mode 100755 new mode 100644 index 0367f3b..3c87b38 --- a/src/Matrix.h +++ b/src/Matrix.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class Matrix: public node::ObjectWrap { +class Matrix: public Nan::ObjectWrap { public: cv::Mat mat; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); Matrix(); @@ -119,34 +119,34 @@ public: JSFUNC(Release) /* - static Handle Val(const Arguments& args); - static Handle RowRange(const Arguments& args); - static Handle ColRange(const Arguments& args); - static Handle Diag(const Arguments& args); - static Handle Clone(const Arguments& args); - static Handle CopyTo(const Arguments& args); - static Handle ConvertTo(const Arguments& args); - static Handle AssignTo(const Arguments& args); - static Handle SetTo(const Arguments& args); - static Handle Reshape(const Arguments& args); - static Handle Transpose(const Arguments& args); - static Handle Invert(const Arguments& args); - static Handle Multiply(const Arguments& args); - static Handle Cross(const Arguments& args); - static Handle Dot(const Arguments& args); - static Handle Zeroes(const Arguments& args); - static Handle Ones(const Arguments& args); + static Handle Val(const Arguments& info); + static Handle RowRange(const Arguments& info); + static Handle ColRange(const Arguments& info); + static Handle Diag(const Arguments& info); + static Handle Clone(const Arguments& info); + static Handle CopyTo(const Arguments& info); + static Handle ConvertTo(const Arguments& info); + static Handle AssignTo(const Arguments& info); + static Handle SetTo(const Arguments& info); + static Handle Reshape(const Arguments& info); + static Handle Transpose(const Arguments& info); + static Handle Invert(const Arguments& info); + static Handle Multiply(const Arguments& info); + static Handle Cross(const Arguments& info); + static Handle Dot(const Arguments& info); + static Handle Zeroes(const Arguments& info); + static Handle Ones(const Arguments& info); // create, increment, release - static Handle PushBack(const Arguments& args); - static Handle PopBack(const Arguments& args); - static Handle Total(const Arguments& args); - static Handle IsContinous(const Arguments& args); - static Handle Type(const Arguments& args); - static Handle Depth(const Arguments& args); - static Handle Channels(const Arguments& args); - static Handle StepOne(const Arguments& args); - static Handle GetPerspectiveTransform(const Arguments& args); - static Handle WarpPerspective(const Arguments& args); + static Handle PushBack(const Arguments& info); + static Handle PopBack(const Arguments& info); + static Handle Total(const Arguments& info); + static Handle IsContinous(const Arguments& info); + static Handle Type(const Arguments& info); + static Handle Depth(const Arguments& info); + static Handle Channels(const Arguments& info); + static Handle StepOne(const Arguments& info); + static Handle GetPerspectiveTransform(const Arguments& info); + static Handle WarpPerspective(const Arguments& info); */ }; diff --git a/src/OpenCV.cc b/src/OpenCV.cc old mode 100755 new mode 100644 index 949cec1..8365138 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -3,66 +3,66 @@ #include void OpenCV::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Version string. char out [21]; int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION); - target->Set(NanNew("version"), NanNew(out, n)); + target->Set(Nan::New("version").ToLocalChecked(), Nan::New(out, n).ToLocalChecked()); - NODE_SET_METHOD(target, "readImage", ReadImage); + Nan::SetMethod(target, "readImage", ReadImage); } NAN_METHOD(OpenCV::ReadImage) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; REQ_FUN_ARG(1, cb); Local argv[2]; - argv[0] = NanNull(); + argv[0] = Nan::Null(); - Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); argv[1] = im_h; try { cv::Mat mat; - if (args[0]->IsNumber() && args[1]->IsNumber()) { + if (info[0]->IsNumber() && info[1]->IsNumber()) { int width, height; - width = args[0]->Uint32Value(); - height = args[1]->Uint32Value(); + width = info[0]->Uint32Value(); + height = info[1]->Uint32Value(); mat = *(new cv::Mat(width, height, CV_64FC1)); - } 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())); mat = cv::imread(filename); - } 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()); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); mat = cv::imdecode(*mbuf, -1); if (mat.empty()) { - argv[0] = NanError("Error loading file"); + argv[0] = Nan::Error("Error loading file"); } } img->mat = mat; } catch (cv::Exception& e) { - argv[0] = NanError(e.what()); - argv[1] = NanNull(); + argv[0] = Nan::Error(e.what()); + argv[1] = Nan::Null(); } TryCatch try_catch; - cb->Call(NanGetCurrentContext()->Global(), 2, argv); + cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - NanReturnUndefined(); + return; } diff --git a/src/OpenCV.h b/src/OpenCV.h old mode 100755 new mode 100644 index 79f191a..6e368ae --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -15,34 +15,34 @@ using namespace v8; using namespace node; #define REQ_FUN_ARG(I, VAR) \ - if (args.Length() <= (I) || !args[I]->IsFunction()) \ - return NanThrowTypeError("Argument " #I " must be a function"); \ - Local VAR = Local::Cast(args[I]); + if (info.Length() <= (I) || !info[I]->IsFunction()) \ + return Nan::ThrowTypeError("Argument " #I " must be a function"); \ + Local VAR = Local::Cast(info[I]); #define SETUP_FUNCTION(TYP) \ - NanScope(); \ - TYP *self = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; \ + TYP *self = Nan::ObjectWrap::Unwrap(info.This()); #define JSFUNC(NAME) \ static NAN_METHOD(NAME); #define JSTHROW_TYPE(ERR) \ - NanThrowTypeError( ERR ); + Nan::ThrowTypeError( ERR ); #define JSTHROW(ERR) \ - NanThrowError( ERR ); + Nan::ThrowError( ERR ); #define INT_FROM_ARGS(NAME, IND) \ - if (args[IND]->IsInt32()){ \ - NAME = args[IND]->Uint32Value(); \ + if (info[IND]->IsInt32()){ \ + NAME = info[IND]->Uint32Value(); \ } #define DOUBLE_FROM_ARGS(NAME, IND) \ - 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 { public: static void Init(Handle target); diff --git a/src/Point.cc b/src/Point.cc old mode 100755 new mode 100644 index b90119f..060029d --- a/src/Point.cc +++ b/src/Point.cc @@ -1,72 +1,72 @@ #include "Point.h" #include "OpenCV.h" -v8::Persistent Point::constructor; +Nan::Persistent Point::constructor; void Point::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(Point::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(Point::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("Point")); + ctor->SetClassName(Nan::New("Point").ToLocalChecked()); // Prototype Local proto = ctor->PrototypeTemplate(); - 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()); }; NAN_METHOD(Point::New) { - 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"); } double x = 0, y = 0; - 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(); } Point *pt = new Point(x, y); - pt->Wrap(args.This()); - NanReturnValue(args.This()); + pt->Wrap(info.This()); + info.GetReturnValue().Set(info.This()); } NAN_GETTER(Point::GetX) { - NanScope(); - Point *pt = ObjectWrap::Unwrap(args.This()); - NanReturnValue(NanNew(pt->point.x)); + Nan::HandleScope scope; + Point *pt = Nan::ObjectWrap::Unwrap(info.This()); + info.GetReturnValue().Set(Nan::New(pt->point.x)); } NAN_GETTER(Point::GetY) { - NanScope(); - Point *pt = ObjectWrap::Unwrap(args.This()); - NanReturnValue(NanNew(pt->point.y)); + Nan::HandleScope scope; + Point *pt = Nan::ObjectWrap::Unwrap(info.This()); + info.GetReturnValue().Set(Nan::New(pt->point.y)); } NAN_SETTER(Point::RaiseImmutable) { - NanThrowTypeError("Point is immutable"); + Nan::ThrowTypeError("Point is immutable"); } NAN_METHOD(Point::Dot) { - NanScope(); - Point *p1 = ObjectWrap::Unwrap(args.This()); - Point *p2 = ObjectWrap::Unwrap(args[0]->ToObject()); + Nan::HandleScope scope; + Point *p1 = Nan::ObjectWrap::Unwrap(info.This()); + Point *p2 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); // Since V 2.3 Native Dot no longer supported - NanReturnValue(NanNew(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); + info.GetReturnValue().Set(Nan::New(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); } Point::Point(double x, double y) : - ObjectWrap() { + Nan::ObjectWrap() { point = cvPoint2D32f(x, y); } diff --git a/src/Point.h b/src/Point.h old mode 100755 new mode 100644 index 2aec52d..d72bf60 --- a/src/Point.h +++ b/src/Point.h @@ -2,10 +2,10 @@ #include "OpenCV.h" -class Point: public node::ObjectWrap { +class Point: public Nan::ObjectWrap { public: CvPoint2D32f point; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); Point(double x, double y); diff --git a/src/Stereo.cc b/src/Stereo.cc index e524eef..b5f83f5 100644 --- a/src/Stereo.cc +++ b/src/Stereo.cc @@ -4,54 +4,54 @@ // Block matching -v8::Persistent StereoBM::constructor; +Nan::Persistent StereoBM::constructor; void StereoBM::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew(StereoBM::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(StereoBM::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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("BASIC_PRESET"), NanNew((int)cv::StereoBM::BASIC_PRESET)); - ctor->Set(NanNew("FISH_EYE_PRESET"), NanNew((int)cv::StereoBM::FISH_EYE_PRESET)); - ctor->Set(NanNew("NARROW_PRESET"), NanNew((int)cv::StereoBM::NARROW_PRESET)); + ctor->Set(Nan::New("BASIC_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::BASIC_PRESET)); + ctor->Set(Nan::New("FISH_EYE_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::FISH_EYE_PRESET)); + ctor->Set(Nan::New("NARROW_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::NARROW_PRESET)); - target->Set(NanNew("StereoBM"), ctor->GetFunction()); + target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction()); } NAN_METHOD(StereoBM::New) { - 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"); } StereoBM *stereo; - if (args.Length() == 0) { + if (info.Length() == 0) { stereo = new StereoBM(); - } else if (args.Length() == 1) { + } else if (info.Length() == 1) { // preset - stereo = new StereoBM(args[0]->IntegerValue()); - } else if (args.Length() == 2) { + stereo = new StereoBM(info[0]->IntegerValue()); + } else if (info.Length() == 2) { // preset, disparity search range - stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue()); + stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue()); } else { - stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(), + stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue(), // preset, disparity search range, sum of absolute differences window size - args[2]->IntegerValue()); + info[2]->IntegerValue()); } - stereo->Wrap(args.Holder()); - NanReturnValue(args.Holder()); + stereo->Wrap(info.Holder()); + info.GetReturnValue().Set(info.Holder()); } StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) : - ObjectWrap(), + Nan::ObjectWrap(), stereo(preset, ndisparities, SADWindowSize) { } @@ -63,17 +63,17 @@ NAN_METHOD(StereoBM::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat right = m1->mat; // Optional 3rd arg, the disparty depth int type = CV_16S; - if (args.Length() > 2) { - type = args[2]->IntegerValue(); + if (info.Length() > 2) { + type = info[2]->IntegerValue(); } // Compute stereo using the block matching algorithm @@ -82,108 +82,108 @@ NAN_METHOD(StereoBM::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - NanReturnValue(disparityWrap); + info.GetReturnValue().Set(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // Semi-Global Block matching -v8::Persistent StereoSGBM::constructor; +Nan::Persistent StereoSGBM::constructor; void StereoSGBM::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew(StereoSGBM::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(StereoSGBM::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); } NAN_METHOD(StereoSGBM::New) { - 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"); } StereoSGBM *stereo; - if (args.Length() == 0) { + if (info.Length() == 0) { stereo = new StereoSGBM(); } else { // If passing arguments, must pass the first 3 at least - if (args.Length() >= 3) { - switch (args.Length()) { + if (info.Length() >= 3) { + switch (info.Length()) { case 3: - stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), - args[2]->IntegerValue()); + stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), + info[2]->IntegerValue()); break; case 4: - 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()); break; case 5: - 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()); break; case 6: - 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()); break; case 7: - 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()); break; case 8: - 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()); break; case 9: - 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()); break; case 10: - 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()); break; default: - 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()); break; } } else { - 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()); } StereoSGBM::StereoSGBM() : - ObjectWrap(), + Nan::ObjectWrap(), stereo() { } @@ -191,7 +191,7 @@ StereoSGBM::StereoSGBM() : StereoSGBM::StereoSGBM(int minDisparity, int ndisparities, int SADWindowSize, int p1, int p2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, bool fullDP) : - ObjectWrap(), + Nan::ObjectWrap(), stereo(minDisparity, ndisparities, SADWindowSize, p1, p2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP) { } @@ -204,11 +204,11 @@ NAN_METHOD(StereoSGBM::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat right = m1->mat; // Compute stereo using the block matching algorithm @@ -217,59 +217,59 @@ NAN_METHOD(StereoSGBM::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - NanReturnValue(disparityWrap); + info.GetReturnValue().Set(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // Graph cut -v8::Persistent StereoGC::constructor; +Nan::Persistent StereoGC::constructor; void StereoGC::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew(StereoGC::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(StereoGC::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); } NAN_METHOD(StereoGC::New) { - 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"); StereoGC *stereo; - if (args.Length() == 0) { + if (info.Length() == 0) { stereo = new StereoGC(); - } else if (args.Length() == 1) { + } else if (info.Length() == 1) { // numberOfDisparities - stereo = new StereoGC(args[0]->IntegerValue()); + stereo = new StereoGC(info[0]->IntegerValue()); } else { // max iterations - 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()); } StereoGC::StereoGC(int numberOfDisparities, int maxIters) : - ObjectWrap() { + Nan::ObjectWrap() { stereo = cvCreateStereoGCState(numberOfDisparities, maxIters); } @@ -281,11 +281,11 @@ NAN_METHOD(StereoGC::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat right = m1->mat; // Compute stereo using the block matching algorithm @@ -301,14 +301,14 @@ NAN_METHOD(StereoGC::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - NanReturnValue(disparityWrap); + info.GetReturnValue().Set(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/Stereo.h b/src/Stereo.h index a791732..a26a8f8 100644 --- a/src/Stereo.h +++ b/src/Stereo.h @@ -3,11 +3,11 @@ #include "OpenCV.h" -class StereoBM: public node::ObjectWrap { +class StereoBM: public Nan::ObjectWrap { public: cv::StereoBM stereo; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); @@ -18,11 +18,11 @@ public: ; }; -class StereoSGBM: public node::ObjectWrap { +class StereoSGBM: public Nan::ObjectWrap { public: cv::StereoSGBM stereo; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); @@ -37,11 +37,11 @@ public: struct CvStereoGCState; -class StereoGC: public node::ObjectWrap { +class StereoGC: public Nan::ObjectWrap { public: CvStereoGCState *stereo; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc old mode 100755 new mode 100644 index 970419a..ca6da1c --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -5,11 +5,11 @@ #include using namespace std; -v8::Persistent VideoCaptureWrap::constructor; +Nan::Persistent VideoCaptureWrap::constructor; struct videocapture_baton { - Persistent cb; + Nan::Persistent cb; VideoCaptureWrap *vc; Matrix *im; @@ -17,124 +17,124 @@ struct videocapture_baton { }; void VideoCaptureWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; //Class - Local ctor = NanNew(VideoCaptureWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(VideoCaptureWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("VideoCapture")); + ctor->SetClassName(Nan::New("VideoCapture").ToLocalChecked()); // Prototype //Local proto = constructor->PrototypeTemplate(); - 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()); } NAN_METHOD(VideoCaptureWrap::New) { - 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"); VideoCaptureWrap *v; - if (args[0]->IsNumber()) { - v = new VideoCaptureWrap(args[0]->NumberValue()); + if (info[0]->IsNumber()) { + v = new VideoCaptureWrap(info[0]->NumberValue()); } else { //TODO - assumes that we have string, verify - 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()); } VideoCaptureWrap::VideoCaptureWrap(int device) { - NanScope(); + Nan::HandleScope scope; cap.open(device); if(!cap.isOpened()) { - NanThrowError("Camera could not be opened"); + Nan::ThrowError("Camera could not be opened"); } } VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) { - NanScope(); + Nan::HandleScope scope; cap.open(filename); // TODO! At the moment this only takes a full path - do relative too. if(!cap.isOpened()) { - 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)"); } } NAN_METHOD(VideoCaptureWrap::SetWidth) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - if(args.Length() != 1) - NanReturnUndefined(); + if(info.Length() != 1) + return; - int w = args[0]->IntegerValue(); + int w = info[0]->IntegerValue(); if(v->cap.isOpened()) v->cap.set(CV_CAP_PROP_FRAME_WIDTH, w); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::SetHeight) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - if(args.Length() != 1) - NanReturnUndefined(); + if(info.Length() != 1) + return; - int h = args[0]->IntegerValue(); + int h = info[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::SetPosition) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - if(args.Length() != 1) - NanReturnUndefined(); + if(info.Length() != 1) + return; - int pos = args[0]->IntegerValue(); + int pos = info[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_POS_FRAMES, pos); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::Close) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); v->cap.release(); - NanReturnUndefined(); + return; } -class AsyncVCWorker: public NanAsyncWorker { +class AsyncVCWorker: public Nan::AsyncWorker { public: - AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc, + AsyncVCWorker(Nan::Callback *callback, VideoCaptureWrap* vc, bool retrieve = false, int channel = 0) : - NanAsyncWorker(callback), + Nan::AsyncWorker(callback), vc(vc), retrieve(retrieve), channel(channel) { @@ -161,14 +161,14 @@ public: // this function will be run inside the main event loop // so it is safe to use V8 again void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; - Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_to_return); + Local im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_to_return); img->mat = mat; Local argv[] = { - NanNull() + Nan::Null() , im_to_return }; @@ -187,33 +187,33 @@ private: }; NAN_METHOD(VideoCaptureWrap::Read) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); REQ_FUN_ARG(0, cb); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncVCWorker(callback, v)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v)); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::ReadSync) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_to_return); + Local im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_to_return); v->cap.read(img->mat); - NanReturnValue(im_to_return); + info.GetReturnValue().Set(im_to_return); } -class AsyncGrabWorker: public NanAsyncWorker { +class AsyncGrabWorker: public Nan::AsyncWorker { public: - AsyncGrabWorker(NanCallback *callback, VideoCaptureWrap* vc) : - NanAsyncWorker(callback), + AsyncGrabWorker(Nan::Callback *callback, VideoCaptureWrap* vc) : + Nan::AsyncWorker(callback), vc(vc) { } @@ -231,27 +231,27 @@ private: }; NAN_METHOD(VideoCaptureWrap::Grab) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); REQ_FUN_ARG(0, cb); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncGrabWorker(callback, v)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncGrabWorker(callback, v)); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::Retrieve) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); int channel = 0; REQ_FUN_ARG(0, cb); INT_FROM_ARGS(channel, 1); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); - NanReturnUndefined(); + return; } diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h old mode 100755 new mode 100644 index fb16c4d..a9b3b03 --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class VideoCaptureWrap: public node::ObjectWrap { +class VideoCaptureWrap: public Nan::ObjectWrap { public: cv::VideoCapture cap; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/init.cc b/src/init.cc old mode 100755 new mode 100644 index 56495c3..9e1b2fc --- a/src/init.cc +++ b/src/init.cc @@ -16,7 +16,7 @@ #include "BackgroundSubtractor.h" extern "C" void init(Handle target) { - NanScope(); + Nan::HandleScope scope; OpenCV::Init(target); Point::Init(target); diff --git a/vagrant/user.sh b/vagrant/user.sh index fb22639..2429f40 100755 --- a/vagrant/user.sh +++ b/vagrant/user.sh @@ -24,3 +24,5 @@ apt-get -y install libgtk2.0-dev cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON .. make install cd /home/vagrant/$REPO_FOLDER/ + +npm install node-gyp -g \ No newline at end of file From ad99fa17f24831b584e7ff90d0db65a1a70991e1 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Tue, 29 Sep 2015 15:37:54 -0500 Subject: [PATCH 3/9] temp change git url --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 88dda82..357626d 100644 --- a/package.json +++ b/package.json @@ -32,7 +32,7 @@ "main": "./lib/opencv", "repository": { "type": "git", - "url": "https://github.com/peterbraden/node-opencv.git" + "url": "https://github.com/keeganbrown/node-opencv.git" }, "engines": { "node": ">=0.12" From 1974fd6d00a2954edcefa1978bfbd20600b64a56 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Thu, 1 Oct 2015 11:03:08 -0500 Subject: [PATCH 4/9] Revert "conversion + build + test passed... so far" This reverts commit ea69fcc10b73a191e1d3dc6c9decdc1ebc8bc714. --- src/BackgroundSubtractor.cc | 66 +- src/BackgroundSubtractor.h | 4 +- src/Calib3D.cc | 264 +++---- src/Calib3D.h | 2 +- src/CamShift.cc | 62 +- src/CamShift.h | 4 +- src/CascadeClassifierWrap.cc | 82 +- src/CascadeClassifierWrap.h | 4 +- src/Constants.cc | 12 +- src/Constants.h | 2 +- src/Contours.cc | 316 ++++---- src/Contours.h | 4 +- src/FaceRecognizer.cc | 112 +-- src/FaceRecognizer.h | 4 +- src/Features2d.cc | 28 +- src/Features2d.h | 4 +- src/HighGUI.cc | 54 +- src/HighGUI.h | 4 +- src/ImgProc.cc | 88 +-- src/ImgProc.h | 2 +- src/Matrix.cc | 1414 +++++++++++++++++----------------- src/Matrix.h | 58 +- src/OpenCV.cc | 40 +- src/OpenCV.h | 24 +- src/Point.cc | 60 +- src/Point.h | 4 +- src/Stereo.cc | 218 +++--- src/Stereo.h | 12 +- src/VideoCaptureWrap.cc | 156 ++-- src/VideoCaptureWrap.h | 4 +- src/init.cc | 2 +- vagrant/user.sh | 2 - 32 files changed, 1555 insertions(+), 1557 deletions(-) mode change 100644 => 100755 src/CascadeClassifierWrap.cc mode change 100644 => 100755 src/CascadeClassifierWrap.h mode change 100644 => 100755 src/Contours.cc mode change 100644 => 100755 src/Contours.h mode change 100644 => 100755 src/Matrix.cc mode change 100644 => 100755 src/Matrix.h mode change 100644 => 100755 src/OpenCV.cc mode change 100644 => 100755 src/OpenCV.h mode change 100644 => 100755 src/Point.cc mode change 100644 => 100755 src/Point.h mode change 100644 => 100755 src/VideoCaptureWrap.cc mode change 100644 => 100755 src/VideoCaptureWrap.h mode change 100644 => 100755 src/init.cc diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index 7bf1741..af242b8 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -5,60 +5,60 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) -Nan::Persistent BackgroundSubtractorWrap::constructor; +Persistent BackgroundSubtractorWrap::constructor; void BackgroundSubtractorWrap::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Constructor - Local ctor = Nan::New(BackgroundSubtractorWrap::New); - constructor.Reset(ctor); + Local ctor = NanNew(BackgroundSubtractorWrap::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("BackgroundSubtractor").ToLocalChecked()); + ctor->SetClassName(NanNew("BackgroundSubtractor")); - Nan::SetMethod(ctor, "createMOG", CreateMOG); - Nan::SetPrototypeMethod(ctor, "applyMOG", ApplyMOG); + NODE_SET_METHOD(ctor, "createMOG", CreateMOG); + NODE_SET_PROTOTYPE_METHOD(ctor, "applyMOG", ApplyMOG); - target->Set(Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("BackgroundSubtractor"), ctor->GetFunction()); } NAN_METHOD(BackgroundSubtractorWrap::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { + if (args.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } // Create MOG by default cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); - pt->Wrap(info.This()); + pt->Wrap(args.This()); - info.GetReturnValue().Set(info.This()); + NanReturnValue(args.This()); } NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) { - Nan::HandleScope scope; + NanScope(); // int history = 200; // int nmixtures = 5; // double backgroundRatio = 0.7; // double noiseSigma = 0; // - // if(info.Length() > 1){ + // if(args.Length() > 1){ // INT_FROM_ARGS(history, 0) // INT_FROM_ARGS(nmixtures, 1) // DOUBLE_FROM_ARGS(backgroundRatio, 2) // DOUBLE_FROM_ARGS(noiseSigma, 3) // } - Local n = Nan::New(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); + Local n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); pt->Wrap(n); - info.GetReturnValue().Set( n ); + NanReturnValue( n ); } // Fetch foreground mask @@ -67,32 +67,32 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { REQ_FUN_ARG(1, cb); Local argv[2]; - if (info.Length() == 0) { - argv[0] = Nan::New("Input image missing").ToLocalChecked(); - argv[1] = Nan::Null(); - cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); - return; + if (args.Length() == 0) { + argv[0] = NanNew("Input image missing"); + argv[1] = NanNull(); + cb->Call(NanGetCurrentContext()->Global(), 2, argv); + NanReturnUndefined(); } try { Local fgMask = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(fgMask); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(fgMask); cv::Mat mat; - if (Buffer::HasInstance(info[0])) { - uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject()); - unsigned len = Buffer::Length(info[0]->ToObject()); + if (Buffer::HasInstance(args[0])) { + uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject()); + unsigned len = Buffer::Length(args[0]->ToObject()); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); mat = cv::imdecode(*mbuf, -1); //mbuf->release(); } else { - Matrix *_img = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *_img = ObjectWrap::Unwrap(args[0]->ToObject()); mat = (_img->mat).clone(); } if (mat.empty()) { - return Nan::ThrowTypeError("Error loading file"); + return NanThrowTypeError("Error loading file"); } cv::Mat _fgMask; @@ -101,20 +101,20 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { img->mat = _fgMask; mat.release(); - argv[0] = Nan::Null(); + argv[0] = NanNull(); argv[1] = fgMask; TryCatch try_catch; - cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); + cb->Call(NanGetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - return; + NanReturnUndefined(); } catch (cv::Exception& e) { const char* err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } diff --git a/src/BackgroundSubtractor.h b/src/BackgroundSubtractor.h index b237699..67d51c5 100644 --- a/src/BackgroundSubtractor.h +++ b/src/BackgroundSubtractor.h @@ -4,11 +4,11 @@ #include -class BackgroundSubtractorWrap: public Nan::ObjectWrap { +class BackgroundSubtractorWrap: public node::ObjectWrap { public: cv::Ptr subtractor; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Calib3D.cc b/src/Calib3D.cc index a49ed31..1242f40 100644 --- a/src/Calib3D.cc +++ b/src/Calib3D.cc @@ -3,15 +3,15 @@ inline Local matrixFromMat(cv::Mat &input) { Local matrixWrap = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *matrix = Nan::ObjectWrap::Unwrap(matrixWrap); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *matrix = ObjectWrap::Unwrap(matrixWrap); matrix->mat = input; return matrixWrap; } inline cv::Mat matFromMatrix(Handle matrix) { - Matrix* m = Nan::ObjectWrap::Unwrap(matrix->ToObject()); + Matrix* m = ObjectWrap::Unwrap(matrix->ToObject()); return m->mat; } @@ -38,8 +38,8 @@ inline std::vector points2fFromArray(Handle array) { for (unsigned int i = 0; i < pointsArray->Length(); i++) { Local pt = pointsArray->Get(i)->ToObject(); points.push_back( - cv::Point2f(pt->Get(Nan::New("x").ToLocalChecked())->ToNumber()->Value(), - pt->Get(Nan::New("y").ToLocalChecked())->ToNumber()->Value())); + cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), + pt->Get(NanNew("y"))->ToNumber()->Value())); } } else { JSTHROW_TYPE("Points not a valid array"); @@ -56,9 +56,9 @@ inline std::vector points3fFromArray(Handle array) { for (unsigned int i = 0; i < pointsArray->Length(); i++) { Local pt = pointsArray->Get(i)->ToObject(); points.push_back( - cv::Point3f(pt->Get(Nan::New("x").ToLocalChecked())->ToNumber()->Value(), - pt->Get(Nan::New("y").ToLocalChecked())->ToNumber()->Value(), - pt->Get(Nan::New("z").ToLocalChecked())->ToNumber()->Value())); + cv::Point3f(pt->Get(NanNew("x"))->ToNumber()->Value(), + pt->Get(NanNew("y"))->ToNumber()->Value(), + pt->Get(NanNew("z"))->ToNumber()->Value())); } } else { JSTHROW_TYPE("Must pass array of object points for each frame") @@ -100,35 +100,35 @@ inline std::vector > points3fFromArrayOfArrays( } void Calib3D::Init(Handle target) { - Nan::Persistent inner; - Local obj = Nan::New(); - inner.Reset(obj); + Persistent inner; + Local obj = NanNew(); + NanAssignPersistent(inner, obj); - 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); + 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); - target->Set(Nan::New("calib3d").ToLocalChecked(), obj); + target->Set(NanNew("calib3d"), obj); } // cv::findChessboardCorners NAN_METHOD(Calib3D::FindChessboardCorners) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments from javascript // Arg 0 is the image - cv::Mat mat = matFromMatrix(info[0]); + cv::Mat mat = matFromMatrix(args[0]); // Arg 1 is the pattern size - cv::Size patternSize = sizeFromArray(info[1]); + cv::Size patternSize = sizeFromArray(args[1]); // Arg 2 would normally be the flags, ignoring this for now and using the // default flags @@ -138,77 +138,77 @@ NAN_METHOD(Calib3D::FindChessboardCorners) { bool found = cv::findChessboardCorners(mat, patternSize, corners); // Make the return value - Local ret = Nan::New(); - ret->Set(Nan::New("found").ToLocalChecked(), Nan::New(found)); + Local ret = NanNew(); + ret->Set(NanNew("found"), NanNew(found)); - Local cornersArray = Nan::New(corners.size()); + Local cornersArray = NanNew(corners.size()); for (unsigned int i = 0; i < corners.size(); i++) { - Local point_data = Nan::New(); - point_data->Set(Nan::New("x").ToLocalChecked(), Nan::New(corners[i].x)); - point_data->Set(Nan::New("y").ToLocalChecked(), Nan::New(corners[i].y)); + Local point_data = NanNew(); + point_data->Set(NanNew("x"), NanNew(corners[i].x)); + point_data->Set(NanNew("y"), NanNew(corners[i].y)); - cornersArray->Set(Nan::New(i), point_data); + cornersArray->Set(NanNew(i), point_data); } - ret->Set(Nan::New("corners").ToLocalChecked(), cornersArray); + ret->Set(NanNew("corners"), cornersArray); - info.GetReturnValue().Set(ret); + NanReturnValue(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::drawChessboardCorners NAN_METHOD(Calib3D::DrawChessboardCorners) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0 is the image - cv::Mat mat = matFromMatrix(info[0]); + cv::Mat mat = matFromMatrix(args[0]); // Arg 1 is the pattern size - cv::Size patternSize = sizeFromArray(info[1]); + cv::Size patternSize = sizeFromArray(args[1]); // Arg 2 is the corners array - std::vector corners = points2fFromArray(info[2]); + std::vector corners = points2fFromArray(args[2]); // Arg 3, pattern found boolean - bool patternWasFound = info[3]->ToBoolean()->Value(); + bool patternWasFound = args[3]->ToBoolean()->Value(); // Draw the corners cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound); // Return the passed image, now with corners drawn on it - info.GetReturnValue().Set(info[0]); + NanReturnValue(args[0]); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::calibrateCamera NAN_METHOD(Calib3D::CalibrateCamera) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0, the array of object points, an array of arrays std::vector > objectPoints = - points3fFromArrayOfArrays(info[0]); + points3fFromArrayOfArrays(args[0]); // Arg 1, the image points, another array of arrays std::vector > imagePoints = - points2fFromArrayOfArrays(info[1]); + points2fFromArrayOfArrays(args[1]); // Arg 2, the image size - cv::Size imageSize = sizeFromArray(info[2]); + cv::Size imageSize = sizeFromArray(args[2]); // Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, // skipping for now @@ -223,48 +223,48 @@ NAN_METHOD(Calib3D::CalibrateCamera) { dist, rvecs, tvecs); // make the return values - Local ret = Nan::New(); + Local ret = NanNew(); // Reprojection error - ret->Set(Nan::New("reprojectionError").ToLocalChecked(), Nan::New(error)); + ret->Set(NanNew("reprojectionError"), NanNew(error)); // K Local KMatrixWrap = matrixFromMat(K); - ret->Set(Nan::New("K").ToLocalChecked(), KMatrixWrap); + ret->Set(NanNew("K"), KMatrixWrap); // dist Local distMatrixWrap = matrixFromMat(dist); - ret->Set(Nan::New("distortion").ToLocalChecked(), distMatrixWrap); + ret->Set(NanNew("distortion"), distMatrixWrap); // Per frame R and t, skiping for now // Return - info.GetReturnValue().Set(ret); + NanReturnValue(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::solvePnP NAN_METHOD(Calib3D::SolvePnP) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0, the array of object points - std::vector objectPoints = points3fFromArray(info[0]); + std::vector objectPoints = points3fFromArray(args[0]); // Arg 1, the image points - std::vector imagePoints = points2fFromArray(info[1]); + std::vector imagePoints = points2fFromArray(args[1]); // Arg 2, the camera matrix - cv::Mat K = matFromMatrix(info[2]); + cv::Mat K = matFromMatrix(args[2]); // Arg 3, the distortion coefficients - cv::Mat dist = matFromMatrix(info[3]); + cv::Mat dist = matFromMatrix(args[3]); // Arg 4, use extrinsic guess, skipped for now @@ -276,47 +276,47 @@ NAN_METHOD(Calib3D::SolvePnP) { cv::solvePnP(objectPoints, imagePoints, K, dist, rvec, tvec); // make the return values - Local ret = Nan::New(); + Local ret = NanNew(); // rvec Local rMatrixWrap = matrixFromMat(rvec); - ret->Set(Nan::New("rvec").ToLocalChecked(), rMatrixWrap); + ret->Set(NanNew("rvec"), rMatrixWrap); // tvec Local tMatrixWrap = matrixFromMat(tvec); - ret->Set(Nan::New("tvec").ToLocalChecked(), tMatrixWrap); + ret->Set(NanNew("tvec"), tMatrixWrap); // Return - info.GetReturnValue().Set(ret); + NanReturnValue(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::getOptimalNewCameraMAtrix NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0 is the original camera matrix - cv::Mat Kin = matFromMatrix(info[0]); + cv::Mat Kin = matFromMatrix(args[0]); // Arg 1 is the distortion coefficients - cv::Mat dist = matFromMatrix(info[1]); + cv::Mat dist = matFromMatrix(args[1]); // Arg 2, the image size - cv::Size imageSize = sizeFromArray(info[2]); + cv::Size imageSize = sizeFromArray(args[2]); // Arg 3 is the alpha free scaling parameter - double alpha = info[3]->ToNumber()->Value(); + double alpha = args[3]->ToNumber()->Value(); // Arg 4, the new image size - cv::Size newImageSize = sizeFromArray(info[4]); + cv::Size newImageSize = sizeFromArray(args[4]); // Arg 5, valid ROI, skip for now // Arg 6, center principal point, skip for now @@ -329,46 +329,46 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { Local KMatrixWrap = matrixFromMat(Kout); // Return the new K matrix - info.GetReturnValue().Set(KMatrixWrap); + NanReturnValue(KMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::stereoCalibrate NAN_METHOD(Calib3D::StereoCalibrate) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0, the array of object points, an array of arrays std::vector > objectPoints = - points3fFromArrayOfArrays(info[0]); + points3fFromArrayOfArrays(args[0]); // Arg 1, the image points1, another array of arrays std::vector > imagePoints1 = - points2fFromArrayOfArrays(info[1]); + points2fFromArrayOfArrays(args[1]); // Arg 2, the image points2, another array of arrays =( std::vector > imagePoints2 = - points2fFromArrayOfArrays(info[2]); + points2fFromArrayOfArrays(args[2]); // Arg 3 is the image size (follows the PYTHON api not the C++ api since all // following arguments are optional or outputs) - cv::Size imageSize = sizeFromArray(info[3]); + cv::Size imageSize = sizeFromArray(args[3]); // Arg 4,5,6,7 is the camera matrix and distortion coefficients // (optional but must pass all 4 or none) cv::Mat k1, d1, k2, d2; - if (info.Length() >= 8) { - k1 = matFromMatrix(info[4]); - d1 = matFromMatrix(info[5]); + if (args.Length() >= 8) { + k1 = matFromMatrix(args[4]); + d1 = matFromMatrix(args[5]); - k2 = matFromMatrix(info[6]); - d2 = matFromMatrix(info[7]); + k2 = matFromMatrix(args[6]); + d2 = matFromMatrix(args[7]); } // Last argument is flags, skipping for now @@ -381,7 +381,7 @@ NAN_METHOD(Calib3D::StereoCalibrate) { d2, imageSize, R, t, E, F); // make the return value - Local ret = Nan::New(); + Local ret = NanNew(); // Make the output arguments @@ -410,51 +410,51 @@ NAN_METHOD(Calib3D::StereoCalibrate) { Local FMatrixWrap = matrixFromMat(F); // Add to return object - ret->Set(Nan::New("K1").ToLocalChecked(), K1MatrixWrap); - ret->Set(Nan::New("distortion1").ToLocalChecked(), d1MatrixWrap); - ret->Set(Nan::New("K2").ToLocalChecked(), K2MatrixWrap); - ret->Set(Nan::New("distortion2").ToLocalChecked(), d2MatrixWrap); - ret->Set(Nan::New("R").ToLocalChecked(), RMatrixWrap); - ret->Set(Nan::New("t").ToLocalChecked(), tMatrixWrap); - ret->Set(Nan::New("E").ToLocalChecked(), EMatrixWrap); - ret->Set(Nan::New("F").ToLocalChecked(), FMatrixWrap); + ret->Set(NanNew("K1"), K1MatrixWrap); + ret->Set(NanNew("distortion1"), d1MatrixWrap); + ret->Set(NanNew("K2"), K2MatrixWrap); + ret->Set(NanNew("distortion2"), d2MatrixWrap); + ret->Set(NanNew("R"), RMatrixWrap); + ret->Set(NanNew("t"), tMatrixWrap); + ret->Set(NanNew("E"), EMatrixWrap); + ret->Set(NanNew("F"), FMatrixWrap); // Return - info.GetReturnValue().Set(ret); + NanReturnValue(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::stereoRectify NAN_METHOD(Calib3D::StereoRectify) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg0, the first camera matrix - cv::Mat K1 = matFromMatrix(info[0]); + cv::Mat K1 = matFromMatrix(args[0]); // Arg1, the first distortion coefficients - cv::Mat d1 = matFromMatrix(info[1]); + cv::Mat d1 = matFromMatrix(args[1]); // Arg2, the second camera matrix - cv::Mat K2 = matFromMatrix(info[2]); + cv::Mat K2 = matFromMatrix(args[2]); // Arg3, the second distortion coefficients - cv::Mat d2 = matFromMatrix(info[3]); + cv::Mat d2 = matFromMatrix(args[3]); // Arg4, the image size - cv::Size imageSize = sizeFromArray(info[4]); + cv::Size imageSize = sizeFromArray(args[4]); // arg5, the intercamera rotation matrix - cv::Mat R = matFromMatrix(info[5]); + cv::Mat R = matFromMatrix(args[5]); // Arg6, the intercamera translation vector - cv::Mat t = matFromMatrix(info[6]); + cv::Mat t = matFromMatrix(args[6]); // Arg8, flags, skipping for now @@ -469,76 +469,76 @@ NAN_METHOD(Calib3D::StereoRectify) { cv::stereoRectify(K1, d1, K2, d2, imageSize, R, t, R1, R2, P1, P2, Q); // Make the return object - Local ret = Nan::New(); + Local ret = NanNew(); - ret->Set(Nan::New("R1").ToLocalChecked(), matrixFromMat(R1)); - ret->Set(Nan::New("R2").ToLocalChecked(), matrixFromMat(R2)); - ret->Set(Nan::New("P1").ToLocalChecked(), matrixFromMat(P1)); - ret->Set(Nan::New("P2").ToLocalChecked(), matrixFromMat(P2)); - ret->Set(Nan::New("Q").ToLocalChecked(), matrixFromMat(Q)); + ret->Set(NanNew("R1"), matrixFromMat(R1)); + ret->Set(NanNew("R2"), matrixFromMat(R2)); + ret->Set(NanNew("P1"), matrixFromMat(P1)); + ret->Set(NanNew("P2"), matrixFromMat(P2)); + ret->Set(NanNew("Q"), matrixFromMat(Q)); // Return the rectification parameters - info.GetReturnValue().Set(ret); + NanReturnValue(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::computeCorrespondEpilines NAN_METHOD(Calib3D::ComputeCorrespondEpilines) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg0, the image points - std::vector points = points2fFromArray(info[0]); + std::vector points = points2fFromArray(args[0]); // Arg1, the image index (1 or 2) - int whichImage = int(info[1]->ToNumber()->Value()); + int whichImage = int(args[1]->ToNumber()->Value()); // Arg2, the fundamental matrix - cv::Mat F = matFromMatrix(info[2]); + cv::Mat F = matFromMatrix(args[2]); // compute the lines std::vector lines; cv::computeCorrespondEpilines(points, whichImage, F, lines); // Convert the lines to an array of objects (ax + by + c = 0) - Local linesArray = Nan::New(lines.size()); + Local linesArray = NanNew(lines.size()); for(unsigned int i = 0; i < lines.size(); i++) { - Local line_data = Nan::New(); - line_data->Set(Nan::New("a").ToLocalChecked(), Nan::New(lines[i][0])); - line_data->Set(Nan::New("b").ToLocalChecked(), Nan::New(lines[i][1])); - line_data->Set(Nan::New("c").ToLocalChecked(), Nan::New(lines[i][2])); + Local line_data = NanNew(); + line_data->Set(NanNew("a"), NanNew(lines[i][0])); + line_data->Set(NanNew("b"), NanNew(lines[i][1])); + line_data->Set(NanNew("c"), NanNew(lines[i][2])); - linesArray->Set(Nan::New(i), line_data); + linesArray->Set(NanNew(i), line_data); } // Return the lines - info.GetReturnValue().Set(linesArray); + NanReturnValue(linesArray); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::reprojectImageTo3D NAN_METHOD(Calib3D::ReprojectImageTo3D) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg0, the disparity image - cv::Mat disparity = matFromMatrix(info[0]); + cv::Mat disparity = matFromMatrix(args[0]); // Arg1, the depth-to-disparity transformation Q - cv::Mat Q = matFromMatrix(info[1]); + cv::Mat Q = matFromMatrix(args[1]); // Arg 2, handle missing values, skipped for now @@ -551,10 +551,10 @@ NAN_METHOD(Calib3D::ReprojectImageTo3D) { // Wrap the depth image Local depthImageMatrix = matrixFromMat(depthImage); - info.GetReturnValue().Set(depthImageMatrix); + NanReturnValue(depthImageMatrix); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } diff --git a/src/Calib3D.h b/src/Calib3D.h index 9617757..a2f89f5 100644 --- a/src/Calib3D.h +++ b/src/Calib3D.h @@ -6,7 +6,7 @@ /** * Implementation of calib3d.hpp functions */ -class Calib3D: public Nan::ObjectWrap { +class Calib3D: public node::ObjectWrap { public: static void Init(Handle target); static NAN_METHOD(FindChessboardCorners); diff --git a/src/CamShift.cc b/src/CamShift.cc index 5e08324..8468783 100644 --- a/src/CamShift.cc +++ b/src/CamShift.cc @@ -8,38 +8,38 @@ #define CHANNEL_VALUE 2 -Nan::Persistent TrackedObject::constructor; +Persistent TrackedObject::constructor; void TrackedObject::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Constructor - Local ctor = Nan::New(TrackedObject::New); - constructor.Reset(ctor); + Local ctor = NanNew(TrackedObject::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("TrackedObject").ToLocalChecked()); + ctor->SetClassName(NanNew("TrackedObject")); // Prototype // Local proto = constructor->PrototypeTemplate(); - Nan::SetPrototypeMethod(ctor, "track", Track); + NODE_SET_PROTOTYPE_METHOD(ctor, "track", Track); - target->Set(Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("TrackedObject"), ctor->GetFunction()); } NAN_METHOD(TrackedObject::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { + if (args.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } - Matrix* m = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Rect r; int channel = CHANNEL_HUE; - if (info[1]->IsArray()) { - Local v8rec = info[1]->ToObject(); + if (args[1]->IsArray()) { + Local v8rec = args[1]->ToObject(); r = cv::Rect( v8rec->Get(0)->IntegerValue(), v8rec->Get(1)->IntegerValue(), @@ -49,11 +49,11 @@ NAN_METHOD(TrackedObject::New) { JSTHROW_TYPE("Must pass rectangle to track") } - if (info[2]->IsObject()) { - Local opts = info[2]->ToObject(); + if (args[2]->IsObject()) { + Local opts = args[2]->ToObject(); - if (opts->Get(Nan::New("channel").ToLocalChecked())->IsString()) { - v8::String::Utf8Value c(opts->Get(Nan::New("channel").ToLocalChecked())->ToString()); + if (opts->Get(NanNew("channel"))->IsString()) { + v8::String::Utf8Value c(opts->Get(NanNew("channel"))->ToString()); std::string cc = std::string(*c); if (cc == "hue" || cc == "h") { @@ -72,8 +72,8 @@ NAN_METHOD(TrackedObject::New) { TrackedObject *to = new TrackedObject(m->mat, r, channel); - to->Wrap(info.This()); - info.GetReturnValue().Set(info.This()); + to->Wrap(args.This()); + NanReturnValue(args.This()); } void update_chann_image(TrackedObject* t, cv::Mat image) { @@ -117,17 +117,17 @@ TrackedObject::TrackedObject(cv::Mat image, cv::Rect rect, int chan) { NAN_METHOD(TrackedObject::Track) { SETUP_FUNCTION(TrackedObject) - if (info.Length() != 1) { - Nan::ThrowTypeError("track takes an image param"); - return; + if (args.Length() != 1) { + NanThrowTypeError("track takes an image param"); + NanReturnUndefined(); } - Matrix *im = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); cv::RotatedRect r; if ((self->prev_rect.x < 0) || (self->prev_rect.y < 0) || (self->prev_rect.width <= 1) || (self->prev_rect.height <= 1)) { - return Nan::ThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); + return NanThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); } update_chann_image(self, im->mat); @@ -155,21 +155,21 @@ NAN_METHOD(TrackedObject::Track) { self->prev_rect = backup_prev_rect; } - v8::Local arr = Nan::New(4); + v8::Local arr = NanNew(4); - arr->Set(0, Nan::New(bounds.x)); - arr->Set(1, Nan::New(bounds.y)); - arr->Set(2, Nan::New(bounds.x + bounds.width)); - arr->Set(3, Nan::New(bounds.y + bounds.height)); + arr->Set(0, NanNew(bounds.x)); + arr->Set(1, NanNew(bounds.y)); + arr->Set(2, NanNew(bounds.x + bounds.width)); + arr->Set(3, NanNew(bounds.y + bounds.height)); /* cv::Point2f pts[4]; r.points(pts); for (int i = 0; i < 8; i += 2) { - arr->Set(i, Nan::New(pts[i].x)); - arr->Set(i + 1, Nan::New(pts[i].y)); + arr->Set(i, NanNew(pts[i].x)); + arr->Set(i + 1, NanNew(pts[i].y)); } */ - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } diff --git a/src/CamShift.h b/src/CamShift.h index ac049f3..f43be0c 100644 --- a/src/CamShift.h +++ b/src/CamShift.h @@ -1,7 +1,7 @@ #include "OpenCV.h" -class TrackedObject: public Nan::ObjectWrap { +class TrackedObject: public node::ObjectWrap { public: int channel; cv::Mat hsv; @@ -12,7 +12,7 @@ public: cv::Mat hist; cv::Rect prev_rect; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc old mode 100644 new mode 100755 index c3dce38..64fae09 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -3,50 +3,50 @@ #include "Matrix.h" #include -Nan::Persistent CascadeClassifierWrap::constructor; +Persistent CascadeClassifierWrap::constructor; void CascadeClassifierWrap::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); - Local ctor = Nan::New (CascadeClassifierWrap::New); - constructor.Reset(ctor); + Local ctor = NanNew (CascadeClassifierWrap::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("CascadeClassifier").ToLocalChecked()); + ctor->SetClassName(NanNew("CascadeClassifier")); // Prototype // Local proto = constructor->PrototypeTemplate(); - Nan::SetPrototypeMethod(ctor, "detectMultiScale", DetectMultiScale); + NODE_SET_PROTOTYPE_METHOD(ctor, "detectMultiScale", DetectMultiScale); - target->Set(Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("CascadeClassifier"), ctor->GetFunction()); } NAN_METHOD(CascadeClassifierWrap::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { - Nan::ThrowTypeError("Cannot instantiate without new"); + if (args.This()->InternalFieldCount() == 0) { + NanThrowTypeError("Cannot instantiate without new"); } - CascadeClassifierWrap *pt = new CascadeClassifierWrap(*info[0]); - pt->Wrap(info.This()); - info.GetReturnValue().Set( info.This() ); + CascadeClassifierWrap *pt = new CascadeClassifierWrap(*args[0]); + pt->Wrap(args.This()); + NanReturnValue( args.This() ); } CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName) { std::string filename; - filename = std::string(*Nan::Utf8String(fileName->ToString())); + filename = std::string(*NanAsciiString(fileName->ToString())); if (!cc.load(filename.c_str())) { - Nan::ThrowTypeError("Error loading file"); + NanThrowTypeError("Error loading file"); } } -class AsyncDetectMultiScale: public Nan::AsyncWorker { +class AsyncDetectMultiScale: public NanAsyncWorker { public: - AsyncDetectMultiScale(Nan::Callback *callback, CascadeClassifierWrap *cc, + AsyncDetectMultiScale(NanCallback *callback, CascadeClassifierWrap *cc, Matrix* im, double scale, int neighbors, int minw, int minh) : - Nan::AsyncWorker(callback), + NanAsyncWorker(callback), cc(cc), im(im), scale(scale), @@ -79,22 +79,22 @@ public: } void HandleOKCallback() { - Nan::HandleScope scope; + NanScope(); // this->matrix->Unref(); Handle < Value > argv[2]; - v8::Local < v8::Array > arr = Nan::New < v8::Array > (this->res.size()); + v8::Local < v8::Array > arr = NanNew < v8::Array > (this->res.size()); for (unsigned int i = 0; i < this->res.size(); i++) { - v8::Local < v8::Object > x = Nan::New(); - 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)); + v8::Local < v8::Object > x = NanNew(); + 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)); arr->Set(i, x); } - argv[0] = Nan::Null(); + argv[0] = NanNull(); argv[1] = arr; TryCatch try_catch; @@ -115,37 +115,37 @@ private: }; NAN_METHOD(CascadeClassifierWrap::DetectMultiScale) { - Nan::HandleScope scope; + NanScope(); - CascadeClassifierWrap *self = Nan::ObjectWrap::Unwrap (info.This()); + CascadeClassifierWrap *self = ObjectWrap::Unwrap (args.This()); - if (info.Length() < 2) { - Nan::ThrowTypeError("detectMultiScale takes at least 2 info"); + if (args.Length() < 2) { + NanThrowTypeError("detectMultiScale takes at least 2 args"); } - Matrix *im = Nan::ObjectWrap::Unwrap < Matrix > (info[0]->ToObject()); + Matrix *im = ObjectWrap::Unwrap < Matrix > (args[0]->ToObject()); REQ_FUN_ARG(1, cb); double scale = 1.1; - if (info.Length() > 2 && info[2]->IsNumber()) { - scale = info[2]->NumberValue(); + if (args.Length() > 2 && args[2]->IsNumber()) { + scale = args[2]->NumberValue(); } int neighbors = 2; - if (info.Length() > 3 && info[3]->IsInt32()) { - neighbors = info[3]->IntegerValue(); + if (args.Length() > 3 && args[3]->IsInt32()) { + neighbors = args[3]->IntegerValue(); } int minw = 30; int minh = 30; - if (info.Length() > 5 && info[4]->IsInt32() && info[5]->IsInt32()) { - minw = info[4]->IntegerValue(); - minh = info[5]->IntegerValue(); + if (args.Length() > 5 && args[4]->IsInt32() && args[5]->IsInt32()) { + minw = args[4]->IntegerValue(); + minh = args[5]->IntegerValue(); } - Nan::Callback *callback = new Nan::Callback(cb.As()); + NanCallback *callback = new NanCallback(cb.As()); - Nan::AsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, + NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, neighbors, minw, minh)); - return; + NanReturnUndefined(); } diff --git a/src/CascadeClassifierWrap.h b/src/CascadeClassifierWrap.h old mode 100644 new mode 100755 index c0016d9..060ca3f --- a/src/CascadeClassifierWrap.h +++ b/src/CascadeClassifierWrap.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class CascadeClassifierWrap: public Nan::ObjectWrap { +class CascadeClassifierWrap: public node::ObjectWrap { public: cv::CascadeClassifier cc; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Constants.cc b/src/Constants.cc index 5d9fa22..1ed9904 100644 --- a/src/Constants.cc +++ b/src/Constants.cc @@ -2,15 +2,15 @@ #include "Constants.h" #define CONST(C) \ - obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New(C)); + obj->Set(NanNew(#C), NanNew(C)); #define CONST_ENUM(C) \ - obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New((int)(cv::C))); + obj->Set(NanNew(#C), NanNew((int)(cv::C))); void Constants::Init(Handle target) { - Nan::Persistent inner; - Local obj = Nan::New(); - inner.Reset(obj); + Persistent inner; + Local obj = NanNew(); + NanAssignPersistent(inner, obj); CONST(CV_8U); CONST(CV_8S); @@ -72,7 +72,7 @@ void Constants::Init(Handle target) { CONST_ENUM(NORM_RELATIVE); CONST_ENUM(NORM_TYPE_MASK); - target->Set(Nan::New("Constants").ToLocalChecked(), obj); + target->Set(NanNew("Constants"), obj); } #undef CONST diff --git a/src/Constants.h b/src/Constants.h index 9bb818e..c7bb6c6 100644 --- a/src/Constants.h +++ b/src/Constants.h @@ -1,6 +1,6 @@ #include "OpenCV.h" -class Constants: public Nan::ObjectWrap { +class Constants: public node::ObjectWrap { public: static void Init(Handle target); }; diff --git a/src/Contours.cc b/src/Contours.cc old mode 100644 new mode 100755 index f8eb726..9705ff0 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -4,337 +4,337 @@ #include -Nan::Persistent Contour::constructor; +v8::Persistent Contour::constructor; void Contour::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Class/contructor - Local ctor = Nan::New(Contour::New); - constructor.Reset(ctor); + Local ctor = NanNew(Contour::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("Contours").ToLocalChecked()); + ctor->SetClassName(NanNew("Contours")); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); + 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_METHOD(Contour::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { - Nan::ThrowTypeError("Cannot instantiate without new"); + if (args.This()->InternalFieldCount() == 0) { + NanThrowTypeError("Cannot instantiate without new"); } Contour *contours; contours = new Contour; - contours->Wrap(info.Holder()); - info.GetReturnValue().Set(info.Holder()); + contours->Wrap(args.Holder()); + NanReturnValue(args.Holder()); } Contour::Contour() : - Nan::ObjectWrap() { + ObjectWrap() { } NAN_METHOD(Contour::Point) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); - int index = info[1]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); + int index = args[1]->NumberValue(); cv::Point point = self->contours[pos][index]; - Local data = Nan::New(); - data->Set(Nan::New("x").ToLocalChecked(), Nan::New(point.x)); - data->Set(Nan::New("y").ToLocalChecked(), Nan::New(point.y)); + Local data = NanNew(); + data->Set(NanNew("x"), NanNew(point.x)); + data->Set(NanNew("y"), NanNew(point.y)); - info.GetReturnValue().Set(data); + NanReturnValue(data); } NAN_METHOD(Contour::Points) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); vector points = self->contours[pos]; - Local data = Nan::New(points.size()); + Local data = NanNew(points.size()); for (std::vector::size_type i = 0; i != points.size(); i++) { - Local point_data = Nan::New(); - point_data->Set(Nan::New("x").ToLocalChecked(), Nan::New(points[i].x)); - point_data->Set(Nan::New("y").ToLocalChecked(), Nan::New(points[i].y)); + Local point_data = NanNew(); + point_data->Set(NanNew("x"), NanNew(points[i].x)); + point_data->Set(NanNew("y"), NanNew(points[i].y)); data->Set(i, point_data); } - info.GetReturnValue().Set(data); + NanReturnValue(data); } // FIXME: this should better be called "Length" as ``Contours`` is an Array like // structure also, this would allow to use ``Size`` for the function returning // the number of corners in the contour for better consistency with OpenCV. NAN_METHOD(Contour::Size) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *self = ObjectWrap::Unwrap(args.This()); - info.GetReturnValue().Set(Nan::New(self->contours.size())); + NanReturnValue(NanNew(self->contours.size())); } NAN_METHOD(Contour::CornerCount) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); - info.GetReturnValue().Set(Nan::New(self->contours[pos].size())); + NanReturnValue(NanNew(self->contours[pos].size())); } NAN_METHOD(Contour::Area) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); - // info.GetReturnValue().Set(Nan::New(contourArea(self->contours))); - info.GetReturnValue().Set(Nan::New(contourArea(cv::Mat(self->contours[pos])))); + // NanReturnValue(NanNew(contourArea(self->contours))); + NanReturnValue(NanNew(contourArea(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::ArcLength) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); - bool isClosed = info[1]->BooleanValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); + bool isClosed = args[1]->BooleanValue(); - info.GetReturnValue().Set(Nan::New(arcLength(cv::Mat(self->contours[pos]), isClosed))); + NanReturnValue(NanNew(arcLength(cv::Mat(self->contours[pos]), isClosed))); } NAN_METHOD(Contour::ApproxPolyDP) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); - double epsilon = info[1]->NumberValue(); - bool isClosed = info[2]->BooleanValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); + double epsilon = args[1]->NumberValue(); + bool isClosed = args[2]->BooleanValue(); cv::Mat approxed; approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed); approxed.copyTo(self->contours[pos]); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Contour::ConvexHull) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = info[0]->NumberValue(); - bool clockwise = info[1]->BooleanValue(); + int pos = args[0]->NumberValue(); + bool clockwise = args[1]->BooleanValue(); cv::Mat hull; cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise); hull.copyTo(self->contours[pos]); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Contour::BoundingRect) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos])); - Local rect = Nan::New(); + Local rect = NanNew(); - rect->Set(Nan::New("x").ToLocalChecked(), Nan::New(bounding.x)); - rect->Set(Nan::New("y").ToLocalChecked(), Nan::New(bounding.y)); - rect->Set(Nan::New("width").ToLocalChecked(), Nan::New(bounding.width)); - rect->Set(Nan::New("height").ToLocalChecked(), Nan::New(bounding.height)); + rect->Set(NanNew("x"), NanNew(bounding.x)); + rect->Set(NanNew("y"), NanNew(bounding.y)); + rect->Set(NanNew("width"), NanNew(bounding.width)); + rect->Set(NanNew("height"), NanNew(bounding.height)); - info.GetReturnValue().Set(rect); + NanReturnValue(rect); } NAN_METHOD(Contour::MinAreaRect) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos])); - Local rect = Nan::New(); - rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New(minimum.angle)); + Local rect = NanNew(); + rect->Set(NanNew("angle"), NanNew(minimum.angle)); - Local size = Nan::New(); - size->Set(Nan::New("height").ToLocalChecked(), Nan::New(minimum.size.height)); - size->Set(Nan::New("width").ToLocalChecked(), Nan::New(minimum.size.width)); - rect->Set(Nan::New("size").ToLocalChecked(), size); + Local size = NanNew(); + size->Set(NanNew("height"), NanNew(minimum.size.height)); + size->Set(NanNew("width"), NanNew(minimum.size.width)); + rect->Set(NanNew("size"), size); - Local center = Nan::New(); - center->Set(Nan::New("x").ToLocalChecked(), Nan::New(minimum.center.x)); - center->Set(Nan::New("y").ToLocalChecked(), Nan::New(minimum.center.y)); + Local center = NanNew(); + center->Set(NanNew("x"), NanNew(minimum.center.x)); + center->Set(NanNew("y"), NanNew(minimum.center.y)); - v8::Local points = Nan::New(4); + v8::Local points = NanNew(4); cv::Point2f rect_points[4]; minimum.points(rect_points); for (unsigned int i=0; i<4; i++) { - Local point = Nan::New(); - point->Set(Nan::New("x").ToLocalChecked(), Nan::New(rect_points[i].x)); - point->Set(Nan::New("y").ToLocalChecked(), Nan::New(rect_points[i].y)); + Local point = NanNew(); + point->Set(NanNew("x"), NanNew(rect_points[i].x)); + point->Set(NanNew("y"), NanNew(rect_points[i].y)); points->Set(i, point); } - rect->Set(Nan::New("points").ToLocalChecked(), points); + rect->Set(NanNew("points"), points); - info.GetReturnValue().Set(rect); + NanReturnValue(rect); } NAN_METHOD(Contour::FitEllipse) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); if (self->contours[pos].size() >= 5) { // Minimum number for an ellipse cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos])); - Local jsEllipse = Nan::New(); - jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New(ellipse.angle)); + Local jsEllipse = NanNew(); + jsEllipse->Set(NanNew("angle"), NanNew(ellipse.angle)); - Local size = Nan::New(); - size->Set(Nan::New("height").ToLocalChecked(), Nan::New(ellipse.size.height)); - size->Set(Nan::New("width").ToLocalChecked(), Nan::New(ellipse.size.width)); - jsEllipse->Set(Nan::New("size").ToLocalChecked(), size); + Local size = NanNew(); + size->Set(NanNew("height"), NanNew(ellipse.size.height)); + size->Set(NanNew("width"), NanNew(ellipse.size.width)); + jsEllipse->Set(NanNew("size"), size); - Local center = Nan::New(); - center->Set(Nan::New("x").ToLocalChecked(), Nan::New(ellipse.center.x)); - center->Set(Nan::New("y").ToLocalChecked(), Nan::New(ellipse.center.y)); - jsEllipse->Set(Nan::New("center").ToLocalChecked(), center); + Local center = NanNew(); + center->Set(NanNew("x"), NanNew(ellipse.center.x)); + center->Set(NanNew("y"), NanNew(ellipse.center.y)); + jsEllipse->Set(NanNew("center"), center); - info.GetReturnValue().Set(jsEllipse); + NanReturnValue(jsEllipse); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Contour::IsConvex) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); - info.GetReturnValue().Set(Nan::New(isContourConvex(cv::Mat(self->contours[pos])))); + NanReturnValue(NanNew(isContourConvex(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::Moments) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->NumberValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); // Get the moments cv::Moments mu = moments( self->contours[pos], false ); - Local res = Nan::New(); + Local res = NanNew(); - res->Set(Nan::New("m00").ToLocalChecked(), Nan::New(mu.m00)); - res->Set(Nan::New("m10").ToLocalChecked(), Nan::New(mu.m10)); - res->Set(Nan::New("m01").ToLocalChecked(), Nan::New(mu.m01)); - res->Set(Nan::New("m11").ToLocalChecked(), Nan::New(mu.m11)); + res->Set(NanNew("m00"), NanNew(mu.m00)); + res->Set(NanNew("m10"), NanNew(mu.m10)); + res->Set(NanNew("m01"), NanNew(mu.m01)); + res->Set(NanNew("m11"), NanNew(mu.m11)); - info.GetReturnValue().Set(res); + NanReturnValue(res); } NAN_METHOD(Contour::Hierarchy) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = info[0]->IntegerValue(); + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->IntegerValue(); cv::Vec4i hierarchy = self->hierarchy[pos]; - Local res = Nan::New(4); + Local res = NanNew(4); - res->Set(0, Nan::New(hierarchy[0])); - res->Set(1, Nan::New(hierarchy[1])); - res->Set(2, Nan::New(hierarchy[2])); - res->Set(3, Nan::New(hierarchy[3])); + res->Set(0, NanNew(hierarchy[0])); + res->Set(1, NanNew(hierarchy[1])); + res->Set(2, NanNew(hierarchy[2])); + res->Set(3, NanNew(hierarchy[3])); - info.GetReturnValue().Set(res); + NanReturnValue(res); } NAN_METHOD(Contour::Serialize) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *self = ObjectWrap::Unwrap(args.This()); - Local contours_data = Nan::New(self->contours.size()); + Local contours_data = NanNew(self->contours.size()); for (std::vector::size_type i = 0; i != self->contours.size(); i++) { vector points = self->contours[i]; - Local contour_data = Nan::New(points.size()); + Local contour_data = NanNew(points.size()); for (std::vector::size_type j = 0; j != points.size(); j++) { - Local point_data = Nan::New(2); - point_data->Set(0, Nan::New(points[j].x)); - point_data->Set(1, Nan::New(points[j].y)); + Local point_data = NanNew(2); + point_data->Set(0, NanNew(points[j].x)); + point_data->Set(1, NanNew(points[j].y)); contour_data->Set(j, point_data); } contours_data->Set(i, contour_data); } - Local hierarchy_data = Nan::New(self->hierarchy.size()); + Local hierarchy_data = NanNew(self->hierarchy.size()); for (std::vector::size_type i = 0; i != self->hierarchy.size(); i++) { - Local contour_data = Nan::New(4); - contour_data->Set(0, Nan::New(self->hierarchy[i][0])); - contour_data->Set(1, Nan::New(self->hierarchy[i][1])); - contour_data->Set(2, Nan::New(self->hierarchy[i][2])); - contour_data->Set(3, Nan::New(self->hierarchy[i][3])); + Local contour_data = NanNew(4); + contour_data->Set(0, NanNew(self->hierarchy[i][0])); + contour_data->Set(1, NanNew(self->hierarchy[i][1])); + contour_data->Set(2, NanNew(self->hierarchy[i][2])); + contour_data->Set(3, NanNew(self->hierarchy[i][3])); hierarchy_data->Set(i, contour_data); } - Local data = Nan::New(); - data->Set(Nan::New("contours").ToLocalChecked(), contours_data); - data->Set(Nan::New("hierarchy").ToLocalChecked(), hierarchy_data); + Local data = NanNew(); + data->Set(NanNew("contours"), contours_data); + data->Set(NanNew("hierarchy"), hierarchy_data); - info.GetReturnValue().Set(data); + NanReturnValue(data); } NAN_METHOD(Contour::Deserialize) { - Nan::HandleScope scope; + NanScope(); - Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *self = ObjectWrap::Unwrap(args.This()); - Handle data = Handle::Cast(info[0]); + Handle data = Handle::Cast(args[0]); - Handle contours_data = Handle::Cast(data->Get(Nan::New("contours").ToLocalChecked())); - Handle hierarchy_data = Handle::Cast(data->Get(Nan::New("hierarchy").ToLocalChecked())); + Handle contours_data = Handle::Cast(data->Get(NanNew("contours"))); + Handle hierarchy_data = Handle::Cast(data->Get(NanNew("hierarchy"))); vector > contours_res; int contours_length = contours_data->Length(); @@ -369,5 +369,5 @@ NAN_METHOD(Contour::Deserialize) { self->contours = contours_res; self->hierarchy = hierarchy_res; - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } diff --git a/src/Contours.h b/src/Contours.h old mode 100644 new mode 100755 index b1a496a..bd442ea --- a/src/Contours.h +++ b/src/Contours.h @@ -2,13 +2,13 @@ using namespace std; -class Contour: public Nan::ObjectWrap { +class Contour: public node::ObjectWrap { public: cv::Mat mat; vector > contours; vector hierarchy; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc index 1b2eb82..3814d45 100644 --- a/src/FaceRecognizer.cc +++ b/src/FaceRecognizer.cc @@ -14,11 +14,11 @@ cv::Mat fromMatrixOrFilename(Local v) { cv::Mat im; if (v->IsString()) { - std::string filename = std::string(*Nan::Utf8String(v->ToString())); + std::string filename = std::string(*NanAsciiString(v->ToString())); im = cv::imread(filename); // std::cout<< im.size(); } else { - Matrix *img = Nan::ObjectWrap::Unwrap(v->ToObject()); + Matrix *img = ObjectWrap::Unwrap(v->ToObject()); im = img->mat; } return im; @@ -27,36 +27,36 @@ cv::Mat fromMatrixOrFilename(Local v) { void AsyncPredict(uv_work_t *req); void AfterAsyncPredict(uv_work_t *req); -Nan::Persistent FaceRecognizerWrap::constructor; +Persistent FaceRecognizerWrap::constructor; void FaceRecognizerWrap::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Constructor - Local ctor = Nan::New(FaceRecognizerWrap::New); - constructor.Reset(ctor); + Local ctor = NanNew(FaceRecognizerWrap::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("FaceRecognizer").ToLocalChecked()); + ctor->SetClassName(NanNew("FaceRecognizer")); - Nan::SetMethod(ctor, "createLBPHFaceRecognizer", CreateLBPH); - Nan::SetMethod(ctor, "createEigenFaceRecognizer", CreateEigen); - Nan::SetMethod(ctor, "createFisherFaceRecognizer", CreateFisher); + NODE_SET_METHOD(ctor, "createLBPHFaceRecognizer", CreateLBPH); + NODE_SET_METHOD(ctor, "createEigenFaceRecognizer", CreateEigen); + NODE_SET_METHOD(ctor, "createFisherFaceRecognizer", CreateFisher); - 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, "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, "getMat", GetMat); + NODE_SET_PROTOTYPE_METHOD(ctor, "getMat", GetMat); - target->Set(Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("FaceRecognizer"), ctor->GetFunction()); }; NAN_METHOD(FaceRecognizerWrap::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { + if (args.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } @@ -64,12 +64,12 @@ NAN_METHOD(FaceRecognizerWrap::New) { cv::Ptr f = cv::createLBPHFaceRecognizer(1, 8, 8, 8, 80.0); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); - pt->Wrap(info.This()); - info.GetReturnValue().Set(info.This()); + pt->Wrap(args.This()); + NanReturnValue(args.This()); } NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { - Nan::HandleScope scope; + NanScope(); int radius = 1; int neighbors = 8; @@ -83,17 +83,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { INT_FROM_ARGS(grid_y, 3) DOUBLE_FROM_ARGS(threshold, 4) - Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createLBPHFaceRecognizer(radius, neighbors, grid_x, grid_y, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); pt->Wrap(n); - info.GetReturnValue().Set( n ); + NanReturnValue( n ); } NAN_METHOD(FaceRecognizerWrap::CreateEigen) { - Nan::HandleScope scope; + NanScope(); int components = 0; double threshold = DBL_MAX; @@ -101,17 +101,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateEigen) { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createEigenFaceRecognizer(components, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN); pt->Wrap(n); - info.GetReturnValue().Set( n ); + NanReturnValue( n ); } NAN_METHOD(FaceRecognizerWrap::CreateFisher) { - Nan::HandleScope scope; + NanScope(); int components = 0; double threshold = DBL_MAX; @@ -119,14 +119,14 @@ NAN_METHOD(FaceRecognizerWrap::CreateFisher) { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createFisherFaceRecognizer(components, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER); pt->Wrap(n); - info.GetReturnValue().Set( n ); + NanReturnValue( n ); } FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, @@ -135,16 +135,16 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, typ = type; } -Handle UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info, +Handle UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, cv::vector* images, cv::vector* labels) { - if (info.Length() < 1 || !info[0]->IsArray()) { + if (args.Length() < 1 || !args[0]->IsArray()) { JSTHROW("FaceRecognizer.train takes a list of [ label, image] tuples") } // Iterate through [[label, image], ...] etc, and add matrix / label to vectors - // const Local tuples = v8::Array::Cast(*info[0]); - const Local tuples = Local::Cast(info[0]); + // const Local tuples = v8::Array::Cast(*args[0]); + const Local tuples = Local::Cast(args[0]); const uint32_t length = tuples->Length(); for (uint32_t i=0; i UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info, labels->push_back(label); images->push_back(im); } - return Nan::Undefined(); + return NanUndefined(); } NAN_METHOD(FaceRecognizerWrap::TrainSync) { @@ -176,14 +176,14 @@ NAN_METHOD(FaceRecognizerWrap::TrainSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(info, &images, &labels); + Handle exception = UnwrapTrainingData(args, &images, &labels); if (!exception->IsUndefined()) { - info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this + NanReturnValue(exception); // FIXME: not too sure about returning exceptions like this } self->rec->train(images, labels); - return; + NanReturnUndefined(); } NAN_METHOD(FaceRecognizerWrap::UpdateSync) { @@ -199,20 +199,20 @@ NAN_METHOD(FaceRecognizerWrap::UpdateSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(info, &images, &labels); + Handle exception = UnwrapTrainingData(args, &images, &labels); if (!exception->IsUndefined()) { JSTHROW(exception); } self->rec->update(images, labels); - return; + NanReturnUndefined(); } NAN_METHOD(FaceRecognizerWrap::PredictSync) { SETUP_FUNCTION(FaceRecognizerWrap) - cv::Mat im = fromMatrixOrFilename(info[0]); // TODO CHECK! + cv::Mat im = fromMatrixOrFilename(args[0]); // TODO CHECK! cv::cvtColor(im, im, CV_RGB2GRAY); // int predictedLabel = self->rec->predict(im); @@ -220,46 +220,46 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync) { double confidence = 0.0; self->rec->predict(im, predictedLabel, confidence); - v8::Local res = Nan::New(); - res->Set(Nan::New("id").ToLocalChecked(), Nan::New(predictedLabel)); - res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New(confidence)); + v8::Local res = NanNew(); + res->Set(NanNew("id"), NanNew(predictedLabel)); + res->Set(NanNew("confidence"), NanNew(confidence)); - info.GetReturnValue().Set(res); + NanReturnValue(res); } NAN_METHOD(FaceRecognizerWrap::SaveSync) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!info[0]->IsString()) { + if (!args[0]->IsString()) { JSTHROW("Save takes a filename") } - std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); + std::string filename = std::string(*NanAsciiString(args[0]->ToString())); self->rec->save(filename); - return; + NanReturnUndefined(); } NAN_METHOD(FaceRecognizerWrap::LoadSync) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!info[0]->IsString()) { + if (!args[0]->IsString()) { JSTHROW("Load takes a filename") } - std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); + std::string filename = std::string(*NanAsciiString(args[0]->ToString())); self->rec->load(filename); - return; + NanReturnUndefined(); } NAN_METHOD(FaceRecognizerWrap::GetMat) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!info[0]->IsString()) { + if (!args[0]->IsString()) { JSTHROW("getMat takes a key") } - std::string key = std::string(*Nan::Utf8String(info[0]->ToString())); + std::string key = std::string(*NanAsciiString(args[0]->ToString())); cv::Mat m = self->rec->getMat(key); - Local im = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im); + Local im = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im); img->mat = m; - info.GetReturnValue().Set(im); + NanReturnValue(im); } #endif // End version > 2.4 diff --git a/src/FaceRecognizer.h b/src/FaceRecognizer.h index 6a19d10..d9bf2aa 100644 --- a/src/FaceRecognizer.h +++ b/src/FaceRecognizer.h @@ -4,12 +4,12 @@ #include "opencv2/contrib/contrib.hpp" -class FaceRecognizerWrap: public Nan::ObjectWrap { +class FaceRecognizerWrap: public node::ObjectWrap { public: cv::Ptr rec; int typ; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Features2d.cc b/src/Features2d.cc index ce09abc..e099275 100644 --- a/src/Features2d.cc +++ b/src/Features2d.cc @@ -6,15 +6,15 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) void Features::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); - Nan::SetMethod(target, "ImageSimilarity", Similarity); + NODE_SET_METHOD(target, "ImageSimilarity", Similarity); } -class AsyncDetectSimilarity: public Nan::AsyncWorker { +class AsyncDetectSimilarity: public NanAsyncWorker { public: - AsyncDetectSimilarity(Nan::Callback *callback, cv::Mat image1, cv::Mat image2) : - Nan::AsyncWorker(callback), + AsyncDetectSimilarity(NanCallback *callback, cv::Mat image1, cv::Mat image2) : + NanAsyncWorker(callback), image1(image1), image2(image2), dissimilarity(0) { @@ -80,12 +80,12 @@ public: } void HandleOKCallback() { - Nan::HandleScope scope; + NanScope(); Handle argv[2]; - argv[0] = Nan::Null(); - argv[1] = Nan::New(dissimilarity); + argv[0] = NanNull(); + argv[1] = NanNew(dissimilarity); callback->Call(2, argv); } @@ -97,17 +97,17 @@ private: }; NAN_METHOD(Features::Similarity) { - Nan::HandleScope scope; + NanScope(); REQ_FUN_ARG(2, cb); - cv::Mat image1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject())->mat; - cv::Mat image2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject())->mat; + cv::Mat image1 = ObjectWrap::Unwrap(args[0]->ToObject())->mat; + cv::Mat image2 = ObjectWrap::Unwrap(args[1]->ToObject())->mat; - Nan::Callback *callback = new Nan::Callback(cb.As()); + NanCallback *callback = new NanCallback(cb.As()); - Nan::AsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); - return; + NanAsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); + NanReturnUndefined(); } #endif diff --git a/src/Features2d.h b/src/Features2d.h index 600f646..764bec8 100644 --- a/src/Features2d.h +++ b/src/Features2d.h @@ -5,9 +5,9 @@ #include #include -class Features: public Nan::ObjectWrap { +class Features: public node::ObjectWrap { public: - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(Similarity); diff --git a/src/HighGUI.cc b/src/HighGUI.cc index b43fb89..6e09579 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -2,41 +2,41 @@ #include "OpenCV.h" #include "Matrix.h" -Nan::Persistent NamedWindow::constructor; +Persistent NamedWindow::constructor; void NamedWindow::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Constructor - Local ctor = Nan::New(NamedWindow::New); - constructor.Reset(ctor); + Local ctor = NanNew(NamedWindow::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("NamedWindow").ToLocalChecked()); + ctor->SetClassName(NanNew("NamedWindow")); // Prototype - Nan::SetPrototypeMethod(ctor, "show", Show); - Nan::SetPrototypeMethod(ctor, "destroy", Destroy); - Nan::SetPrototypeMethod(ctor, "blockingWaitKey", BlockingWaitKey); + NODE_SET_PROTOTYPE_METHOD(ctor, "show", Show); + NODE_SET_PROTOTYPE_METHOD(ctor, "destroy", Destroy); + NODE_SET_PROTOTYPE_METHOD(ctor, "blockingWaitKey", BlockingWaitKey); - target->Set(Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("NamedWindow"), ctor->GetFunction()); }; NAN_METHOD(NamedWindow::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { + if (args.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } NamedWindow* win; - 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); + 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); } - win->Wrap(info.Holder()); - info.GetReturnValue().Set(info.Holder()); + win->Wrap(args.Holder()); + NanReturnValue(args.Holder()); } NamedWindow::NamedWindow(const std::string& name, int f) { @@ -47,38 +47,38 @@ NamedWindow::NamedWindow(const std::string& name, int f) { NAN_METHOD(NamedWindow::Show) { SETUP_FUNCTION(NamedWindow) - Matrix *im = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); try { cv::imshow(self->winname, im->mat); } catch (cv::Exception& e) { const char* err_msg = e.what(); - Nan::ThrowError(err_msg); + NanThrowError(err_msg); } - info.GetReturnValue().Set(info.Holder()); + NanReturnValue(args.Holder()); } NAN_METHOD(NamedWindow::Destroy) { SETUP_FUNCTION(NamedWindow) cv::destroyWindow(self->winname); - info.GetReturnValue().Set(info.Holder()); + NanReturnValue(args.Holder()); } NAN_METHOD(NamedWindow::BlockingWaitKey) { - Nan::HandleScope scope; + NanScope(); //SETUP_FUNCTION(NamedWindow) int time = 0; - if (info.Length() > 1) { - time = info[1]->IntegerValue(); + if (args.Length() > 1) { + time = args[1]->IntegerValue(); } else { - if (info.Length() > 0) { - time = info[0]->IntegerValue(); + if (args.Length() > 0) { + time = args[0]->IntegerValue(); } } int res = cv::waitKey(time); - info.GetReturnValue().Set(Nan::New(res)); + NanReturnValue(NanNew(res)); } diff --git a/src/HighGUI.h b/src/HighGUI.h index 9b7019a..e88254b 100644 --- a/src/HighGUI.h +++ b/src/HighGUI.h @@ -1,11 +1,11 @@ #include "OpenCV.h" -class NamedWindow: public Nan::ObjectWrap { +class NamedWindow: public node::ObjectWrap { public: std::string winname; int flags; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/ImgProc.cc b/src/ImgProc.cc index b84e20a..20f32c8 100644 --- a/src/ImgProc.cc +++ b/src/ImgProc.cc @@ -2,34 +2,34 @@ #include "Matrix.h" void ImgProc::Init(Handle target) { - Nan::Persistent inner; - Local obj = Nan::New(); - inner.Reset(obj); + Persistent inner; + Local obj = NanNew(); + NanAssignPersistent(inner, obj); - Nan::SetMethod(obj, "undistort", Undistort); - Nan::SetMethod(obj, "initUndistortRectifyMap", InitUndistortRectifyMap); - Nan::SetMethod(obj, "remap", Remap); + NODE_SET_METHOD(obj, "undistort", Undistort); + NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap); + NODE_SET_METHOD(obj, "remap", Remap); - target->Set(Nan::New("imgproc").ToLocalChecked(), obj); + target->Set(NanNew("imgproc"), obj); } // cv::undistort NAN_METHOD(ImgProc::Undistort) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0 is the image - Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Mat inputImage = m0->mat; // Arg 1 is the camera matrix - Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::Mat K = m1->mat; // Arg 2 is the distortion coefficents - Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); + Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); cv::Mat dist = m2->mat; // Make an mat to hold the result image @@ -39,51 +39,51 @@ NAN_METHOD(ImgProc::Undistort) { cv::undistort(inputImage, outputImage, K, dist); // Wrap the output image - Local outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *outMatrix = Nan::ObjectWrap::Unwrap(outMatrixWrap); + Local outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *outMatrix = ObjectWrap::Unwrap(outMatrixWrap); outMatrix->mat = outputImage; // Return the output image - info.GetReturnValue().Set(outMatrixWrap); + NanReturnValue(outMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::initUndistortRectifyMap NAN_METHOD(ImgProc::InitUndistortRectifyMap) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Arg 0 is the camera matrix - Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Mat K = m0->mat; // Arg 1 is the distortion coefficents - Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::Mat dist = m1->mat; // Arg 2 is the recification transformation - Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); + Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); cv::Mat R = m2->mat; // Arg 3 is the new camera matrix - Matrix* m3 = Nan::ObjectWrap::Unwrap(info[3]->ToObject()); + Matrix* m3 = ObjectWrap::Unwrap(args[3]->ToObject()); cv::Mat newK = m3->mat; // Arg 4 is the image size cv::Size imageSize; - if (info[4]->IsArray()) { - Local v8sz = info[4]->ToObject(); + if (args[4]->IsArray()) { + Local v8sz = args[4]->ToObject(); imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); } else { JSTHROW_TYPE("Must pass image size"); } // Arg 5 is the first map type, skip for now - int m1type = info[5]->IntegerValue(); + int m1type = args[5]->IntegerValue(); // Make matrices to hold the output maps cv::Mat map1, map2; @@ -92,49 +92,49 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) { cv::initUndistortRectifyMap(K, dist, R, newK, imageSize, m1type, map1, map2); // Wrap the output maps - Local map1Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *map1Matrix = Nan::ObjectWrap::Unwrap(map1Wrap); + Local map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *map1Matrix = ObjectWrap::Unwrap(map1Wrap); map1Matrix->mat = map1; - Local map2Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *map2Matrix = Nan::ObjectWrap::Unwrap(map2Wrap); + Local map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *map2Matrix = ObjectWrap::Unwrap(map2Wrap); map2Matrix->mat = map2; // Make a return object with the two maps - Local ret = Nan::New(); - ret->Set(Nan::New("map1").ToLocalChecked(), map1Wrap); - ret->Set(Nan::New("map2").ToLocalChecked(), map2Wrap); + Local ret = NanNew(); + ret->Set(NanNew("map1"), map1Wrap); + ret->Set(NanNew("map2"), map2Wrap); // Return the maps - info.GetReturnValue().Set(ret); + NanReturnValue(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // cv::remap NAN_METHOD(ImgProc::Remap) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); try { // Get the arguments // Arg 0 is the image - Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Mat inputImage = m0->mat; // Arg 1 is the first map - Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::Mat map1 = m1->mat; // Arg 2 is the second map - Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); + Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); cv::Mat map2 = m2->mat; // Arg 3 is the interpolation mode - int interpolation = info[3]->IntegerValue(); + int interpolation = args[3]->IntegerValue(); // Args 4, 5 border settings, skipping for now @@ -145,15 +145,15 @@ NAN_METHOD(ImgProc::Remap) { cv::remap(inputImage, outputImage, map1, map2, interpolation); // Wrap the output image - Local outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *outMatrix = Nan::ObjectWrap::Unwrap(outMatrixWrap); + Local outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *outMatrix = ObjectWrap::Unwrap(outMatrixWrap); outMatrix->mat = outputImage; // Return the image - info.GetReturnValue().Set(outMatrixWrap); + NanReturnValue(outMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } diff --git a/src/ImgProc.h b/src/ImgProc.h index a73220a..8f7c504 100644 --- a/src/ImgProc.h +++ b/src/ImgProc.h @@ -6,7 +6,7 @@ /** * Implementation of imgproc.hpp functions */ -class ImgProc: public Nan::ObjectWrap { +class ImgProc: public node::ObjectWrap { public: static void Init(Handle target); static NAN_METHOD(Undistort); diff --git a/src/Matrix.cc b/src/Matrix.cc old mode 100644 new mode 100755 index 83d1634..3fec65b --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -3,156 +3,156 @@ #include "OpenCV.h" #include -Nan::Persistent Matrix::constructor; +v8::Persistent Matrix::constructor; cv::Scalar setColor(Local objColor); cv::Point setPoint(Local objPoint); cv::Rect* setRect(Local objRect, cv::Rect &result); void Matrix::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); //Class - Local ctor = Nan::New(Matrix::New); - constructor.Reset(ctor); + Local ctor = NanNew(Matrix::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("Matrix").ToLocalChecked()); + ctor->SetClassName(NanNew("Matrix")); // Prototype - 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); + 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); - target->Set(Nan::New("Matrix").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("Matrix"), ctor->GetFunction()); }; NAN_METHOD(Matrix::New) { - Nan::HandleScope scope; - if (info.This()->InternalFieldCount() == 0) { - Nan::ThrowTypeError("Cannot instantiate without new"); + NanScope(); + if (args.This()->InternalFieldCount() == 0) { + NanThrowTypeError("Cannot instantiate without new"); } Matrix *mat; - if (info.Length() == 0) { + if (args.Length() == 0) { mat = new Matrix; - } 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(info[0]->ToObject()); - int x = info[1]->IntegerValue(); - int y = info[2]->IntegerValue(); - int w = info[3]->IntegerValue(); - int h = info[4]->IntegerValue(); + } 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(args[0]->ToObject()); + int x = args[1]->IntegerValue(); + int y = args[2]->IntegerValue(); + int w = args[3]->IntegerValue(); + int h = args[4]->IntegerValue(); mat = new Matrix(other->mat, cv::Rect(x, y, w, h)); } - mat->Wrap(info.Holder()); - info.GetReturnValue().Set(info.Holder()); + mat->Wrap(args.Holder()); + NanReturnValue(args.Holder()); } Matrix::Matrix() : - Nan::ObjectWrap() { + ObjectWrap() { mat = cv::Mat(); } Matrix::Matrix(int rows, int cols) : - Nan::ObjectWrap() { + ObjectWrap() { mat = cv::Mat(rows, cols, CV_32FC3); } Matrix::Matrix(int rows, int cols, int type) : - Nan::ObjectWrap() { + ObjectWrap() { mat = cv::Mat(rows, cols, type); } Matrix::Matrix(cv::Mat m, cv::Rect roi) : - Nan::ObjectWrap() { + ObjectWrap() { mat = cv::Mat(m, roi); } @@ -168,13 +168,13 @@ Matrix::Matrix(int rows, int cols, int type, Local scalarObj) { } else if (mat.channels() == 1) { mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue())); } else { - Nan::ThrowError("Only 1-3 channels are supported"); + NanThrowError("Only 1-3 channels are supported"); } } NAN_METHOD(Matrix::Empty) { SETUP_FUNCTION(Matrix) - info.GetReturnValue().Set(Nan::New(self->mat.empty())); + NanReturnValue(NanNew(self->mat.empty())); } double Matrix::DblGet(cv::Mat mat, int i, int j) { @@ -205,13 +205,13 @@ double Matrix::DblGet(cv::Mat mat, int i, int j) { NAN_METHOD(Matrix::Pixel) { SETUP_FUNCTION(Matrix) - int y = info[0]->IntegerValue(); - int x = info[1]->IntegerValue(); + int y = args[0]->IntegerValue(); + int x = args[1]->IntegerValue(); // cv::Scalar scal = self->mat.at(y, x); - if (info.Length() == 3) { - Local < Object > objColor = info[2]->ToObject(); + if (args.Length() == 3) { + Local < Object > objColor = args[2]->ToObject(); if (self->mat.channels() == 3) { self->mat.at(y, x)[0] = @@ -223,48 +223,48 @@ NAN_METHOD(Matrix::Pixel) { } else if (self->mat.channels() == 1) self->mat.at(y, x) = (uchar) objColor->Get(0)->IntegerValue(); - info.GetReturnValue().Set(info[2]->ToObject()); + NanReturnValue(args[2]->ToObject()); } else { if (self->mat.channels() == 3) { cv::Vec3b intensity = self->mat.at(y, x); - v8::Local < v8::Array > arr = Nan::New(3); - arr->Set(0, Nan::New(intensity[0])); - arr->Set(1, Nan::New(intensity[1])); - arr->Set(2, Nan::New(intensity[2])); - info.GetReturnValue().Set(arr); + v8::Local < v8::Array > arr = NanNew(3); + arr->Set(0, NanNew(intensity[0])); + arr->Set(1, NanNew(intensity[1])); + arr->Set(2, NanNew(intensity[2])); + NanReturnValue(arr); } else if (self->mat.channels() == 1) { uchar intensity = self->mat.at(y, x); - info.GetReturnValue().Set(Nan::New(intensity)); + NanReturnValue(NanNew(intensity)); } } - return; + NanReturnUndefined(); // double val = Matrix::DblGet(t, i, j); - // info.GetReturnValue().Set(Nan::New(val)); + // NanReturnValue(NanNew(val)); } NAN_METHOD(Matrix::Get) { SETUP_FUNCTION(Matrix) - int i = info[0]->IntegerValue(); - int j = info[1]->IntegerValue(); + int i = args[0]->IntegerValue(); + int j = args[1]->IntegerValue(); double val = Matrix::DblGet(self->mat, i, j); - info.GetReturnValue().Set(Nan::New(val)); + NanReturnValue(NanNew(val)); } NAN_METHOD(Matrix::Set) { SETUP_FUNCTION(Matrix) - int i = info[0]->IntegerValue(); - int j = info[1]->IntegerValue(); - double val = info[2]->NumberValue(); + int i = args[0]->IntegerValue(); + int j = args[1]->IntegerValue(); + double val = args[2]->NumberValue(); int vint = 0; - if (info.Length() == 4) { - self->mat.at(i, j)[info[3]->NumberValue()] = val; - } else if (info.Length() == 3) { + if (args.Length() == 4) { + self->mat.at(i, j)[args[3]->NumberValue()] = val; + } else if (args.Length() == 3) { switch (self->mat.type()) { case CV_32FC3: vint = static_cast(val + 0.5); @@ -278,10 +278,10 @@ NAN_METHOD(Matrix::Set) { } } else { - Nan::ThrowTypeError("Invalid number of arguments"); + NanThrowTypeError("Invalid number of arguments"); } - return; + NanReturnUndefined(); } // @author tualo @@ -290,39 +290,39 @@ NAN_METHOD(Matrix::Set) { NAN_METHOD(Matrix::Put) { SETUP_FUNCTION(Matrix) - if (!Buffer::HasInstance(info[0])) { - Nan::ThrowTypeError("Not a buffer"); + if (!Buffer::HasInstance(args[0])) { + NanThrowTypeError("Not a buffer"); } - const char* buffer_data = Buffer::Data(info[0]); - size_t buffer_length = Buffer::Length(info[0]); + const char* buffer_data = Buffer::Data(args[0]); + size_t buffer_length = Buffer::Length(args[0]); memcpy(self->mat.data, buffer_data, buffer_length); - return; + NanReturnUndefined(); } // @author tualo // getData getting node buffer of image data NAN_METHOD(Matrix::GetData) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); int size = self->mat.rows * self->mat.cols * self->mat.elemSize1(); - Local buf = Nan::NewBuffer(size).ToLocalChecked(); + Local buf = NanNewBufferHandle(size); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, self->mat.data, size); - v8::Local globalObj = Nan::GetCurrentContext()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); - v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned) size), Nan::New(0)}; + v8::Local globalObj = NanGetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); + v8::Handle constructorArgs[3] = {buf, NanNew((unsigned) size), NanNew(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - info.GetReturnValue().Set(actualBuffer); + NanReturnValue(actualBuffer); } NAN_METHOD(Matrix::Brightness) { - Nan::HandleScope scope; - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + Matrix *self = ObjectWrap::Unwrap(args.This()); - if (info.Length() == 2) { + if (args.Length() == 2) { cv::Mat image; if (self->mat.channels() == 3) { @@ -331,12 +331,12 @@ NAN_METHOD(Matrix::Brightness) { cv::Mat myimg = self->mat; cv::cvtColor(myimg, image, CV_GRAY2RGB); } else { - Nan::ThrowError("those channels are not supported"); + NanThrowError("those channels are not supported"); } cv::Mat new_image = cv::Mat::zeros( image.size(), image.type() ); - double alpha = info[0]->NumberValue(); - int beta = info[1]->IntegerValue(); + double alpha = args[0]->NumberValue(); + int beta = args[1]->IntegerValue(); // Do the operation new_image(i,j) = alpha*image(i,j) + beta for (int y = 0; y < image.rows; y++ ) { @@ -356,56 +356,56 @@ NAN_METHOD(Matrix::Brightness) { gray.copyTo(self->mat); } } else { - if (info.Length() == 1) { - int diff = info[0]->IntegerValue(); + if (args.Length() == 1) { + int diff = args[0]->IntegerValue(); cv::Mat img = self->mat + diff; img.copyTo(self->mat); } else { - info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked()); + NanReturnValue(NanNew("Insufficient or wrong arguments")); } } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } // @author tualo // normalize wrapper NAN_METHOD(Matrix::Normalize) { - if (!info[0]->IsNumber()) { - Nan::ThrowTypeError("min is required (argument 1)"); + if (!args[0]->IsNumber()) { + NanThrowTypeError("min is required (argument 1)"); } - if (!info[1]->IsNumber()) { - Nan::ThrowTypeError("max is required (argument 2)"); + if (!args[1]->IsNumber()) { + NanThrowTypeError("max is required (argument 2)"); } int type = cv::NORM_MINMAX; - if (info[2]->IsNumber()) { - type = info[2]->Uint32Value(); + if (args[2]->IsNumber()) { + type = args[2]->Uint32Value(); if ((type != cv::NORM_MINMAX) || (type != cv::NORM_INF) || (type != cv::NORM_L1) || (type != cv::NORM_L2) || (type != cv::NORM_L2SQR) || (type != cv::NORM_HAMMING) || (type != cv::NORM_HAMMING2) || (type != cv::NORM_RELATIVE) || (type != cv::NORM_TYPE_MASK)) { - Nan::ThrowTypeError("type value must be NORM_INF=1, NORM_L1=2, NORM_L2=4," + NanThrowTypeError("type value must be NORM_INF=1, NORM_L1=2, NORM_L2=4," " NORM_L2SQR=5, NORM_HAMMING=6, NORM_HAMMING2=7, NORM_TYPE_MASK=7, " "NORM_RELATIVE=8, NORM_MINMAX=32 "); } } int dtype = -1; - if (info[3]->IsNumber()) { - dtype = info[3]->IntegerValue(); + if (args[3]->IsNumber()) { + dtype = args[3]->IntegerValue(); } - double min = info[0]->NumberValue(); - double max = info[1]->NumberValue(); + double min = args[0]->NumberValue(); + double max = args[1]->NumberValue(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); cv::Mat norm; cv::Mat mask; - if (info[4]->IsObject()) { - Matrix *mmask = Nan::ObjectWrap::Unwrap(info[4]->ToObject()); + if (args[4]->IsObject()) { + Matrix *mmask = ObjectWrap::Unwrap(args[4]->ToObject()); mask = mmask->mat; } @@ -413,52 +413,52 @@ NAN_METHOD(Matrix::Normalize) { norm.copyTo(self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Size) { SETUP_FUNCTION(Matrix) - v8::Local < v8::Array > arr = Nan::New(2); - arr->Set(0, Nan::New(self->mat.size().height)); - arr->Set(1, Nan::New(self->mat.size().width)); + v8::Local < v8::Array > arr = NanNew(2); + arr->Set(0, NanNew(self->mat.size().height)); + arr->Set(1, NanNew(self->mat.size().width)); - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::Clone) { SETUP_FUNCTION(Matrix) Local < Object > im_h = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m = Nan::ObjectWrap::Unwrap(im_h); + Matrix *m = ObjectWrap::Unwrap(im_h); m->mat = self->mat.clone(); - info.GetReturnValue().Set(im_h); + NanReturnValue(im_h); } NAN_METHOD(Matrix::Crop) { SETUP_FUNCTION(Matrix) - if ((info.Length() == 4) && (info[0]->IsNumber()) && (info[1]->IsNumber()) - && (info[2]->IsNumber()) && (info[3]->IsNumber())) { + if ((args.Length() == 4) && (args[0]->IsNumber()) && (args[1]->IsNumber()) + && (args[2]->IsNumber()) && (args[3]->IsNumber())) { - int x = info[0]->IntegerValue(); - int y = info[1]->IntegerValue(); - int width = info[2]->IntegerValue(); - int height = info[3]->IntegerValue(); + int x = args[0]->IntegerValue(); + int y = args[1]->IntegerValue(); + int width = args[2]->IntegerValue(); + int height = args[3]->IntegerValue(); cv::Rect roi(x, y, width, height); Local < Object > im_h = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m = Nan::ObjectWrap::Unwrap(im_h); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m = ObjectWrap::Unwrap(im_h); m->mat = self->mat(roi); - info.GetReturnValue().Set(im_h); + NanReturnValue(im_h); } else { - info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked()); + NanReturnValue(NanNew("Insufficient or wrong arguments")); } } @@ -466,89 +466,89 @@ NAN_METHOD(Matrix::Row) { SETUP_FUNCTION(Matrix) int width = self->mat.size().width; - int y = info[0]->IntegerValue(); - v8::Local < v8::Array > arr = Nan::New(width); + int y = args[0]->IntegerValue(); + v8::Local < v8::Array > arr = NanNew(width); for (int x = 0; x < width; x++) { double v = Matrix::DblGet(self->mat, y, x); - arr->Set(x, Nan::New(v)); + arr->Set(x, NanNew(v)); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::PixelRow) { SETUP_FUNCTION(Matrix) int width = self->mat.size().width; - int y = info[0]->IntegerValue(); - v8::Local < v8::Array > arr = Nan::New(width * 3); + int y = args[0]->IntegerValue(); + v8::Local < v8::Array > arr = NanNew(width * 3); for (int x = 0; x < width; x++) { cv::Vec3b pixel = self->mat.at(y, x); int offset = x * 3; - arr->Set(offset, Nan::New((double) pixel.val[0])); - arr->Set(offset + 1, Nan::New((double) pixel.val[1])); - arr->Set(offset + 2, Nan::New((double) pixel.val[2])); + arr->Set(offset, NanNew((double) pixel.val[0])); + arr->Set(offset + 1, NanNew((double) pixel.val[1])); + arr->Set(offset + 2, NanNew((double) pixel.val[2])); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::Col) { SETUP_FUNCTION(Matrix) int height = self->mat.size().height; - int x = info[0]->IntegerValue(); - v8::Local < v8::Array > arr = Nan::New(height); + int x = args[0]->IntegerValue(); + v8::Local < v8::Array > arr = NanNew(height); for (int y = 0; y < height; y++) { double v = Matrix::DblGet(self->mat, y, x); - arr->Set(y, Nan::New(v)); + arr->Set(y, NanNew(v)); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::PixelCol) { SETUP_FUNCTION(Matrix) int height = self->mat.size().height; - int x = info[0]->IntegerValue(); - v8::Local < v8::Array > arr = Nan::New(height * 3); + int x = args[0]->IntegerValue(); + v8::Local < v8::Array > arr = NanNew(height * 3); for (int y = 0; y < height; y++) { cv::Vec3b pixel = self->mat.at(y, x); int offset = y * 3; - arr->Set(offset, Nan::New((double) pixel.val[0])); - arr->Set(offset + 1, Nan::New((double) pixel.val[1])); - arr->Set(offset + 2, Nan::New((double) pixel.val[2])); + arr->Set(offset, NanNew((double) pixel.val[0])); + arr->Set(offset + 1, NanNew((double) pixel.val[1])); + arr->Set(offset + 2, NanNew((double) pixel.val[2])); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::Width) { SETUP_FUNCTION(Matrix) - info.GetReturnValue().Set(Nan::New(self->mat.size().width)); + NanReturnValue(NanNew(self->mat.size().width)); } NAN_METHOD(Matrix::Height) { SETUP_FUNCTION(Matrix) - info.GetReturnValue().Set(Nan::New(self->mat.size().height)); + NanReturnValue(NanNew(self->mat.size().height)); } NAN_METHOD(Matrix::Channels) { SETUP_FUNCTION(Matrix) - info.GetReturnValue().Set(Nan::New(self->mat.channels())); + NanReturnValue(NanNew(self->mat.channels())); } NAN_METHOD(Matrix::ToBuffer) { SETUP_FUNCTION(Matrix) - if ((info.Length() > 0) && (info[0]->IsFunction())) { - return Matrix::ToBufferAsync(info); + if ((args.Length() > 0) && (args[0]->IsFunction())) { + return Matrix::ToBufferAsync(args); } // SergeMv changes @@ -564,25 +564,25 @@ NAN_METHOD(Matrix::ToBuffer) { std::vector params; // See if the options argument is passed - if ((info.Length() > 0) && (info[0]->IsObject())) { + if ((args.Length() > 0) && (args[0]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); + v8::Handle < v8::Object > options = v8::Handle::Cast(args[0]); // If the extension (image format) is provided - if (options->Has(Nan::New("ext").ToLocalChecked())) { + if (options->Has(NanNew("ext"))) { v8::String::Utf8Value str( - options->Get(Nan::New("ext").ToLocalChecked())->ToString()); + options->Get(NanNew("ext"))->ToString()); optExt = *str; ext = (const char *) optExt.c_str(); } - if (options->Has(Nan::New("jpegQuality").ToLocalChecked())) { + if (options->Has(NanNew("jpegQuality"))) { int compression = - options->Get(Nan::New("jpegQuality").ToLocalChecked())->IntegerValue(); + options->Get(NanNew("jpegQuality"))->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(Nan::New("pngCompression").ToLocalChecked())) { + if (options->Has(NanNew("pngCompression"))) { int compression = - options->Get(Nan::New("pngCompression").ToLocalChecked())->IntegerValue(); + options->Get(NanNew("pngCompression"))->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } @@ -593,26 +593,26 @@ NAN_METHOD(Matrix::ToBuffer) { cv::imencode(ext, self->mat, vec, params); - Local < Object > buf = Nan::NewBuffer(vec.size()).ToLocalChecked(); + Local < Object > buf = NanNewBufferHandle(vec.size()); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, &vec[0], vec.size()); - v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global(); + v8::Local < v8::Object > globalObj = NanGetCurrentContext()->Global(); v8::Local < v8::Function > bufferConstructor = v8::Local < v8::Function - > ::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); + > ::Cast(globalObj->Get(NanNew("Buffer"))); v8::Handle constructorArgs[3] = - {buf, Nan::New((unsigned)vec.size()), Nan::New(0)}; + {buf, NanNew((unsigned)vec.size()), NanNew(0)}; v8::Local < v8::Object > actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - info.GetReturnValue().Set(actualBuffer); + NanReturnValue(actualBuffer); } -class AsyncToBufferWorker: public Nan::AsyncWorker { +class AsyncToBufferWorker: public NanAsyncWorker { public: - AsyncToBufferWorker(Nan::Callback *callback, Matrix* matrix, string ext, + AsyncToBufferWorker(NanCallback *callback, Matrix* matrix, string ext, vector params) : - Nan::AsyncWorker(callback), + NanAsyncWorker(callback), matrix(matrix), ext(ext), params(params) { @@ -629,19 +629,19 @@ public: } void HandleOKCallback() { - Nan::HandleScope scope; + NanScope(); - Local buf = Nan::NewBuffer(res.size()).ToLocalChecked(); + Local buf = NanNewBufferHandle(res.size()); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, &res[0], res.size()); - v8::Local globalObj = Nan::GetCurrentContext()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); - v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned)res.size()), Nan::New(0)}; + v8::Local globalObj = NanGetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); + v8::Handle constructorArgs[3] = {buf, NanNew((unsigned)res.size()), NanNew(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); Local argv[] = { - Nan::Null(), + NanNull(), actualBuffer }; @@ -669,34 +669,34 @@ NAN_METHOD(Matrix::ToBufferAsync) { std::vector params; // See if the options argument is passed - if ((info.Length() > 1) && (info[1]->IsObject())) { + if ((args.Length() > 1) && (args[1]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(info[1]); + v8::Handle < v8::Object > options = v8::Handle::Cast(args[1]); // If the extension (image format) is provided - if (options->Has(Nan::New("ext").ToLocalChecked())) { + if (options->Has(NanNew("ext"))) { v8::String::Utf8Value str( - options->Get(Nan::New("ext").ToLocalChecked())->ToString()); + options->Get(NanNew("ext"))->ToString()); std::string str2 = std::string(*str); ext = str2; } - if (options->Has(Nan::New("jpegQuality").ToLocalChecked())) { + if (options->Has(NanNew("jpegQuality"))) { int compression = - options->Get(Nan::New("jpegQuality").ToLocalChecked())->IntegerValue(); + options->Get(NanNew("jpegQuality"))->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(Nan::New("pngCompression").ToLocalChecked())) { + if (options->Has(NanNew("pngCompression"))) { int compression = - options->Get(Nan::New("pngCompression").ToLocalChecked())->IntegerValue(); + options->Get(NanNew("pngCompression"))->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } } - Nan::Callback *callback = new Nan::Callback(cb.As()); - Nan::AsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::Ellipse) { @@ -714,73 +714,73 @@ NAN_METHOD(Matrix::Ellipse) { int lineType = 8; int shift = 0; - if (info[0]->IsObject()) { - v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); - if (options->Has(Nan::New("center").ToLocalChecked())) { + if (args[0]->IsObject()) { + v8::Handle < v8::Object > options = v8::Handle::Cast(args[0]); + if (options->Has(NanNew("center"))) { Local < Object > center = - options->Get(Nan::New("center").ToLocalChecked())->ToObject(); - x = center->Get(Nan::New("x").ToLocalChecked())->Uint32Value(); - y = center->Get(Nan::New("y").ToLocalChecked())->Uint32Value(); + options->Get(NanNew("center"))->ToObject(); + x = center->Get(NanNew("x"))->Uint32Value(); + y = center->Get(NanNew("y"))->Uint32Value(); } - if (options->Has(Nan::New("axes").ToLocalChecked())) { - Local < Object > axes = options->Get(Nan::New("axes").ToLocalChecked())->ToObject(); - width = axes->Get(Nan::New("width").ToLocalChecked())->Uint32Value(); - height = axes->Get(Nan::New("height").ToLocalChecked())->Uint32Value(); + if (options->Has(NanNew("axes"))) { + Local < Object > axes = options->Get(NanNew("axes"))->ToObject(); + width = axes->Get(NanNew("width"))->Uint32Value(); + height = axes->Get(NanNew("height"))->Uint32Value(); } - if (options->Has(Nan::New("thickness").ToLocalChecked())) { - thickness = options->Get(Nan::New("thickness").ToLocalChecked())->Uint32Value(); + if (options->Has(NanNew("thickness"))) { + thickness = options->Get(NanNew("thickness"))->Uint32Value(); } - if (options->Has(Nan::New("angle").ToLocalChecked())) { - angle = options->Get(Nan::New("angle").ToLocalChecked())->NumberValue(); + if (options->Has(NanNew("angle"))) { + angle = options->Get(NanNew("angle"))->NumberValue(); } - if (options->Has(Nan::New("startAngle").ToLocalChecked())) { - startAngle = options->Get(Nan::New("startAngle").ToLocalChecked())->NumberValue(); + if (options->Has(NanNew("startAngle"))) { + startAngle = options->Get(NanNew("startAngle"))->NumberValue(); } - if (options->Has(Nan::New("endAngle").ToLocalChecked())) { - endAngle = options->Get(Nan::New("endAngle").ToLocalChecked())->NumberValue(); + if (options->Has(NanNew("endAngle"))) { + endAngle = options->Get(NanNew("endAngle"))->NumberValue(); } - if (options->Has(Nan::New("lineType").ToLocalChecked())) { - lineType = options->Get(Nan::New("lineType").ToLocalChecked())->Uint32Value(); + if (options->Has(NanNew("lineType"))) { + lineType = options->Get(NanNew("lineType"))->Uint32Value(); } - if (options->Has(Nan::New("shift").ToLocalChecked())) { - shift = options->Get(Nan::New("shift").ToLocalChecked())->Uint32Value(); + if (options->Has(NanNew("shift"))) { + shift = options->Get(NanNew("shift"))->Uint32Value(); } - if (options->Has(Nan::New("color").ToLocalChecked())) { + if (options->Has(NanNew("color"))) { Local < Object > objColor = - options->Get(Nan::New("color").ToLocalChecked())->ToObject(); + options->Get(NanNew("color"))->ToObject(); color = setColor(objColor); } } else { - x = info[0]->Uint32Value(); - y = info[1]->Uint32Value(); - width = info[2]->Uint32Value(); - height = info[3]->Uint32Value(); + x = args[0]->Uint32Value(); + y = args[1]->Uint32Value(); + width = args[2]->Uint32Value(); + height = args[3]->Uint32Value(); - if (info[4]->IsArray()) { - Local < Object > objColor = info[4]->ToObject(); + if (args[4]->IsArray()) { + Local < Object > objColor = args[4]->ToObject(); color = setColor(objColor); } - if (info[5]->IntegerValue()) - thickness = info[5]->IntegerValue(); + if (args[5]->IntegerValue()) + thickness = args[5]->IntegerValue(); } cv::ellipse(self->mat, cv::Point(x, y), cv::Size(width, height), angle, startAngle, endAngle, color, thickness, lineType, shift); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Rectangle) { SETUP_FUNCTION(Matrix) - if (info[0]->IsArray() && info[1]->IsArray()) { - Local < Object > xy = info[0]->ToObject(); - Local < Object > width_height = info[1]->ToObject(); + if (args[0]->IsArray() && args[1]->IsArray()) { + Local < Object > xy = args[0]->ToObject(); + Local < Object > width_height = args[1]->ToObject(); cv::Scalar color(0, 0, 255); - if (info[2]->IsArray()) { - Local < Object > objColor = info[2]->ToObject(); + if (args[2]->IsArray()) { + Local < Object > objColor = args[2]->ToObject(); color = setColor(objColor); } @@ -792,27 +792,27 @@ NAN_METHOD(Matrix::Rectangle) { int thickness = 1; - if (info[3]->IntegerValue()) - thickness = info[3]->IntegerValue(); + if (args[3]->IntegerValue()) + thickness = args[3]->IntegerValue(); cv::rectangle(self->mat, cv::Point(x, y), cv::Point(x + width, y + height), color, thickness); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Line) { SETUP_FUNCTION(Matrix) - if (info[0]->IsArray() && info[1]->IsArray()) { - Local < Object > xy1 = info[0]->ToObject(); - Local < Object > xy2 = info[1]->ToObject(); + if (args[0]->IsArray() && args[1]->IsArray()) { + Local < Object > xy1 = args[0]->ToObject(); + Local < Object > xy2 = args[1]->ToObject(); cv::Scalar color(0, 0, 255); - if (info[2]->IsArray()) { - Local < Object > objColor = info[2]->ToObject(); + if (args[2]->IsArray()) { + Local < Object > objColor = args[2]->ToObject(); color = setColor(objColor); } @@ -824,20 +824,20 @@ NAN_METHOD(Matrix::Line) { int thickness = 1; - if (info[3]->IntegerValue()) - thickness = info[3]->IntegerValue(); + if (args[3]->IntegerValue()) + thickness = args[3]->IntegerValue(); cv::line(self->mat, cv::Point(x1, y1), cv::Point(x2, y2), color, thickness); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::FillPoly) { SETUP_FUNCTION(Matrix) - if (info[0]->IsArray()) { - Local < Array > polyArray = Local < Array > ::Cast(info[0]->ToObject()); + if (args[0]->IsArray()) { + Local < Array > polyArray = Local < Array > ::Cast(args[0]->ToObject()); cv::Point **polygons = new cv::Point*[polyArray->Length()]; int *polySizes = new int[polyArray->Length()]; @@ -854,8 +854,8 @@ NAN_METHOD(Matrix::FillPoly) { } cv::Scalar color(0, 0, 255); - if (info[1]->IsArray()) { - Local objColor = info[1]->ToObject(); + if (args[1]->IsArray()) { + Local objColor = args[1]->ToObject(); color = setColor(objColor); } @@ -863,32 +863,32 @@ NAN_METHOD(Matrix::FillPoly) { polyArray->Length(), color); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Save) { SETUP_FUNCTION(Matrix) - if (info.Length() > 1) { - return SaveAsync(info); + if (args.Length() > 1) { + return SaveAsync(args); } - if (!info[0]->IsString()) { - Nan::ThrowTypeError("filename required"); + if (!args[0]->IsString()) { + NanThrowTypeError("filename required"); } - Nan::Utf8String filename(info[0]); + NanAsciiString filename(args[0]); int res = cv::imwrite(*filename, self->mat); - info.GetReturnValue().Set(Nan::New(res)); + NanReturnValue(NanNew(res)); } // All this is for async save, see here for nan example: // https://github.com/rvagg/nan/blob/c579ae858ae3208d7e702e8400042ba9d48fa64b/examples/async_pi_estimate/async.cc -class AsyncSaveWorker: public Nan::AsyncWorker { +class AsyncSaveWorker: public NanAsyncWorker { public: - AsyncSaveWorker(Nan::Callback *callback, Matrix* matrix, char* filename) : - Nan::AsyncWorker(callback), + AsyncSaveWorker(NanCallback *callback, Matrix* matrix, char* filename) : + NanAsyncWorker(callback), matrix(matrix), filename(filename) { } @@ -908,11 +908,11 @@ public: // this function will be run inside the main event loop // so it is safe to use V8 again void HandleOKCallback() { - Nan::HandleScope scope; + NanScope(); Local argv[] = { - Nan::Null(), - Nan::New(res) + NanNull(), + NanNew(res) }; TryCatch try_catch; @@ -931,71 +931,71 @@ private: NAN_METHOD(Matrix::SaveAsync) { SETUP_FUNCTION(Matrix) - if (!info[0]->IsString()) { - Nan::ThrowTypeError("filename required"); + if (!args[0]->IsString()) { + NanThrowTypeError("filename required"); } - Nan::Utf8String filename(info[0]); + NanAsciiString filename(args[0]); REQ_FUN_ARG(1, cb); - Nan::Callback *callback = new Nan::Callback(cb.As()); - Nan::AsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::Zeros) { - Nan::HandleScope scope; + NanScope(); - int w = info[0]->Uint32Value(); - int h = info[1]->Uint32Value(); - int type = (info.Length() > 2) ? info[2]->IntegerValue() : CV_64FC1; + int w = args[0]->Uint32Value(); + int h = args[1]->Uint32Value(); + int type = (args.Length() > 2) ? args[2]->IntegerValue() : CV_64FC1; - Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im_h); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::zeros(w, h, type); img->mat = mat; - info.GetReturnValue().Set(im_h); + NanReturnValue(im_h); } NAN_METHOD(Matrix::Ones) { - Nan::HandleScope scope; + NanScope(); - int w = info[0]->Uint32Value(); - int h = info[1]->Uint32Value(); - int type = (info.Length() > 2) ? info[2]->IntegerValue() : CV_64FC1; + int w = args[0]->Uint32Value(); + int h = args[1]->Uint32Value(); + int type = (args.Length() > 2) ? args[2]->IntegerValue() : CV_64FC1; - Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im_h); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::ones(w, h, type); img->mat = mat; - info.GetReturnValue().Set(im_h); + NanReturnValue(im_h); } NAN_METHOD(Matrix::Eye) { - Nan::HandleScope scope; + NanScope(); - int w = info[0]->Uint32Value(); - int h = info[1]->Uint32Value(); - int type = (info.Length() > 2) ? info[2]->IntegerValue() : CV_64FC1; + int w = args[0]->Uint32Value(); + int h = args[1]->Uint32Value(); + int type = (args.Length() > 2) ? args[2]->IntegerValue() : CV_64FC1; - Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im_h); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::eye(w, h, type); img->mat = mat; - info.GetReturnValue().Set(im_h); + NanReturnValue(im_h); } NAN_METHOD(Matrix::ConvertGrayscale) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); if (self->mat.channels() != 3) { - Nan::ThrowError("Image is no 3-channel"); + NanThrowError("Image is no 3-channel"); } cv::Mat gray; @@ -1003,15 +1003,15 @@ NAN_METHOD(Matrix::ConvertGrayscale) { cv::cvtColor(self->mat, gray, CV_BGR2GRAY); gray.copyTo(self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::ConvertHSVscale) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); if (self->mat.channels() != 3) { - Nan::ThrowError("Image is no 3-channel"); + NanThrowError("Image is no 3-channel"); } cv::Mat hsv; @@ -1019,29 +1019,29 @@ NAN_METHOD(Matrix::ConvertHSVscale) { cv::cvtColor(self->mat, hsv, CV_BGR2HSV); hsv.copyTo(self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::GaussianBlur) { - Nan::HandleScope scope; + NanScope(); cv::Size ksize; cv::Mat blurred; - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - if (info.Length() < 1) { + if (args.Length() < 1) { ksize = cv::Size(5, 5); } else { - if (!info[0]->IsArray()) { - Nan::ThrowTypeError("'ksize' argument must be a 2 double array"); + if (!args[0]->IsArray()) { + NanThrowTypeError("'ksize' argument must be a 2 double array"); } - Local array = info[0]->ToObject(); + Local array = args[0]->ToObject(); // TODO: Length check Local x = array->Get(0); Local y = array->Get(1); if (!x->IsNumber() || !y->IsNumber()) { - Nan::ThrowTypeError("'ksize' argument must be a 2 double array"); + NanThrowTypeError("'ksize' argument must be a 2 double array"); } ksize = cv::Size(x->NumberValue(), y->NumberValue()); } @@ -1049,49 +1049,49 @@ NAN_METHOD(Matrix::GaussianBlur) { cv::GaussianBlur(self->mat, blurred, ksize, 0); blurred.copyTo(self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::MedianBlur) { - Nan::HandleScope scope; + NanScope(); cv::Mat blurred; int ksize = 3; - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - if (info[0]->IsNumber()) { - ksize = info[0]->IntegerValue(); + if (args[0]->IsNumber()) { + ksize = args[0]->IntegerValue(); if ((ksize % 2) == 0) { - Nan::ThrowTypeError("'ksize' argument must be a positive odd integer"); + NanThrowTypeError("'ksize' argument must be a positive odd integer"); } } else { - Nan::ThrowTypeError("'ksize' argument must be a positive odd integer"); + NanThrowTypeError("'ksize' argument must be a positive odd integer"); } cv::medianBlur(self->mat, blurred, ksize); blurred.copyTo(self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BilateralFilter) { - Nan::HandleScope scope; + NanScope(); cv::Mat filtered; int d = 15; double sigmaColor = 80; double sigmaSpace = 80; int borderType = cv::BORDER_DEFAULT; - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - if (info.Length() != 0) { - if (info.Length() < 3 || info.Length() > 4) { - Nan::ThrowTypeError("BilateralFilter takes 0, 3, or 4 arguments"); + if (args.Length() != 0) { + if (args.Length() < 3 || args.Length() > 4) { + NanThrowTypeError("BilateralFilter takes 0, 3, or 4 arguments"); } else { - d = info[0]->IntegerValue(); - sigmaColor = info[1]->NumberValue(); - sigmaSpace = info[2]->NumberValue(); - if (info.Length() == 4) { - borderType = info[3]->IntegerValue(); + d = args[0]->IntegerValue(); + sigmaColor = args[1]->NumberValue(); + sigmaSpace = args[2]->NumberValue(); + if (args.Length() == 4) { + borderType = args[3]->IntegerValue(); } } } @@ -1099,276 +1099,276 @@ NAN_METHOD(Matrix::BilateralFilter) { cv::bilateralFilter(self->mat, filtered, d, sigmaColor, sigmaSpace, borderType); filtered.copyTo(self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Copy) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); Local img_to_return = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); - info.GetReturnValue().Set(img_to_return); + NanReturnValue(img_to_return); } NAN_METHOD(Matrix::Flip) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - if ( info.Length() < 1 || !info[0]->IsInt32() ) { - Nan::ThrowTypeError("Flip requires an integer flipCode argument " + if ( args.Length() < 1 || !args[0]->IsInt32() ) { + NanThrowTypeError("Flip requires an integer flipCode argument " "(0 = X axis, positive = Y axis, negative = both axis)"); } - int flipCode = info[0]->ToInt32()->Value(); + int flipCode = args[0]->ToInt32()->Value(); - Local img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); cv::flip(self->mat, img->mat, flipCode); - info.GetReturnValue().Set(img_to_return); + NanReturnValue(img_to_return); } NAN_METHOD(Matrix::ROI) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - if ( info.Length() != 4 ) { - Nan::ThrowTypeError("ROI requires x,y,w,h arguments"); + if ( args.Length() != 4 ) { + NanThrowTypeError("ROI requires x,y,w,h arguments"); } // Although it's an image to return, it is in fact a pointer to ROI of parent matrix - Local img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); - int x = info[0]->IntegerValue(); - int y = info[1]->IntegerValue(); - int w = info[2]->IntegerValue(); - int h = info[3]->IntegerValue(); + int x = args[0]->IntegerValue(); + int y = args[1]->IntegerValue(); + int w = args[2]->IntegerValue(); + int h = args[3]->IntegerValue(); cv::Mat roi(self->mat, cv::Rect(x,y,w,h)); img->mat = roi; - info.GetReturnValue().Set(img_to_return); + NanReturnValue(img_to_return); } NAN_METHOD(Matrix::Ptr) { - Nan::HandleScope scope; - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - int line = info[0]->Uint32Value(); + NanScope(); + Matrix *self = ObjectWrap::Unwrap(args.This()); + int line = args[0]->Uint32Value(); char* data = self->mat.ptr(line); // uchar* data = self->mat.data; // char *mydata = "Random raw data\0"; - Local return_buffer = Nan::NewBuffer((char*)data, self->mat.step).ToLocalChecked(); - info.GetReturnValue().Set( return_buffer ); -// return; + Local return_buffer = NanNewBufferHandle((char*)data, self->mat.step); + NanReturnValue( return_buffer ); +// NanReturnUndefined(); } NAN_METHOD(Matrix::AbsDiff) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::absdiff(src1->mat, src2->mat, self->mat); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::AddWeighted) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - Matrix *src2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *src2 = ObjectWrap::Unwrap(args[2]->ToObject()); - float alpha = info[1]->NumberValue(); - float beta = info[3]->NumberValue(); + float alpha = args[1]->NumberValue(); + float beta = args[3]->NumberValue(); int gamma = 0; try { cv::addWeighted(src1->mat, alpha, src2->mat, beta, gamma, self->mat); } catch(cv::Exception& e ) { const char* err_msg = e.what(); - Nan::ThrowError(err_msg); + NanThrowError(err_msg); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BitwiseXor) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); - if (info.Length() == 3) { - Matrix *mask = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); + if (args.Length() == 3) { + Matrix *mask = ObjectWrap::Unwrap(args[2]->ToObject()); cv::bitwise_xor(src1->mat, src2->mat, self->mat, mask->mat); } else { cv::bitwise_xor(src1->mat, src2->mat, self->mat); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BitwiseNot) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Matrix *dst = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - if (info.Length() == 2) { - Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *dst = ObjectWrap::Unwrap(args[0]->ToObject()); + if (args.Length() == 2) { + Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); cv::bitwise_not(self->mat, dst->mat, mask->mat); } else { cv::bitwise_not(self->mat, dst->mat); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BitwiseAnd) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); - if (info.Length() == 3) { - Matrix *mask = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); + if (args.Length() == 3) { + Matrix *mask = ObjectWrap::Unwrap(args[2]->ToObject()); cv::bitwise_and(src1->mat, src2->mat, self->mat, mask->mat); } else { cv::bitwise_and(src1->mat, src2->mat, self->mat); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::CountNonZero) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); double count = (double)cv::countNonZero(self->mat); - info.GetReturnValue().Set(Nan::New(count)); + NanReturnValue(NanNew(count)); } /* NAN_METHOD(Matrix::Split) { - Nan::HandleScope scope; + NanScope(); - //Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + //Matrix *self = ObjectWrap::Unwrap(args.This()); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } */ NAN_METHOD(Matrix::Canny) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - int lowThresh = info[0]->NumberValue(); - int highThresh = info[1]->NumberValue(); + Matrix *self = ObjectWrap::Unwrap(args.This()); + int lowThresh = args[0]->NumberValue(); + int highThresh = args[1]->NumberValue(); cv::Canny(self->mat, self->mat, lowThresh, highThresh); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Dilate) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - int niters = info[0]->NumberValue(); + Matrix *self = ObjectWrap::Unwrap(args.This()); + int niters = args[0]->NumberValue(); cv::dilate(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Erode) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - int niters = info[0]->NumberValue(); + Matrix *self = ObjectWrap::Unwrap(args.This()); + int niters = args[0]->NumberValue(); cv::erode(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::FindContours) { - Nan::HandleScope scope; + NanScope(); int mode = CV_RETR_LIST; int chain = CV_CHAIN_APPROX_SIMPLE; - if (info.Length() > 0) { - if (info[0]->IsNumber()) mode = info[0]->IntegerValue(); + if (args.Length() > 0) { + if (args[0]->IsNumber()) mode = args[0]->IntegerValue(); } - if (info.Length() > 1) { - if (info[1]->IsNumber()) chain = info[1]->IntegerValue(); + if (args.Length() > 1) { + if (args[1]->IsNumber()) chain = args[1]->IntegerValue(); } - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Local conts_to_return= Nan::New(Contour::constructor)->GetFunction()->NewInstance(); - Contour *contours = Nan::ObjectWrap::Unwrap(conts_to_return); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Local conts_to_return= NanNew(Contour::constructor)->GetFunction()->NewInstance(); + Contour *contours = ObjectWrap::Unwrap(conts_to_return); cv::findContours(self->mat, contours->contours, contours->hierarchy, mode, chain); - info.GetReturnValue().Set(conts_to_return); + NanReturnValue(conts_to_return); } NAN_METHOD(Matrix::DrawContour) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Contour *cont = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - int pos = info[1]->NumberValue(); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); + int pos = args[1]->NumberValue(); cv::Scalar color(0, 0, 255); - if (info[2]->IsArray()) { - Local objColor = info[2]->ToObject(); + if (args[2]->IsArray()) { + Local objColor = args[2]->ToObject(); color = setColor(objColor); } - int thickness = info.Length() < 4 ? 1 : info[3]->NumberValue(); + int thickness = args.Length() < 4 ? 1 : args[3]->NumberValue(); cv::drawContours(self->mat, cont->contours, pos, color, thickness); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::DrawAllContours) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Contour *cont = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Scalar color(0, 0, 255); - if (info[1]->IsArray()) { - Local objColor = info[1]->ToObject(); + if (args[1]->IsArray()) { + Local objColor = args[1]->ToObject(); color = setColor(objColor); } - int thickness = info.Length() < 3 ? 1 : info[2]->NumberValue(); + int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue(); cv::drawContours(self->mat, cont->contours, -1, color, thickness); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::GoodFeaturesToTrack) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); std::vector corners; cv::Mat gray; @@ -1376,27 +1376,27 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) { equalizeHist(gray, gray); cv::goodFeaturesToTrack(gray, corners, 500, 0.01, 10); - v8::Local arr = Nan::New(corners.size()); + v8::Local arr = NanNew(corners.size()); for (unsigned int i=0; i pt = Nan::New(2); - pt->Set(0, Nan::New((double) corners[i].x)); - pt->Set(1, Nan::New((double) corners[i].y)); + v8::Local pt = NanNew(2); + pt->Set(0, NanNew((double) corners[i].x)); + pt->Set(1, NanNew((double) corners[i].y)); arr->Set(i, pt); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::HoughLinesP) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(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(); + Matrix *self = ObjectWrap::Unwrap(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(); std::vector lines; cv::Mat gray; @@ -1405,31 +1405,31 @@ NAN_METHOD(Matrix::HoughLinesP) { // cv::Canny(gray, gray, 50, 200, 3); cv::HoughLinesP(gray, lines, rho, theta, threshold, minLineLength, maxLineGap); - v8::Local arr = Nan::New(lines.size()); + v8::Local arr = NanNew(lines.size()); for (unsigned int i=0; i pt = Nan::New(4); - pt->Set(0, Nan::New((double) lines[i][0])); - pt->Set(1, Nan::New((double) lines[i][1])); - pt->Set(2, Nan::New((double) lines[i][2])); - pt->Set(3, Nan::New((double) lines[i][3])); + v8::Local pt = NanNew(4); + pt->Set(0, NanNew((double) lines[i][0])); + pt->Set(1, NanNew((double) lines[i][1])); + pt->Set(2, NanNew((double) lines[i][2])); + pt->Set(3, NanNew((double) lines[i][3])); arr->Set(i, pt); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::HoughCircles) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - 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(); + 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(); std::vector circles; cv::Mat gray; @@ -1439,17 +1439,17 @@ NAN_METHOD(Matrix::HoughCircles) { cv::HoughCircles(gray, circles, CV_HOUGH_GRADIENT, dp, minDist, higherThreshold, accumulatorThreshold, minRadius, maxRadius); - v8::Local arr = Nan::New(circles.size()); + v8::Local arr = NanNew(circles.size()); for (unsigned int i=0; i < circles.size(); i++) { - v8::Local pt = Nan::New(3); - pt->Set(0, Nan::New((double) circles[i][0])); // center x - pt->Set(1, Nan::New((double) circles[i][1]));// center y - pt->Set(2, Nan::New((double) circles[i][2]));// radius + v8::Local pt = NanNew(3); + pt->Set(0, NanNew((double) circles[i][0])); // center x + pt->Set(1, NanNew((double) circles[i][1]));// center y + pt->Set(2, NanNew((double) circles[i][2]));// radius arr->Set(i, pt); } - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } cv::Scalar setColor(Local objColor) { @@ -1486,10 +1486,10 @@ cv::Rect* setRect(Local objRect, cv::Rect &result) { } NAN_METHOD(Matrix::Resize) { - Nan::HandleScope scope; + NanScope(); - int x = info[0]->Uint32Value(); - int y = info[1]->Uint32Value(); + int x = args[0]->Uint32Value(); + int y = args[1]->Uint32Value(); /* CV_INTER_NN =0, CV_INTER_LINEAR =1, @@ -1497,35 +1497,35 @@ NAN_METHOD(Matrix::Resize) { CV_INTER_AREA =3, CV_INTER_LANCZOS4 =4 */ - int interpolation = (info.Length() < 3) ? (int)cv::INTER_LINEAR : info[2]->Uint32Value(); + int interpolation = (args.Length() < 3) ? (int)cv::INTER_LINEAR : args[2]->Uint32Value(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); cv::Mat res = cv::Mat(x, y, CV_32FC3); cv::resize(self->mat, res, cv::Size(x, y), 0, 0, interpolation); ~self->mat; self->mat = res; - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::Rotate) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); cv::Mat rotMatrix(2, 3, CV_32FC1); cv::Mat res; - float angle = info[0]->ToNumber()->Value(); + float angle = args[0]->ToNumber()->Value(); // Modification by SergeMv //------------- // If you provide only the angle argument and the angle is multiple of 90, then // we do a fast thing bool rightOrStraight = (ceil(angle) == angle) && (!((int)angle % 90)) - && (info.Length() == 1); + && (args.Length() == 1); if (rightOrStraight) { int angle2 = ((int)angle) % 360; - if (!angle2) {return;} + if (!angle2) {NanReturnUndefined();} if (angle2 < 0) {angle2 += 360;} // See if we do right angle rotation, we transpose the matrix: if (angle2 % 180) { @@ -1540,14 +1540,14 @@ NAN_METHOD(Matrix::Rotate) { // If clockwise, flip around the y-axis if (angle2 == 270) {mode = 1;} cv::flip(self->mat, self->mat, mode); - return; + NanReturnUndefined(); } //------------- - 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(); + 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(); cv::Point center = cv::Point(x,y); rotMatrix = getRotationMatrix2D(center, angle, 1.0); @@ -1556,33 +1556,33 @@ NAN_METHOD(Matrix::Rotate) { ~self->mat; self->mat = res; - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::PyrDown) { SETUP_FUNCTION(Matrix) cv::pyrDown(self->mat, self->mat); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::PyrUp) { SETUP_FUNCTION(Matrix) cv::pyrUp(self->mat, self->mat); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::inRange) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); /*if (self->mat.channels() != 3) - Nan::ThrowError(String::New("Image is no 3-channel"));*/ + NanThrowError(String::New("Image is no 3-channel"));*/ - if (info[0]->IsArray() && info[1]->IsArray()) { - Local args_lowerb = info[0]->ToObject(); - Local args_upperb = info[1]->ToObject(); + if (args[0]->IsArray() && args[1]->IsArray()) { + Local args_lowerb = args[0]->ToObject(); + Local args_upperb = args[1]->ToObject(); cv::Scalar lowerb(0, 0, 0); cv::Scalar upperb(0, 0, 0); @@ -1595,19 +1595,19 @@ NAN_METHOD(Matrix::inRange) { mask.copyTo(self->mat); } - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::AdjustROI) { SETUP_FUNCTION(Matrix) - int dtop = info[0]->Uint32Value(); - int dbottom = info[1]->Uint32Value(); - int dleft = info[2]->Uint32Value(); - int dright = info[3]->Uint32Value(); + int dtop = args[0]->Uint32Value(); + int dbottom = args[1]->Uint32Value(); + int dleft = args[2]->Uint32Value(); + int dright = args[3]->Uint32Value(); self->mat.adjustROI(dtop, dbottom, dleft, dright); - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::LocateROI) { @@ -1618,25 +1618,25 @@ NAN_METHOD(Matrix::LocateROI) { self->mat.locateROI(wholeSize, ofs); - v8::Local < v8::Array > arr = Nan::New(4); - arr->Set(0, Nan::New(wholeSize.width)); - arr->Set(1, Nan::New(wholeSize.height)); - arr->Set(2, Nan::New(ofs.x)); - arr->Set(3, Nan::New(ofs.y)); + v8::Local < v8::Array > arr = NanNew(4); + arr->Set(0, NanNew(wholeSize.width)); + arr->Set(1, NanNew(wholeSize.height)); + arr->Set(2, NanNew(ofs.x)); + arr->Set(3, NanNew(ofs.y)); - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::Threshold) { SETUP_FUNCTION(Matrix) - double threshold = info[0]->NumberValue(); - double maxVal = info[1]->NumberValue(); + double threshold = args[0]->NumberValue(); + double maxVal = args[1]->NumberValue(); int typ = cv::THRESH_BINARY; - if (info.Length() == 3) { - // typ = info[2]->IntegerValue(); - Nan::Utf8String typstr(info[2]); + if (args.Length() == 3) { + // typ = args[2]->IntegerValue(); + NanAsciiString typstr(args[2]); if (strcmp(*typstr, "Binary") == 0) { typ = 0; } @@ -1655,52 +1655,52 @@ NAN_METHOD(Matrix::Threshold) { } Local < Object > img_to_return = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); cv::threshold(self->mat, img->mat, threshold, maxVal, typ); - info.GetReturnValue().Set(img_to_return); + NanReturnValue(img_to_return); } NAN_METHOD(Matrix::AdaptiveThreshold) { SETUP_FUNCTION(Matrix) - 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(); + 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(); Local < Object > img_to_return = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C); - info.GetReturnValue().Set(img_to_return); + NanReturnValue(img_to_return); } NAN_METHOD(Matrix::MeanStdDev) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - Local mean = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_mean = Nan::ObjectWrap::Unwrap(mean); - Local stddev = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_stddev = Nan::ObjectWrap::Unwrap(stddev); + Local mean = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_mean = ObjectWrap::Unwrap(mean); + Local stddev = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_stddev = ObjectWrap::Unwrap(stddev); cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat); - Local data = Nan::New(); - data->Set(Nan::New("mean").ToLocalChecked(), mean); - data->Set(Nan::New("stddev").ToLocalChecked(), stddev); + Local data = NanNew(); + data->Set(NanNew("mean"), mean); + data->Set(NanNew("stddev"), stddev); - info.GetReturnValue().Set(data); + NanReturnValue(data); } // @author SergeMv @@ -1713,34 +1713,34 @@ NAN_METHOD(Matrix::MeanStdDev) { // our.width + x <= destination.width (and the same for y and height) // both x and y must be >= 0 NAN_METHOD(Matrix::CopyTo) { - Nan::HandleScope scope; + NanScope(); - Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix * self = ObjectWrap::Unwrap(args.This()); int width = self->mat.size().width; int height = self->mat.size().height; // param 0 - destination image: - Matrix *dest = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); // param 1 - x coord of the destination - int x = info[1]->IntegerValue(); + int x = args[1]->IntegerValue(); // param 2 - y coord of the destination - int y = info[2]->IntegerValue(); + int y = args[2]->IntegerValue(); cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height)); self->mat.copyTo(dstROI); - return; + NanReturnUndefined(); } // @author SergeMv // Does in-place color transformation // img.cvtColor('CV_BGR2YCrCb'); NAN_METHOD(Matrix::CvtColor) { - Nan::HandleScope scope; + NanScope(); - Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix * self = ObjectWrap::Unwrap(args.This()); - v8::String::Utf8Value str (info[0]->ToString()); + v8::String::Utf8Value str (args[0]->ToString()); std::string str2 = std::string(*str); const char * sTransform = (const char *) str2.c_str(); int iTransform; @@ -1772,20 +1772,20 @@ NAN_METHOD(Matrix::CvtColor) { else if (!strcmp(sTransform, "CV_BayerGR2BGR")) {iTransform = CV_BayerGR2BGR;} else { iTransform = 0; // to avoid compiler warning - Nan::ThrowTypeError("Conversion code is unsupported"); + NanThrowTypeError("Conversion code is unsupported"); } cv::cvtColor(self->mat, self->mat, iTransform); - return; + NanReturnUndefined(); } // @author SergeMv // arrChannels = img.split(); NAN_METHOD(Matrix::Split) { - Nan::HandleScope scope; + NanScope(); - Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix * self = ObjectWrap::Unwrap(args.This()); unsigned int size = self->mat.channels(); vector channels; @@ -1797,55 +1797,55 @@ NAN_METHOD(Matrix::Split) { cv::split(self->mat, channels); size = channels.size(); - v8::Local arrChannels = Nan::New(size); + v8::Local arrChannels = NanNew(size); for (unsigned int i = 0; i < size; i++) { Local matObject = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix * m = Nan::ObjectWrap::Unwrap(matObject); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix * m = ObjectWrap::Unwrap(matObject); m->mat = channels[i]; arrChannels->Set(i, matObject); } - info.GetReturnValue().Set(arrChannels); + NanReturnValue(arrChannels); } // @author SergeMv // img.merge(arrChannels); NAN_METHOD(Matrix::Merge) { - Nan::HandleScope scope; + NanScope(); - Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); - if (!info[0]->IsArray()) { - Nan::ThrowTypeError("The argument must be an array"); + Matrix * self = ObjectWrap::Unwrap(args.This()); + if (!args[0]->IsArray()) { + NanThrowTypeError("The argument must be an array"); } - v8::Handle jsChannels = v8::Handle::Cast(info[0]); + v8::Handle jsChannels = v8::Handle::Cast(args[0]); unsigned int L = jsChannels->Length(); vector vChannels(L); for (unsigned int i = 0; i < L; i++) { - Matrix * matObject = Nan::ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); + Matrix * matObject = ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); vChannels[i] = matObject->mat; } cv::merge(vChannels, self->mat); - return; + NanReturnUndefined(); } // @author SergeMv // Equalizes histogram // img.equalizeHist() NAN_METHOD(Matrix::EqualizeHist) { - Nan::HandleScope scope; - Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + Matrix * self = ObjectWrap::Unwrap(args.This()); cv::equalizeHist(self->mat, self->mat); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::FloodFill) { SETUP_FUNCTION(Matrix) - // obj->Get(Nan::New("x").ToLocalChecked()) + // obj->Get(NanNew("x")) // int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int) /* mat.floodFill( {seedPoint: [1,1] , @@ -1855,22 +1855,22 @@ NAN_METHOD(Matrix::FloodFill) { upDiff:[10,100,70] }); */ - if (info.Length() < 1 || !info[0]->IsObject()) { + if (args.Length() < 1 || !args[0]->IsObject()) { // error } - Local < Object > obj = info[0]->ToObject(); + Local < Object > obj = args[0]->ToObject(); cv::Rect rect; int ret = cv::floodFill(self->mat, - setPoint(obj->Get(Nan::New("seedPoint").ToLocalChecked())->ToObject()), - setColor(obj->Get(Nan::New("newColor").ToLocalChecked())->ToObject()), - obj->Get(Nan::New("rect").ToLocalChecked())->IsUndefined() ? - 0 : setRect(obj->Get(Nan::New("rect").ToLocalChecked())->ToObject(), rect), - setColor(obj->Get(Nan::New("loDiff").ToLocalChecked())->ToObject()), - setColor(obj->Get(Nan::New("upDiff").ToLocalChecked())->ToObject()), 4); + setPoint(obj->Get(NanNew("seedPoint"))->ToObject()), + setColor(obj->Get(NanNew("newColor"))->ToObject()), + obj->Get(NanNew("rect"))->IsUndefined() ? + 0 : setRect(obj->Get(NanNew("rect"))->ToObject(), rect), + setColor(obj->Get(NanNew("loDiff"))->ToObject()), + setColor(obj->Get(NanNew("upDiff"))->ToObject()), 4); - info.GetReturnValue().Set(Nan::New(ret)); + NanReturnValue(NanNew(ret)); } // @author olfox @@ -1880,15 +1880,15 @@ NAN_METHOD(Matrix::TemplateMatches) { SETUP_FUNCTION(Matrix) bool filter_min_probability = - (info.Length() >= 1) ? info[0]->IsNumber() : false; + (args.Length() >= 1) ? args[0]->IsNumber() : false; bool filter_max_probability = - (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; + (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; cv::Mat_ indices; @@ -1901,7 +1901,7 @@ NAN_METHOD(Matrix::TemplateMatches) { } cv::Mat hit_mask = cv::Mat::zeros(self->mat.size(), CV_64F); - v8::Local < v8::Array > probabilites_array = Nan::New(limit); + v8::Local < v8::Array > probabilites_array = NanNew(limit); cv::Mat_::const_iterator begin = self->mat.begin(); cv::Mat_::const_iterator it = indices.begin(); @@ -1955,37 +1955,37 @@ NAN_METHOD(Matrix::TemplateMatches) { cv::rectangle(hit_mask, top_left, bottom_right, color, CV_FILLED); } - Local x_value = Nan::New(pt.x); - Local y_value = Nan::New(pt.y); - Local probability_value = Nan::New(probability); + Local x_value = NanNew(pt.x); + Local y_value = NanNew(pt.y); + Local probability_value = NanNew(probability); - Local < Object > probability_object = Nan::New(); - probability_object->Set(Nan::New("x").ToLocalChecked(), x_value); - probability_object->Set(Nan::New("y").ToLocalChecked(), y_value); - probability_object->Set(Nan::New("probability").ToLocalChecked(), probability_value); + Local < Object > probability_object = NanNew(); + probability_object->Set(NanNew("x"), x_value); + probability_object->Set(NanNew("y"), y_value); + probability_object->Set(NanNew("probability"), probability_value); probabilites_array->Set(index, probability_object); index++; } - info.GetReturnValue().Set(probabilites_array); + NanReturnValue(probabilites_array); } // @author ytham // Match Template filter // Usage: output = input.matchTemplate("templateFileString", method); NAN_METHOD(Matrix::MatchTemplate) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); - v8::String::Utf8Value args0(info[0]->ToString()); + v8::String::Utf8Value args0(args[0]->ToString()); std::string filename = std::string(*args0); cv::Mat templ; templ = cv::imread(filename, CV_8S); - Local out = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_out = Nan::ObjectWrap::Unwrap(out); + Local out = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_out = ObjectWrap::Unwrap(out); int cols = self->mat.cols - templ.cols + 1; int rows = self->mat.rows - templ.rows + 1; m_out->mat.create(cols, rows, CV_32FC1); @@ -1999,70 +1999,70 @@ NAN_METHOD(Matrix::MatchTemplate) { TM_CCOEFF_NORMED =5 */ - int method = (info.Length() < 2) ? (int)cv::TM_CCORR_NORMED : info[1]->Uint32Value(); + int method = (args.Length() < 2) ? (int)cv::TM_CCORR_NORMED : args[1]->Uint32Value(); cv::matchTemplate(self->mat, templ, m_out->mat, method); - info.GetReturnValue().Set(out); + NanReturnValue(out); } // @author ytham // Min/Max location NAN_METHOD(Matrix::MinMaxLoc) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; cv::minMaxLoc(self->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); - Local v_minVal = Nan::New(minVal); - Local v_maxVal = Nan::New(maxVal); - Local v_minLoc_x = Nan::New(minLoc.x); - Local v_minLoc_y = Nan::New(minLoc.y); - Local v_maxLoc_x = Nan::New(maxLoc.x); - Local v_maxLoc_y = Nan::New(maxLoc.y); + Local v_minVal = NanNew(minVal); + Local v_maxVal = NanNew(maxVal); + Local v_minLoc_x = NanNew(minLoc.x); + Local v_minLoc_y = NanNew(minLoc.y); + Local v_maxLoc_x = NanNew(maxLoc.x); + Local v_maxLoc_y = NanNew(maxLoc.y); - Local o_minLoc = Nan::New(); - o_minLoc->Set(Nan::New("x").ToLocalChecked(), v_minLoc_x); - o_minLoc->Set(Nan::New("y").ToLocalChecked(), v_minLoc_y); + Local o_minLoc = NanNew(); + o_minLoc->Set(NanNew("x"), v_minLoc_x); + o_minLoc->Set(NanNew("y"), v_minLoc_y); - Local o_maxLoc = Nan::New(); - o_maxLoc->Set(Nan::New("x").ToLocalChecked(), v_maxLoc_x); - o_maxLoc->Set(Nan::New("y").ToLocalChecked(), v_maxLoc_y); + Local o_maxLoc = NanNew(); + o_maxLoc->Set(NanNew("x"), v_maxLoc_x); + o_maxLoc->Set(NanNew("y"), v_maxLoc_y); // Output result object - Local result = Nan::New(); - result->Set(Nan::New("minVal").ToLocalChecked(), v_minVal); - result->Set(Nan::New("maxVal").ToLocalChecked(), v_maxVal); - result->Set(Nan::New("minLoc").ToLocalChecked(), o_minLoc); - result->Set(Nan::New("maxLoc").ToLocalChecked(), o_maxLoc); + Local result = NanNew(); + result->Set(NanNew("minVal"), v_minVal); + result->Set(NanNew("maxVal"), v_maxVal); + result->Set(NanNew("minLoc"), o_minLoc); + result->Set(NanNew("maxLoc"), o_maxLoc); - info.GetReturnValue().Set(result); + NanReturnValue(result); } // @author ytham // Pushes some matrix (argument) the back of a matrix (self) NAN_METHOD(Matrix::PushBack) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Matrix *m_input = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *m_input = ObjectWrap::Unwrap(args[0]->ToObject()); self->mat.push_back(m_input->mat); - info.GetReturnValue().Set(info.This()); + NanReturnValue(args.This()); } NAN_METHOD(Matrix::PutText) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Nan::Utf8String textString(info[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 + Matrix *self = ObjectWrap::Unwrap(args.This()); + NanAsciiString textString(args[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 char *text = *textString;//(char *) malloc(textString.length() + 1); //strcpy(text, *textString); - int x = info[1]->IntegerValue(); - int y = info[2]->IntegerValue(); + int x = args[1]->IntegerValue(); + int y = args[2]->IntegerValue(); - Nan::Utf8String fontString(info[3]); + NanAsciiString fontString(args[3]); char *font = *fontString;//(char *) malloc(fontString.length() + 1); //strcpy(font, *fontString); int constFont = cv::FONT_HERSHEY_SIMPLEX; @@ -2079,25 +2079,25 @@ NAN_METHOD(Matrix::PutText) { cv::Scalar color(0, 0, 255); - if (info[4]->IsArray()) { - Local objColor = info[4]->ToObject(); + if (args[4]->IsArray()) { + Local objColor = args[4]->ToObject(); color = setColor(objColor); } - double scale = info.Length() < 6 ? 1 : info[5]->NumberValue(); - double thickness = info.Length() < 7 ? 1 : info[6]->NumberValue(); + double scale = args.Length() < 6 ? 1 : args[5]->NumberValue(); + double thickness = args.Length() < 7 ? 1 : args[6]->NumberValue(); cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, thickness); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::GetPerspectiveTransform) { - Nan::HandleScope scope; + NanScope(); // extract quad args - Local srcArray = info[0]->ToObject(); - Local tgtArray = info[1]->ToObject(); + Local srcArray = args[0]->ToObject(); + Local tgtArray = args[1]->ToObject(); std::vector src_corners(4); std::vector tgt_corners(4); @@ -2106,28 +2106,28 @@ NAN_METHOD(Matrix::GetPerspectiveTransform) { tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue(),tgtArray->Get(i*2+1)->IntegerValue()); } - Local xfrm = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *xfrmmat = Nan::ObjectWrap::Unwrap(xfrm); + Local xfrm = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *xfrmmat = ObjectWrap::Unwrap(xfrm); xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners); - info.GetReturnValue().Set(xfrm); + NanReturnValue(xfrm); } NAN_METHOD(Matrix::WarpPerspective) { SETUP_FUNCTION(Matrix) - Matrix *xfrm = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *xfrm = ObjectWrap::Unwrap(args[0]->ToObject()); - int width = info[1]->IntegerValue(); - int height = info[2]->IntegerValue(); + int width = args[1]->IntegerValue(); + int height = args[2]->IntegerValue(); int flags = cv::INTER_LINEAR; int borderMode = cv::BORDER_REPLICATE; cv::Scalar borderColor(0, 0, 255); - if (info[3]->IsArray()) { - Local < Object > objColor = info[3]->ToObject(); + if (args[3]->IsArray()) { + Local < Object > objColor = args[3]->ToObject(); borderColor = setColor(objColor); } @@ -2139,53 +2139,53 @@ NAN_METHOD(Matrix::WarpPerspective) { ~self->mat; self->mat = res; - info.GetReturnValue().Set(Nan::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::CopyWithMask) { SETUP_FUNCTION(Matrix) // param 0 - destination image: - Matrix *dest = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); // param 1 - mask. same size as src and dest - Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); self->mat.copyTo(dest->mat, mask->mat); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::SetWithMask) { SETUP_FUNCTION(Matrix) // param 0 - target value: - Local < Object > valArray = info[0]->ToObject(); + Local < Object > valArray = args[0]->ToObject(); cv::Scalar newvals; newvals.val[0] = valArray->Get(0)->NumberValue(); newvals.val[1] = valArray->Get(1)->NumberValue(); newvals.val[2] = valArray->Get(2)->NumberValue(); // param 1 - mask. same size as src and dest - Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); self->mat.setTo(newvals, mask->mat); - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::MeanWithMask) { SETUP_FUNCTION(Matrix) // param 0 - mask. same size as src and dest - Matrix *mask = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *mask = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Scalar means = cv::mean(self->mat, mask->mat); - v8::Local < v8::Array > arr = Nan::New(3); - arr->Set(0, Nan::New(means[0])); - arr->Set(1, Nan::New(means[1])); - arr->Set(2, Nan::New(means[2])); + v8::Local < v8::Array > arr = NanNew(3); + arr->Set(0, NanNew(means[0])); + arr->Set(1, NanNew(means[1])); + arr->Set(2, NanNew(means[2])); - info.GetReturnValue().Set(arr); + NanReturnValue(arr); } NAN_METHOD(Matrix::Shift) { @@ -2193,8 +2193,8 @@ NAN_METHOD(Matrix::Shift) { cv::Mat res; - double tx = info[0]->NumberValue(); - double ty = info[1]->NumberValue(); + double tx = args[0]->NumberValue(); + double ty = args[1]->NumberValue(); // get the integer values of args cv::Point2i deltai(ceil(tx), ceil(ty)); @@ -2227,14 +2227,14 @@ NAN_METHOD(Matrix::Shift) { ~self->mat; self->mat = res; - return; + NanReturnUndefined(); } NAN_METHOD(Matrix::Release) { - Nan::HandleScope scope; + NanScope(); - Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *self = ObjectWrap::Unwrap(args.This()); self->mat.release(); - return; + NanReturnUndefined(); } diff --git a/src/Matrix.h b/src/Matrix.h old mode 100644 new mode 100755 index 3c87b38..0367f3b --- a/src/Matrix.h +++ b/src/Matrix.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class Matrix: public Nan::ObjectWrap { +class Matrix: public node::ObjectWrap { public: cv::Mat mat; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); Matrix(); @@ -119,34 +119,34 @@ public: JSFUNC(Release) /* - static Handle Val(const Arguments& info); - static Handle RowRange(const Arguments& info); - static Handle ColRange(const Arguments& info); - static Handle Diag(const Arguments& info); - static Handle Clone(const Arguments& info); - static Handle CopyTo(const Arguments& info); - static Handle ConvertTo(const Arguments& info); - static Handle AssignTo(const Arguments& info); - static Handle SetTo(const Arguments& info); - static Handle Reshape(const Arguments& info); - static Handle Transpose(const Arguments& info); - static Handle Invert(const Arguments& info); - static Handle Multiply(const Arguments& info); - static Handle Cross(const Arguments& info); - static Handle Dot(const Arguments& info); - static Handle Zeroes(const Arguments& info); - static Handle Ones(const Arguments& info); + static Handle Val(const Arguments& args); + static Handle RowRange(const Arguments& args); + static Handle ColRange(const Arguments& args); + static Handle Diag(const Arguments& args); + static Handle Clone(const Arguments& args); + static Handle CopyTo(const Arguments& args); + static Handle ConvertTo(const Arguments& args); + static Handle AssignTo(const Arguments& args); + static Handle SetTo(const Arguments& args); + static Handle Reshape(const Arguments& args); + static Handle Transpose(const Arguments& args); + static Handle Invert(const Arguments& args); + static Handle Multiply(const Arguments& args); + static Handle Cross(const Arguments& args); + static Handle Dot(const Arguments& args); + static Handle Zeroes(const Arguments& args); + static Handle Ones(const Arguments& args); // create, increment, release - static Handle PushBack(const Arguments& info); - static Handle PopBack(const Arguments& info); - static Handle Total(const Arguments& info); - static Handle IsContinous(const Arguments& info); - static Handle Type(const Arguments& info); - static Handle Depth(const Arguments& info); - static Handle Channels(const Arguments& info); - static Handle StepOne(const Arguments& info); - static Handle GetPerspectiveTransform(const Arguments& info); - static Handle WarpPerspective(const Arguments& info); + static Handle PushBack(const Arguments& args); + static Handle PopBack(const Arguments& args); + static Handle Total(const Arguments& args); + static Handle IsContinous(const Arguments& args); + static Handle Type(const Arguments& args); + static Handle Depth(const Arguments& args); + static Handle Channels(const Arguments& args); + static Handle StepOne(const Arguments& args); + static Handle GetPerspectiveTransform(const Arguments& args); + static Handle WarpPerspective(const Arguments& args); */ }; diff --git a/src/OpenCV.cc b/src/OpenCV.cc old mode 100644 new mode 100755 index 8365138..949cec1 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -3,66 +3,66 @@ #include void OpenCV::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Version string. char out [21]; int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION); - target->Set(Nan::New("version").ToLocalChecked(), Nan::New(out, n).ToLocalChecked()); + target->Set(NanNew("version"), NanNew(out, n)); - Nan::SetMethod(target, "readImage", ReadImage); + NODE_SET_METHOD(target, "readImage", ReadImage); } NAN_METHOD(OpenCV::ReadImage) { - Nan::EscapableHandleScope scope; + NanEscapableScope(); REQ_FUN_ARG(1, cb); Local argv[2]; - argv[0] = Nan::Null(); + argv[0] = NanNull(); - Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im_h); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_h); argv[1] = im_h; try { cv::Mat mat; - if (info[0]->IsNumber() && info[1]->IsNumber()) { + if (args[0]->IsNumber() && args[1]->IsNumber()) { int width, height; - width = info[0]->Uint32Value(); - height = info[1]->Uint32Value(); + width = args[0]->Uint32Value(); + height = args[1]->Uint32Value(); mat = *(new cv::Mat(width, height, CV_64FC1)); - } else if (info[0]->IsString()) { - std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); + } else if (args[0]->IsString()) { + std::string filename = std::string(*NanUtf8String(args[0]->ToString())); mat = cv::imread(filename); - } else if (Buffer::HasInstance(info[0])) { - uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject()); - unsigned len = Buffer::Length(info[0]->ToObject()); + } else if (Buffer::HasInstance(args[0])) { + uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject()); + unsigned len = Buffer::Length(args[0]->ToObject()); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); mat = cv::imdecode(*mbuf, -1); if (mat.empty()) { - argv[0] = Nan::Error("Error loading file"); + argv[0] = NanError("Error loading file"); } } img->mat = mat; } catch (cv::Exception& e) { - argv[0] = Nan::Error(e.what()); - argv[1] = Nan::Null(); + argv[0] = NanError(e.what()); + argv[1] = NanNull(); } TryCatch try_catch; - cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); + cb->Call(NanGetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - return; + NanReturnUndefined(); } diff --git a/src/OpenCV.h b/src/OpenCV.h old mode 100644 new mode 100755 index 6e368ae..79f191a --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -15,34 +15,34 @@ using namespace v8; using namespace node; #define REQ_FUN_ARG(I, VAR) \ - if (info.Length() <= (I) || !info[I]->IsFunction()) \ - return Nan::ThrowTypeError("Argument " #I " must be a function"); \ - Local VAR = Local::Cast(info[I]); + if (args.Length() <= (I) || !args[I]->IsFunction()) \ + return NanThrowTypeError("Argument " #I " must be a function"); \ + Local VAR = Local::Cast(args[I]); #define SETUP_FUNCTION(TYP) \ - Nan::HandleScope scope; \ - TYP *self = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); \ + TYP *self = ObjectWrap::Unwrap(args.This()); #define JSFUNC(NAME) \ static NAN_METHOD(NAME); #define JSTHROW_TYPE(ERR) \ - Nan::ThrowTypeError( ERR ); + NanThrowTypeError( ERR ); #define JSTHROW(ERR) \ - Nan::ThrowError( ERR ); + NanThrowError( ERR ); #define INT_FROM_ARGS(NAME, IND) \ - if (info[IND]->IsInt32()){ \ - NAME = info[IND]->Uint32Value(); \ + if (args[IND]->IsInt32()){ \ + NAME = args[IND]->Uint32Value(); \ } #define DOUBLE_FROM_ARGS(NAME, IND) \ - if (info[IND]->IsInt32()){ \ - NAME = info[IND]->NumberValue(); \ + if (args[IND]->IsInt32()){ \ + NAME = args[IND]->NumberValue(); \ } -class OpenCV: public Nan::ObjectWrap { +class OpenCV: public node::ObjectWrap { public: static void Init(Handle target); diff --git a/src/Point.cc b/src/Point.cc old mode 100644 new mode 100755 index 060029d..b90119f --- a/src/Point.cc +++ b/src/Point.cc @@ -1,72 +1,72 @@ #include "Point.h" #include "OpenCV.h" -Nan::Persistent Point::constructor; +v8::Persistent Point::constructor; void Point::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); // Constructor - Local ctor = Nan::New(Point::New); - constructor.Reset(ctor); + Local ctor = NanNew(Point::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("Point").ToLocalChecked()); + ctor->SetClassName(NanNew("Point")); // Prototype Local proto = ctor->PrototypeTemplate(); - Nan::SetAccessor(proto, Nan::New("x").ToLocalChecked(), GetX, RaiseImmutable); - Nan::SetAccessor(proto, Nan::New("y").ToLocalChecked(), GetY, RaiseImmutable); + proto->SetAccessor(NanNew("x"), GetX, RaiseImmutable); + proto->SetAccessor(NanNew("y"), GetY, RaiseImmutable); - Nan::SetPrototypeMethod(ctor, "dot", Dot); + NODE_SET_PROTOTYPE_METHOD(ctor, "dot", Dot); - target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("Point"), ctor->GetFunction()); }; NAN_METHOD(Point::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { - return Nan::ThrowTypeError("Cannot Instantiate without new"); + if (args.This()->InternalFieldCount() == 0) { + return NanThrowTypeError("Cannot Instantiate without new"); } double x = 0, y = 0; - if (info[0]->IsNumber()) { - x = info[0]->NumberValue(); + if (args[0]->IsNumber()) { + x = args[0]->NumberValue(); } - if (info[1]->IsNumber()) { - y = info[1]->NumberValue(); + if (args[1]->IsNumber()) { + y = args[1]->NumberValue(); } Point *pt = new Point(x, y); - pt->Wrap(info.This()); - info.GetReturnValue().Set(info.This()); + pt->Wrap(args.This()); + NanReturnValue(args.This()); } NAN_GETTER(Point::GetX) { - Nan::HandleScope scope; - Point *pt = Nan::ObjectWrap::Unwrap(info.This()); - info.GetReturnValue().Set(Nan::New(pt->point.x)); + NanScope(); + Point *pt = ObjectWrap::Unwrap(args.This()); + NanReturnValue(NanNew(pt->point.x)); } NAN_GETTER(Point::GetY) { - Nan::HandleScope scope; - Point *pt = Nan::ObjectWrap::Unwrap(info.This()); - info.GetReturnValue().Set(Nan::New(pt->point.y)); + NanScope(); + Point *pt = ObjectWrap::Unwrap(args.This()); + NanReturnValue(NanNew(pt->point.y)); } NAN_SETTER(Point::RaiseImmutable) { - Nan::ThrowTypeError("Point is immutable"); + NanThrowTypeError("Point is immutable"); } NAN_METHOD(Point::Dot) { - Nan::HandleScope scope; - Point *p1 = Nan::ObjectWrap::Unwrap(info.This()); - Point *p2 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + NanScope(); + Point *p1 = ObjectWrap::Unwrap(args.This()); + Point *p2 = ObjectWrap::Unwrap(args[0]->ToObject()); // Since V 2.3 Native Dot no longer supported - info.GetReturnValue().Set(Nan::New(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); + NanReturnValue(NanNew(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); } Point::Point(double x, double y) : - Nan::ObjectWrap() { + ObjectWrap() { point = cvPoint2D32f(x, y); } diff --git a/src/Point.h b/src/Point.h old mode 100644 new mode 100755 index d72bf60..2aec52d --- a/src/Point.h +++ b/src/Point.h @@ -2,10 +2,10 @@ #include "OpenCV.h" -class Point: public Nan::ObjectWrap { +class Point: public node::ObjectWrap { public: CvPoint2D32f point; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); Point(double x, double y); diff --git a/src/Stereo.cc b/src/Stereo.cc index b5f83f5..e524eef 100644 --- a/src/Stereo.cc +++ b/src/Stereo.cc @@ -4,54 +4,54 @@ // Block matching -Nan::Persistent StereoBM::constructor; +v8::Persistent StereoBM::constructor; void StereoBM::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); - Local ctor = Nan::New(StereoBM::New); - constructor.Reset(ctor); + Local ctor = NanNew(StereoBM::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("StereoBM").ToLocalChecked()); + ctor->SetClassName(NanNew("StereoBM")); - Nan::SetPrototypeMethod(ctor, "compute", Compute); + NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); - ctor->Set(Nan::New("BASIC_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::BASIC_PRESET)); - ctor->Set(Nan::New("FISH_EYE_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::FISH_EYE_PRESET)); - ctor->Set(Nan::New("NARROW_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::NARROW_PRESET)); + ctor->Set(NanNew("BASIC_PRESET"), NanNew((int)cv::StereoBM::BASIC_PRESET)); + ctor->Set(NanNew("FISH_EYE_PRESET"), NanNew((int)cv::StereoBM::FISH_EYE_PRESET)); + ctor->Set(NanNew("NARROW_PRESET"), NanNew((int)cv::StereoBM::NARROW_PRESET)); - target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("StereoBM"), ctor->GetFunction()); } NAN_METHOD(StereoBM::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { - Nan::ThrowTypeError("Cannot instantiate without new"); + if (args.This()->InternalFieldCount() == 0) { + NanThrowTypeError("Cannot instantiate without new"); } StereoBM *stereo; - if (info.Length() == 0) { + if (args.Length() == 0) { stereo = new StereoBM(); - } else if (info.Length() == 1) { + } else if (args.Length() == 1) { // preset - stereo = new StereoBM(info[0]->IntegerValue()); - } else if (info.Length() == 2) { + stereo = new StereoBM(args[0]->IntegerValue()); + } else if (args.Length() == 2) { // preset, disparity search range - stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue()); + stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue()); } else { - stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue(), + stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(), // preset, disparity search range, sum of absolute differences window size - info[2]->IntegerValue()); + args[2]->IntegerValue()); } - stereo->Wrap(info.Holder()); - info.GetReturnValue().Set(info.Holder()); + stereo->Wrap(args.Holder()); + NanReturnValue(args.Holder()); } StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) : - Nan::ObjectWrap(), + ObjectWrap(), stereo(preset, ndisparities, SADWindowSize) { } @@ -63,17 +63,17 @@ NAN_METHOD(StereoBM::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::Mat right = m1->mat; // Optional 3rd arg, the disparty depth int type = CV_16S; - if (info.Length() > 2) { - type = info[2]->IntegerValue(); + if (args.Length() > 2) { + type = args[2]->IntegerValue(); } // Compute stereo using the block matching algorithm @@ -82,108 +82,108 @@ NAN_METHOD(StereoBM::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - info.GetReturnValue().Set(disparityWrap); + NanReturnValue(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // Semi-Global Block matching -Nan::Persistent StereoSGBM::constructor; +v8::Persistent StereoSGBM::constructor; void StereoSGBM::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); - Local ctor = Nan::New(StereoSGBM::New); - constructor.Reset(ctor); + Local ctor = NanNew(StereoSGBM::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("StereoSGBM").ToLocalChecked()); + ctor->SetClassName(NanNew("StereoSGBM")); - Nan::SetPrototypeMethod(ctor, "compute", Compute); + NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); - target->Set(Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("StereoSGBM"), ctor->GetFunction()); } NAN_METHOD(StereoSGBM::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) { - Nan::ThrowTypeError("Cannot instantiate without new"); + if (args.This()->InternalFieldCount() == 0) { + NanThrowTypeError("Cannot instantiate without new"); } StereoSGBM *stereo; - if (info.Length() == 0) { + if (args.Length() == 0) { stereo = new StereoSGBM(); } else { // If passing arguments, must pass the first 3 at least - if (info.Length() >= 3) { - switch (info.Length()) { + if (args.Length() >= 3) { + switch (args.Length()) { case 3: - stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), - info[2]->IntegerValue()); + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), + args[2]->IntegerValue()); break; case 4: - 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()); break; case 5: - 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()); break; case 6: - 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()); break; case 7: - 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()); break; case 8: - 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()); break; case 9: - 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()); break; case 10: - 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()); break; default: - 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()); + 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()); break; } } else { - Nan::ThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize"); - return; + NanThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize"); + NanReturnUndefined(); } } - stereo->Wrap(info.Holder()); - info.GetReturnValue().Set(info.Holder()); + stereo->Wrap(args.Holder()); + NanReturnValue(args.Holder()); } StereoSGBM::StereoSGBM() : - Nan::ObjectWrap(), + ObjectWrap(), stereo() { } @@ -191,7 +191,7 @@ StereoSGBM::StereoSGBM() : StereoSGBM::StereoSGBM(int minDisparity, int ndisparities, int SADWindowSize, int p1, int p2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, bool fullDP) : - Nan::ObjectWrap(), + ObjectWrap(), stereo(minDisparity, ndisparities, SADWindowSize, p1, p2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP) { } @@ -204,11 +204,11 @@ NAN_METHOD(StereoSGBM::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::Mat right = m1->mat; // Compute stereo using the block matching algorithm @@ -217,59 +217,59 @@ NAN_METHOD(StereoSGBM::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - info.GetReturnValue().Set(disparityWrap); + NanReturnValue(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } // Graph cut -Nan::Persistent StereoGC::constructor; +v8::Persistent StereoGC::constructor; void StereoGC::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); - Local ctor = Nan::New(StereoGC::New); - constructor.Reset(ctor); + Local ctor = NanNew(StereoGC::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("StereoGC").ToLocalChecked()); + ctor->SetClassName(NanNew("StereoGC")); - Nan::SetPrototypeMethod(ctor, "compute", Compute); + NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); - target->Set(Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("StereoGC"), ctor->GetFunction()); } NAN_METHOD(StereoGC::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) - Nan::ThrowTypeError("Cannot instantiate without new"); + if (args.This()->InternalFieldCount() == 0) + NanThrowTypeError("Cannot instantiate without new"); StereoGC *stereo; - if (info.Length() == 0) { + if (args.Length() == 0) { stereo = new StereoGC(); - } else if (info.Length() == 1) { + } else if (args.Length() == 1) { // numberOfDisparities - stereo = new StereoGC(info[0]->IntegerValue()); + stereo = new StereoGC(args[0]->IntegerValue()); } else { // max iterations - stereo = new StereoGC(info[0]->IntegerValue(), info[1]->IntegerValue()); + stereo = new StereoGC(args[0]->IntegerValue(), args[1]->IntegerValue()); } - stereo->Wrap(info.Holder()); - info.GetReturnValue().Set(info.Holder()); + stereo->Wrap(args.Holder()); + NanReturnValue(args.Holder()); } StereoGC::StereoGC(int numberOfDisparities, int maxIters) : - Nan::ObjectWrap() { + ObjectWrap() { stereo = cvCreateStereoGCState(numberOfDisparities, maxIters); } @@ -281,11 +281,11 @@ NAN_METHOD(StereoGC::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); cv::Mat right = m1->mat; // Compute stereo using the block matching algorithm @@ -301,14 +301,14 @@ NAN_METHOD(StereoGC::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); + NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - info.GetReturnValue().Set(disparityWrap); + NanReturnValue(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - Nan::ThrowError(err_msg); - return; + NanThrowError(err_msg); + NanReturnUndefined(); } } diff --git a/src/Stereo.h b/src/Stereo.h index a26a8f8..a791732 100644 --- a/src/Stereo.h +++ b/src/Stereo.h @@ -3,11 +3,11 @@ #include "OpenCV.h" -class StereoBM: public Nan::ObjectWrap { +class StereoBM: public node::ObjectWrap { public: cv::StereoBM stereo; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); @@ -18,11 +18,11 @@ public: ; }; -class StereoSGBM: public Nan::ObjectWrap { +class StereoSGBM: public node::ObjectWrap { public: cv::StereoSGBM stereo; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); @@ -37,11 +37,11 @@ public: struct CvStereoGCState; -class StereoGC: public Nan::ObjectWrap { +class StereoGC: public node::ObjectWrap { public: CvStereoGCState *stereo; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc old mode 100644 new mode 100755 index ca6da1c..970419a --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -5,11 +5,11 @@ #include using namespace std; -Nan::Persistent VideoCaptureWrap::constructor; +v8::Persistent VideoCaptureWrap::constructor; struct videocapture_baton { - Nan::Persistent cb; + Persistent cb; VideoCaptureWrap *vc; Matrix *im; @@ -17,124 +17,124 @@ struct videocapture_baton { }; void VideoCaptureWrap::Init(Handle target) { - Nan::HandleScope scope; + NanScope(); //Class - Local ctor = Nan::New(VideoCaptureWrap::New); - constructor.Reset(ctor); + Local ctor = NanNew(VideoCaptureWrap::New); + NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(Nan::New("VideoCapture").ToLocalChecked()); + ctor->SetClassName(NanNew("VideoCapture")); // Prototype //Local proto = constructor->PrototypeTemplate(); - 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); + 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); - target->Set(Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction()); + target->Set(NanNew("VideoCapture"), ctor->GetFunction()); } NAN_METHOD(VideoCaptureWrap::New) { - Nan::HandleScope scope; + NanScope(); - if (info.This()->InternalFieldCount() == 0) - return Nan::ThrowTypeError("Cannot Instantiate without new"); + if (args.This()->InternalFieldCount() == 0) + return NanThrowTypeError("Cannot Instantiate without new"); VideoCaptureWrap *v; - if (info[0]->IsNumber()) { - v = new VideoCaptureWrap(info[0]->NumberValue()); + if (args[0]->IsNumber()) { + v = new VideoCaptureWrap(args[0]->NumberValue()); } else { //TODO - assumes that we have string, verify - v = new VideoCaptureWrap(std::string(*Nan::Utf8String(info[0]->ToString()))); + v = new VideoCaptureWrap(std::string(*NanAsciiString(args[0]->ToString()))); } - v->Wrap(info.This()); + v->Wrap(args.This()); - info.GetReturnValue().Set(info.This()); + NanReturnValue(args.This()); } VideoCaptureWrap::VideoCaptureWrap(int device) { - Nan::HandleScope scope; + NanScope(); cap.open(device); if(!cap.isOpened()) { - Nan::ThrowError("Camera could not be opened"); + NanThrowError("Camera could not be opened"); } } VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) { - Nan::HandleScope scope; + NanScope(); cap.open(filename); // TODO! At the moment this only takes a full path - do relative too. if(!cap.isOpened()) { - Nan::ThrowError("Video file could not be opened (opencv reqs. non relative paths)"); + NanThrowError("Video file could not be opened (opencv reqs. non relative paths)"); } } NAN_METHOD(VideoCaptureWrap::SetWidth) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); - if(info.Length() != 1) - return; + if(args.Length() != 1) + NanReturnUndefined(); - int w = info[0]->IntegerValue(); + int w = args[0]->IntegerValue(); if(v->cap.isOpened()) v->cap.set(CV_CAP_PROP_FRAME_WIDTH, w); - return; + NanReturnUndefined(); } NAN_METHOD(VideoCaptureWrap::SetHeight) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); - if(info.Length() != 1) - return; + if(args.Length() != 1) + NanReturnUndefined(); - int h = info[0]->IntegerValue(); + int h = args[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h); - return; + NanReturnUndefined(); } NAN_METHOD(VideoCaptureWrap::SetPosition) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); - if(info.Length() != 1) - return; + if(args.Length() != 1) + NanReturnUndefined(); - int pos = info[0]->IntegerValue(); + int pos = args[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_POS_FRAMES, pos); - return; + NanReturnUndefined(); } NAN_METHOD(VideoCaptureWrap::Close) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); v->cap.release(); - return; + NanReturnUndefined(); } -class AsyncVCWorker: public Nan::AsyncWorker { +class AsyncVCWorker: public NanAsyncWorker { public: - AsyncVCWorker(Nan::Callback *callback, VideoCaptureWrap* vc, + AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc, bool retrieve = false, int channel = 0) : - Nan::AsyncWorker(callback), + NanAsyncWorker(callback), vc(vc), retrieve(retrieve), channel(channel) { @@ -161,14 +161,14 @@ public: // this function will be run inside the main event loop // so it is safe to use V8 again void HandleOKCallback() { - Nan::HandleScope scope; + NanScope(); - Local im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im_to_return); + Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_to_return); img->mat = mat; Local argv[] = { - Nan::Null() + NanNull() , im_to_return }; @@ -187,33 +187,33 @@ private: }; NAN_METHOD(VideoCaptureWrap::Read) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); REQ_FUN_ARG(0, cb); - Nan::Callback *callback = new Nan::Callback(cb.As()); - Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v)); + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncVCWorker(callback, v)); - return; + NanReturnUndefined(); } NAN_METHOD(VideoCaptureWrap::ReadSync) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); - Local im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = Nan::ObjectWrap::Unwrap(im_to_return); + Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_to_return); v->cap.read(img->mat); - info.GetReturnValue().Set(im_to_return); + NanReturnValue(im_to_return); } -class AsyncGrabWorker: public Nan::AsyncWorker { +class AsyncGrabWorker: public NanAsyncWorker { public: - AsyncGrabWorker(Nan::Callback *callback, VideoCaptureWrap* vc) : - Nan::AsyncWorker(callback), + AsyncGrabWorker(NanCallback *callback, VideoCaptureWrap* vc) : + NanAsyncWorker(callback), vc(vc) { } @@ -231,27 +231,27 @@ private: }; NAN_METHOD(VideoCaptureWrap::Grab) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); REQ_FUN_ARG(0, cb); - Nan::Callback *callback = new Nan::Callback(cb.As()); - Nan::AsyncQueueWorker(new AsyncGrabWorker(callback, v)); + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncGrabWorker(callback, v)); - return; + NanReturnUndefined(); } NAN_METHOD(VideoCaptureWrap::Retrieve) { - Nan::HandleScope scope; - VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); + NanScope(); + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); int channel = 0; REQ_FUN_ARG(0, cb); INT_FROM_ARGS(channel, 1); - Nan::Callback *callback = new Nan::Callback(cb.As()); - Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); - return; + NanReturnUndefined(); } diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h old mode 100644 new mode 100755 index a9b3b03..fb16c4d --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class VideoCaptureWrap: public Nan::ObjectWrap { +class VideoCaptureWrap: public node::ObjectWrap { public: cv::VideoCapture cap; - static Nan::Persistent constructor; + static Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/init.cc b/src/init.cc old mode 100644 new mode 100755 index 9e1b2fc..56495c3 --- a/src/init.cc +++ b/src/init.cc @@ -16,7 +16,7 @@ #include "BackgroundSubtractor.h" extern "C" void init(Handle target) { - Nan::HandleScope scope; + NanScope(); OpenCV::Init(target); Point::Init(target); diff --git a/vagrant/user.sh b/vagrant/user.sh index 2429f40..fb22639 100755 --- a/vagrant/user.sh +++ b/vagrant/user.sh @@ -24,5 +24,3 @@ apt-get -y install libgtk2.0-dev cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON .. make install cd /home/vagrant/$REPO_FOLDER/ - -npm install node-gyp -g \ No newline at end of file From 0216128fb053edc2dbf2fdb884217123e8b33f21 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Thu, 1 Oct 2015 18:15:10 -0500 Subject: [PATCH 5/9] Builds fine in 4, Fails in 0.12.7 --- src/BackgroundSubtractor.cc | 66 +- src/BackgroundSubtractor.h | 4 +- src/Calib3D.cc | 264 +- src/Calib3D.h | 2 +- src/CamShift.cc | 62 +- src/CamShift.h | 4 +- src/CascadeClassifierWrap.cc | 82 +- src/CascadeClassifierWrap.h | 4 +- src/Constants.cc | 12 +- src/Constants.h | 2 +- src/Contours.cc | 316 +- src/Contours.h | 4 +- src/FaceRecognizer.cc | 112 +- src/FaceRecognizer.h | 4 +- src/Features2d.cc | 28 +- src/Features2d.h | 4 +- src/HighGUI.cc | 54 +- src/HighGUI.h | 4 +- src/ImgProc.cc | 88 +- src/ImgProc.h | 2 +- src/Matrix.cc | 1418 ++++----- src/Matrix.h | 58 +- src/OpenCV.cc | 40 +- src/OpenCV.h | 24 +- src/Point.cc | 60 +- src/Point.h | 4 +- src/Stereo.cc | 218 +- src/Stereo.h | 12 +- src/VideoCaptureWrap.cc | 156 +- src/VideoCaptureWrap.h | 4 +- src/init.cc | 2 +- upgrade-log.html | 5333 ++++++++++++++++++++++++++++++++++ 32 files changed, 6890 insertions(+), 1557 deletions(-) create mode 100644 upgrade-log.html diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index af242b8..7bf1741 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -5,60 +5,60 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) -Persistent BackgroundSubtractorWrap::constructor; +Nan::Persistent BackgroundSubtractorWrap::constructor; void BackgroundSubtractorWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(BackgroundSubtractorWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(BackgroundSubtractorWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); } NAN_METHOD(BackgroundSubtractorWrap::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } // Create MOG by default cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); - pt->Wrap(args.This()); + pt->Wrap(info.This()); - NanReturnValue(args.This()); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) { - NanScope(); + Nan::HandleScope scope; // int history = 200; // int nmixtures = 5; // double backgroundRatio = 0.7; // double noiseSigma = 0; // - // if(args.Length() > 1){ + // if(info.Length() > 1){ // INT_FROM_ARGS(history, 0) // INT_FROM_ARGS(nmixtures, 1) // DOUBLE_FROM_ARGS(backgroundRatio, 2) // DOUBLE_FROM_ARGS(noiseSigma, 3) // } - Local n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } // Fetch foreground mask @@ -67,32 +67,32 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { REQ_FUN_ARG(1, cb); Local argv[2]; - 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; } try { Local fgMask = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(fgMask); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(fgMask); cv::Mat mat; - 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()); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); mat = cv::imdecode(*mbuf, -1); //mbuf->release(); } else { - Matrix *_img = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *_img = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); mat = (_img->mat).clone(); } if (mat.empty()) { - return NanThrowTypeError("Error loading file"); + return Nan::ThrowTypeError("Error loading file"); } cv::Mat _fgMask; @@ -101,20 +101,20 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { img->mat = _fgMask; mat.release(); - argv[0] = NanNull(); + argv[0] = Nan::Null(); argv[1] = fgMask; TryCatch try_catch; - cb->Call(NanGetCurrentContext()->Global(), 2, argv); + cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - NanReturnUndefined(); + return; } catch (cv::Exception& e) { const char* err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/BackgroundSubtractor.h b/src/BackgroundSubtractor.h index 67d51c5..b237699 100644 --- a/src/BackgroundSubtractor.h +++ b/src/BackgroundSubtractor.h @@ -4,11 +4,11 @@ #include -class BackgroundSubtractorWrap: public node::ObjectWrap { +class BackgroundSubtractorWrap: public Nan::ObjectWrap { public: cv::Ptr subtractor; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Calib3D.cc b/src/Calib3D.cc index 1242f40..a49ed31 100644 --- a/src/Calib3D.cc +++ b/src/Calib3D.cc @@ -3,15 +3,15 @@ inline Local matrixFromMat(cv::Mat &input) { Local matrixWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *matrix = ObjectWrap::Unwrap(matrixWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *matrix = Nan::ObjectWrap::Unwrap(matrixWrap); matrix->mat = input; return matrixWrap; } inline cv::Mat matFromMatrix(Handle matrix) { - Matrix* m = ObjectWrap::Unwrap(matrix->ToObject()); + Matrix* m = Nan::ObjectWrap::Unwrap(matrix->ToObject()); return m->mat; } @@ -38,8 +38,8 @@ inline std::vector points2fFromArray(Handle array) { for (unsigned int i = 0; i < pointsArray->Length(); i++) { Local pt = pointsArray->Get(i)->ToObject(); points.push_back( - cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value())); + cv::Point2f(pt->Get(Nan::New("x").ToLocalChecked())->ToNumber()->Value(), + pt->Get(Nan::New("y").ToLocalChecked())->ToNumber()->Value())); } } else { JSTHROW_TYPE("Points not a valid array"); @@ -56,9 +56,9 @@ inline std::vector points3fFromArray(Handle array) { for (unsigned int i = 0; i < pointsArray->Length(); i++) { Local pt = pointsArray->Get(i)->ToObject(); points.push_back( - cv::Point3f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value(), - pt->Get(NanNew("z"))->ToNumber()->Value())); + cv::Point3f(pt->Get(Nan::New("x").ToLocalChecked())->ToNumber()->Value(), + pt->Get(Nan::New("y").ToLocalChecked())->ToNumber()->Value(), + pt->Get(Nan::New("z").ToLocalChecked())->ToNumber()->Value())); } } else { JSTHROW_TYPE("Must pass array of object points for each frame") @@ -100,35 +100,35 @@ inline std::vector > points3fFromArrayOfArrays( } void Calib3D::Init(Handle target) { - Persistent inner; - Local obj = NanNew(); - NanAssignPersistent(inner, obj); + Nan::Persistent inner; + Local obj = Nan::New(); + 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); } // cv::findChessboardCorners NAN_METHOD(Calib3D::FindChessboardCorners) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments from javascript // Arg 0 is the image - cv::Mat mat = matFromMatrix(args[0]); + cv::Mat mat = matFromMatrix(info[0]); // Arg 1 is the pattern size - cv::Size patternSize = sizeFromArray(args[1]); + cv::Size patternSize = sizeFromArray(info[1]); // Arg 2 would normally be the flags, ignoring this for now and using the // default flags @@ -138,77 +138,77 @@ NAN_METHOD(Calib3D::FindChessboardCorners) { bool found = cv::findChessboardCorners(mat, patternSize, corners); // Make the return value - Local ret = NanNew(); - ret->Set(NanNew("found"), NanNew(found)); + Local ret = Nan::New(); + ret->Set(Nan::New("found").ToLocalChecked(), Nan::New(found)); - Local cornersArray = NanNew(corners.size()); + Local cornersArray = Nan::New(corners.size()); for (unsigned int i = 0; i < corners.size(); i++) { - Local point_data = NanNew(); - point_data->Set(NanNew("x"), NanNew(corners[i].x)); - point_data->Set(NanNew("y"), NanNew(corners[i].y)); + Local point_data = Nan::New(); + point_data->Set(Nan::New("x").ToLocalChecked(), Nan::New(corners[i].x)); + point_data->Set(Nan::New("y").ToLocalChecked(), Nan::New(corners[i].y)); - cornersArray->Set(NanNew(i), point_data); + cornersArray->Set(Nan::New(i), point_data); } - ret->Set(NanNew("corners"), cornersArray); + ret->Set(Nan::New("corners").ToLocalChecked(), cornersArray); - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::drawChessboardCorners NAN_METHOD(Calib3D::DrawChessboardCorners) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the image - cv::Mat mat = matFromMatrix(args[0]); + cv::Mat mat = matFromMatrix(info[0]); // Arg 1 is the pattern size - cv::Size patternSize = sizeFromArray(args[1]); + cv::Size patternSize = sizeFromArray(info[1]); // Arg 2 is the corners array - std::vector corners = points2fFromArray(args[2]); + std::vector corners = points2fFromArray(info[2]); // Arg 3, pattern found boolean - bool patternWasFound = args[3]->ToBoolean()->Value(); + bool patternWasFound = info[3]->ToBoolean()->Value(); // Draw the corners cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound); // Return the passed image, now with corners drawn on it - NanReturnValue(args[0]); + info.GetReturnValue().Set(info[0]); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::calibrateCamera NAN_METHOD(Calib3D::CalibrateCamera) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0, the array of object points, an array of arrays std::vector > objectPoints = - points3fFromArrayOfArrays(args[0]); + points3fFromArrayOfArrays(info[0]); // Arg 1, the image points, another array of arrays std::vector > imagePoints = - points2fFromArrayOfArrays(args[1]); + points2fFromArrayOfArrays(info[1]); // Arg 2, the image size - cv::Size imageSize = sizeFromArray(args[2]); + cv::Size imageSize = sizeFromArray(info[2]); // Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, // skipping for now @@ -223,48 +223,48 @@ NAN_METHOD(Calib3D::CalibrateCamera) { dist, rvecs, tvecs); // make the return values - Local ret = NanNew(); + Local ret = Nan::New(); // Reprojection error - ret->Set(NanNew("reprojectionError"), NanNew(error)); + ret->Set(Nan::New("reprojectionError").ToLocalChecked(), Nan::New(error)); // K Local KMatrixWrap = matrixFromMat(K); - ret->Set(NanNew("K"), KMatrixWrap); + ret->Set(Nan::New("K").ToLocalChecked(), KMatrixWrap); // dist Local distMatrixWrap = matrixFromMat(dist); - ret->Set(NanNew("distortion"), distMatrixWrap); + ret->Set(Nan::New("distortion").ToLocalChecked(), distMatrixWrap); // Per frame R and t, skiping for now // Return - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::solvePnP NAN_METHOD(Calib3D::SolvePnP) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0, the array of object points - std::vector objectPoints = points3fFromArray(args[0]); + std::vector objectPoints = points3fFromArray(info[0]); // Arg 1, the image points - std::vector imagePoints = points2fFromArray(args[1]); + std::vector imagePoints = points2fFromArray(info[1]); // Arg 2, the camera matrix - cv::Mat K = matFromMatrix(args[2]); + cv::Mat K = matFromMatrix(info[2]); // Arg 3, the distortion coefficients - cv::Mat dist = matFromMatrix(args[3]); + cv::Mat dist = matFromMatrix(info[3]); // Arg 4, use extrinsic guess, skipped for now @@ -276,47 +276,47 @@ NAN_METHOD(Calib3D::SolvePnP) { cv::solvePnP(objectPoints, imagePoints, K, dist, rvec, tvec); // make the return values - Local ret = NanNew(); + Local ret = Nan::New(); // rvec Local rMatrixWrap = matrixFromMat(rvec); - ret->Set(NanNew("rvec"), rMatrixWrap); + ret->Set(Nan::New("rvec").ToLocalChecked(), rMatrixWrap); // tvec Local tMatrixWrap = matrixFromMat(tvec); - ret->Set(NanNew("tvec"), tMatrixWrap); + ret->Set(Nan::New("tvec").ToLocalChecked(), tMatrixWrap); // Return - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::getOptimalNewCameraMAtrix NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the original camera matrix - cv::Mat Kin = matFromMatrix(args[0]); + cv::Mat Kin = matFromMatrix(info[0]); // Arg 1 is the distortion coefficients - cv::Mat dist = matFromMatrix(args[1]); + cv::Mat dist = matFromMatrix(info[1]); // Arg 2, the image size - cv::Size imageSize = sizeFromArray(args[2]); + cv::Size imageSize = sizeFromArray(info[2]); // Arg 3 is the alpha free scaling parameter - double alpha = args[3]->ToNumber()->Value(); + double alpha = info[3]->ToNumber()->Value(); // Arg 4, the new image size - cv::Size newImageSize = sizeFromArray(args[4]); + cv::Size newImageSize = sizeFromArray(info[4]); // Arg 5, valid ROI, skip for now // Arg 6, center principal point, skip for now @@ -329,46 +329,46 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { Local KMatrixWrap = matrixFromMat(Kout); // Return the new K matrix - NanReturnValue(KMatrixWrap); + info.GetReturnValue().Set(KMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::stereoCalibrate NAN_METHOD(Calib3D::StereoCalibrate) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0, the array of object points, an array of arrays std::vector > objectPoints = - points3fFromArrayOfArrays(args[0]); + points3fFromArrayOfArrays(info[0]); // Arg 1, the image points1, another array of arrays std::vector > imagePoints1 = - points2fFromArrayOfArrays(args[1]); + points2fFromArrayOfArrays(info[1]); // Arg 2, the image points2, another array of arrays =( std::vector > imagePoints2 = - points2fFromArrayOfArrays(args[2]); + points2fFromArrayOfArrays(info[2]); // Arg 3 is the image size (follows the PYTHON api not the C++ api since all // following arguments are optional or outputs) - cv::Size imageSize = sizeFromArray(args[3]); + cv::Size imageSize = sizeFromArray(info[3]); // Arg 4,5,6,7 is the camera matrix and distortion coefficients // (optional but must pass all 4 or none) cv::Mat k1, d1, k2, d2; - 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]); } // Last argument is flags, skipping for now @@ -381,7 +381,7 @@ NAN_METHOD(Calib3D::StereoCalibrate) { d2, imageSize, R, t, E, F); // make the return value - Local ret = NanNew(); + Local ret = Nan::New(); // Make the output arguments @@ -410,51 +410,51 @@ NAN_METHOD(Calib3D::StereoCalibrate) { Local FMatrixWrap = matrixFromMat(F); // Add to return object - ret->Set(NanNew("K1"), K1MatrixWrap); - ret->Set(NanNew("distortion1"), d1MatrixWrap); - ret->Set(NanNew("K2"), K2MatrixWrap); - ret->Set(NanNew("distortion2"), d2MatrixWrap); - ret->Set(NanNew("R"), RMatrixWrap); - ret->Set(NanNew("t"), tMatrixWrap); - ret->Set(NanNew("E"), EMatrixWrap); - ret->Set(NanNew("F"), FMatrixWrap); + ret->Set(Nan::New("K1").ToLocalChecked(), K1MatrixWrap); + ret->Set(Nan::New("distortion1").ToLocalChecked(), d1MatrixWrap); + ret->Set(Nan::New("K2").ToLocalChecked(), K2MatrixWrap); + ret->Set(Nan::New("distortion2").ToLocalChecked(), d2MatrixWrap); + ret->Set(Nan::New("R").ToLocalChecked(), RMatrixWrap); + ret->Set(Nan::New("t").ToLocalChecked(), tMatrixWrap); + ret->Set(Nan::New("E").ToLocalChecked(), EMatrixWrap); + ret->Set(Nan::New("F").ToLocalChecked(), FMatrixWrap); // Return - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::stereoRectify NAN_METHOD(Calib3D::StereoRectify) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg0, the first camera matrix - cv::Mat K1 = matFromMatrix(args[0]); + cv::Mat K1 = matFromMatrix(info[0]); // Arg1, the first distortion coefficients - cv::Mat d1 = matFromMatrix(args[1]); + cv::Mat d1 = matFromMatrix(info[1]); // Arg2, the second camera matrix - cv::Mat K2 = matFromMatrix(args[2]); + cv::Mat K2 = matFromMatrix(info[2]); // Arg3, the second distortion coefficients - cv::Mat d2 = matFromMatrix(args[3]); + cv::Mat d2 = matFromMatrix(info[3]); // Arg4, the image size - cv::Size imageSize = sizeFromArray(args[4]); + cv::Size imageSize = sizeFromArray(info[4]); // arg5, the intercamera rotation matrix - cv::Mat R = matFromMatrix(args[5]); + cv::Mat R = matFromMatrix(info[5]); // Arg6, the intercamera translation vector - cv::Mat t = matFromMatrix(args[6]); + cv::Mat t = matFromMatrix(info[6]); // Arg8, flags, skipping for now @@ -469,76 +469,76 @@ NAN_METHOD(Calib3D::StereoRectify) { cv::stereoRectify(K1, d1, K2, d2, imageSize, R, t, R1, R2, P1, P2, Q); // Make the return object - Local ret = NanNew(); + Local ret = Nan::New(); - ret->Set(NanNew("R1"), matrixFromMat(R1)); - ret->Set(NanNew("R2"), matrixFromMat(R2)); - ret->Set(NanNew("P1"), matrixFromMat(P1)); - ret->Set(NanNew("P2"), matrixFromMat(P2)); - ret->Set(NanNew("Q"), matrixFromMat(Q)); + ret->Set(Nan::New("R1").ToLocalChecked(), matrixFromMat(R1)); + ret->Set(Nan::New("R2").ToLocalChecked(), matrixFromMat(R2)); + ret->Set(Nan::New("P1").ToLocalChecked(), matrixFromMat(P1)); + ret->Set(Nan::New("P2").ToLocalChecked(), matrixFromMat(P2)); + ret->Set(Nan::New("Q").ToLocalChecked(), matrixFromMat(Q)); // Return the rectification parameters - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::computeCorrespondEpilines NAN_METHOD(Calib3D::ComputeCorrespondEpilines) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg0, the image points - std::vector points = points2fFromArray(args[0]); + std::vector points = points2fFromArray(info[0]); // Arg1, the image index (1 or 2) - int whichImage = int(args[1]->ToNumber()->Value()); + int whichImage = int(info[1]->ToNumber()->Value()); // Arg2, the fundamental matrix - cv::Mat F = matFromMatrix(args[2]); + cv::Mat F = matFromMatrix(info[2]); // compute the lines std::vector lines; cv::computeCorrespondEpilines(points, whichImage, F, lines); // Convert the lines to an array of objects (ax + by + c = 0) - Local linesArray = NanNew(lines.size()); + Local linesArray = Nan::New(lines.size()); for(unsigned int i = 0; i < lines.size(); i++) { - Local line_data = NanNew(); - line_data->Set(NanNew("a"), NanNew(lines[i][0])); - line_data->Set(NanNew("b"), NanNew(lines[i][1])); - line_data->Set(NanNew("c"), NanNew(lines[i][2])); + Local line_data = Nan::New(); + line_data->Set(Nan::New("a").ToLocalChecked(), Nan::New(lines[i][0])); + line_data->Set(Nan::New("b").ToLocalChecked(), Nan::New(lines[i][1])); + line_data->Set(Nan::New("c").ToLocalChecked(), Nan::New(lines[i][2])); - linesArray->Set(NanNew(i), line_data); + linesArray->Set(Nan::New(i), line_data); } // Return the lines - NanReturnValue(linesArray); + info.GetReturnValue().Set(linesArray); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::reprojectImageTo3D NAN_METHOD(Calib3D::ReprojectImageTo3D) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg0, the disparity image - cv::Mat disparity = matFromMatrix(args[0]); + cv::Mat disparity = matFromMatrix(info[0]); // Arg1, the depth-to-disparity transformation Q - cv::Mat Q = matFromMatrix(args[1]); + cv::Mat Q = matFromMatrix(info[1]); // Arg 2, handle missing values, skipped for now @@ -551,10 +551,10 @@ NAN_METHOD(Calib3D::ReprojectImageTo3D) { // Wrap the depth image Local depthImageMatrix = matrixFromMat(depthImage); - NanReturnValue(depthImageMatrix); + info.GetReturnValue().Set(depthImageMatrix); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/Calib3D.h b/src/Calib3D.h index a2f89f5..9617757 100644 --- a/src/Calib3D.h +++ b/src/Calib3D.h @@ -6,7 +6,7 @@ /** * Implementation of calib3d.hpp functions */ -class Calib3D: public node::ObjectWrap { +class Calib3D: public Nan::ObjectWrap { public: static void Init(Handle target); static NAN_METHOD(FindChessboardCorners); diff --git a/src/CamShift.cc b/src/CamShift.cc index 8468783..5e08324 100644 --- a/src/CamShift.cc +++ b/src/CamShift.cc @@ -8,38 +8,38 @@ #define CHANNEL_VALUE 2 -Persistent TrackedObject::constructor; +Nan::Persistent TrackedObject::constructor; void TrackedObject::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(TrackedObject::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(TrackedObject::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("TrackedObject")); + ctor->SetClassName(Nan::New("TrackedObject").ToLocalChecked()); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); } NAN_METHOD(TrackedObject::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } - Matrix* m = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Rect r; int channel = CHANNEL_HUE; - if (args[1]->IsArray()) { - Local v8rec = args[1]->ToObject(); + if (info[1]->IsArray()) { + Local v8rec = info[1]->ToObject(); r = cv::Rect( v8rec->Get(0)->IntegerValue(), v8rec->Get(1)->IntegerValue(), @@ -49,11 +49,11 @@ NAN_METHOD(TrackedObject::New) { JSTHROW_TYPE("Must pass rectangle to track") } - if (args[2]->IsObject()) { - Local opts = args[2]->ToObject(); + if (info[2]->IsObject()) { + Local 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()); std::string cc = std::string(*c); if (cc == "hue" || cc == "h") { @@ -72,8 +72,8 @@ NAN_METHOD(TrackedObject::New) { TrackedObject *to = new TrackedObject(m->mat, r, channel); - to->Wrap(args.This()); - NanReturnValue(args.This()); + to->Wrap(info.This()); + info.GetReturnValue().Set(info.This()); } void update_chann_image(TrackedObject* t, cv::Mat image) { @@ -117,17 +117,17 @@ TrackedObject::TrackedObject(cv::Mat image, cv::Rect rect, int chan) { NAN_METHOD(TrackedObject::Track) { SETUP_FUNCTION(TrackedObject) - 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(args[0]->ToObject()); + Matrix *im = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::RotatedRect r; if ((self->prev_rect.x < 0) || (self->prev_rect.y < 0) || (self->prev_rect.width <= 1) || (self->prev_rect.height <= 1)) { - return NanThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); + return Nan::ThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); } update_chann_image(self, im->mat); @@ -155,21 +155,21 @@ NAN_METHOD(TrackedObject::Track) { self->prev_rect = backup_prev_rect; } - v8::Local arr = NanNew(4); + v8::Local arr = Nan::New(4); - arr->Set(0, NanNew(bounds.x)); - arr->Set(1, NanNew(bounds.y)); - arr->Set(2, NanNew(bounds.x + bounds.width)); - arr->Set(3, NanNew(bounds.y + bounds.height)); + arr->Set(0, Nan::New(bounds.x)); + arr->Set(1, Nan::New(bounds.y)); + arr->Set(2, Nan::New(bounds.x + bounds.width)); + arr->Set(3, Nan::New(bounds.y + bounds.height)); /* cv::Point2f pts[4]; r.points(pts); for (int i = 0; i < 8; i += 2) { - arr->Set(i, NanNew(pts[i].x)); - arr->Set(i + 1, NanNew(pts[i].y)); + arr->Set(i, Nan::New(pts[i].x)); + arr->Set(i + 1, Nan::New(pts[i].y)); } */ - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } diff --git a/src/CamShift.h b/src/CamShift.h index f43be0c..ac049f3 100644 --- a/src/CamShift.h +++ b/src/CamShift.h @@ -1,7 +1,7 @@ #include "OpenCV.h" -class TrackedObject: public node::ObjectWrap { +class TrackedObject: public Nan::ObjectWrap { public: int channel; cv::Mat hsv; @@ -12,7 +12,7 @@ public: cv::Mat hist; cv::Rect prev_rect; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index 64fae09..c3dce38 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -3,50 +3,50 @@ #include "Matrix.h" #include -Persistent CascadeClassifierWrap::constructor; +Nan::Persistent CascadeClassifierWrap::constructor; void CascadeClassifierWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew (CascadeClassifierWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New (CascadeClassifierWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("CascadeClassifier")); + ctor->SetClassName(Nan::New("CascadeClassifier").ToLocalChecked()); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); } NAN_METHOD(CascadeClassifierWrap::New) { - 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() ); } CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName) { std::string filename; - filename = std::string(*NanAsciiString(fileName->ToString())); + filename = std::string(*Nan::Utf8String(fileName->ToString())); if (!cc.load(filename.c_str())) { - NanThrowTypeError("Error loading file"); + Nan::ThrowTypeError("Error loading file"); } } -class AsyncDetectMultiScale: public NanAsyncWorker { +class AsyncDetectMultiScale: public Nan::AsyncWorker { public: - AsyncDetectMultiScale(NanCallback *callback, CascadeClassifierWrap *cc, + AsyncDetectMultiScale(Nan::Callback *callback, CascadeClassifierWrap *cc, Matrix* im, double scale, int neighbors, int minw, int minh) : - NanAsyncWorker(callback), + Nan::AsyncWorker(callback), cc(cc), im(im), scale(scale), @@ -79,22 +79,22 @@ public: } void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; // this->matrix->Unref(); Handle < Value > argv[2]; - v8::Local < v8::Array > arr = NanNew < v8::Array > (this->res.size()); + v8::Local < v8::Array > arr = Nan::New < v8::Array > (this->res.size()); for (unsigned int i = 0; i < this->res.size(); i++) { - v8::Local < v8::Object > x = NanNew(); - 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(); + 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)); arr->Set(i, x); } - argv[0] = NanNull(); + argv[0] = Nan::Null(); argv[1] = arr; TryCatch try_catch; @@ -115,37 +115,37 @@ private: }; NAN_METHOD(CascadeClassifierWrap::DetectMultiScale) { - NanScope(); + Nan::HandleScope scope; - CascadeClassifierWrap *self = ObjectWrap::Unwrap (args.This()); + CascadeClassifierWrap *self = Nan::ObjectWrap::Unwrap (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()); REQ_FUN_ARG(1, cb); double scale = 1.1; - if (args.Length() > 2 && args[2]->IsNumber()) { - scale = args[2]->NumberValue(); + if (info.Length() > 2 && info[2]->IsNumber()) { + scale = info[2]->NumberValue(); } int neighbors = 2; - if (args.Length() > 3 && args[3]->IsInt32()) { - neighbors = args[3]->IntegerValue(); + if (info.Length() > 3 && info[3]->IsInt32()) { + neighbors = info[3]->IntegerValue(); } int minw = 30; int minh = 30; - 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()); + Nan::Callback *callback = new Nan::Callback(cb.As()); - NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, + Nan::AsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, neighbors, minw, minh)); - NanReturnUndefined(); + return; } diff --git a/src/CascadeClassifierWrap.h b/src/CascadeClassifierWrap.h index 060ca3f..c0016d9 100755 --- a/src/CascadeClassifierWrap.h +++ b/src/CascadeClassifierWrap.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class CascadeClassifierWrap: public node::ObjectWrap { +class CascadeClassifierWrap: public Nan::ObjectWrap { public: cv::CascadeClassifier cc; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Constants.cc b/src/Constants.cc index 1ed9904..5d9fa22 100644 --- a/src/Constants.cc +++ b/src/Constants.cc @@ -2,15 +2,15 @@ #include "Constants.h" #define CONST(C) \ - obj->Set(NanNew(#C), NanNew(C)); + obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New(C)); #define CONST_ENUM(C) \ - obj->Set(NanNew(#C), NanNew((int)(cv::C))); + obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New((int)(cv::C))); void Constants::Init(Handle target) { - Persistent inner; - Local obj = NanNew(); - NanAssignPersistent(inner, obj); + Nan::Persistent inner; + Local obj = Nan::New(); + inner.Reset(obj); CONST(CV_8U); CONST(CV_8S); @@ -72,7 +72,7 @@ void Constants::Init(Handle target) { CONST_ENUM(NORM_RELATIVE); CONST_ENUM(NORM_TYPE_MASK); - target->Set(NanNew("Constants"), obj); + target->Set(Nan::New("Constants").ToLocalChecked(), obj); } #undef CONST diff --git a/src/Constants.h b/src/Constants.h index c7bb6c6..9bb818e 100644 --- a/src/Constants.h +++ b/src/Constants.h @@ -1,6 +1,6 @@ #include "OpenCV.h" -class Constants: public node::ObjectWrap { +class Constants: public Nan::ObjectWrap { public: static void Init(Handle target); }; diff --git a/src/Contours.cc b/src/Contours.cc index 9705ff0..f8eb726 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -4,337 +4,337 @@ #include -v8::Persistent Contour::constructor; +Nan::Persistent Contour::constructor; void Contour::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Class/contructor - Local ctor = NanNew(Contour::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(Contour::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("Contours")); + ctor->SetClassName(Nan::New("Contours").ToLocalChecked()); // Prototype // Local proto = constructor->PrototypeTemplate(); - 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()); }; NAN_METHOD(Contour::New) { - 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"); } Contour *contours; contours = new Contour; - contours->Wrap(args.Holder()); - NanReturnValue(args.Holder()); + contours->Wrap(info.Holder()); + info.GetReturnValue().Set(info.Holder()); } Contour::Contour() : - ObjectWrap() { + Nan::ObjectWrap() { } NAN_METHOD(Contour::Point) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); - int index = args[1]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); + int index = info[1]->NumberValue(); cv::Point point = self->contours[pos][index]; - Local data = NanNew(); - data->Set(NanNew("x"), NanNew(point.x)); - data->Set(NanNew("y"), NanNew(point.y)); + Local data = Nan::New(); + data->Set(Nan::New("x").ToLocalChecked(), Nan::New(point.x)); + data->Set(Nan::New("y").ToLocalChecked(), Nan::New(point.y)); - NanReturnValue(data); + info.GetReturnValue().Set(data); } NAN_METHOD(Contour::Points) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); vector points = self->contours[pos]; - Local data = NanNew(points.size()); + Local data = Nan::New(points.size()); for (std::vector::size_type i = 0; i != points.size(); i++) { - Local point_data = NanNew(); - point_data->Set(NanNew("x"), NanNew(points[i].x)); - point_data->Set(NanNew("y"), NanNew(points[i].y)); + Local point_data = Nan::New(); + point_data->Set(Nan::New("x").ToLocalChecked(), Nan::New(points[i].x)); + point_data->Set(Nan::New("y").ToLocalChecked(), Nan::New(points[i].y)); data->Set(i, point_data); } - NanReturnValue(data); + info.GetReturnValue().Set(data); } // FIXME: this should better be called "Length" as ``Contours`` is an Array like // structure also, this would allow to use ``Size`` for the function returning // the number of corners in the contour for better consistency with OpenCV. NAN_METHOD(Contour::Size) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - NanReturnValue(NanNew(self->contours.size())); + info.GetReturnValue().Set(Nan::New(self->contours.size())); } NAN_METHOD(Contour::CornerCount) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); - NanReturnValue(NanNew(self->contours[pos].size())); + info.GetReturnValue().Set(Nan::New(self->contours[pos].size())); } NAN_METHOD(Contour::Area) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); - // NanReturnValue(NanNew(contourArea(self->contours))); - NanReturnValue(NanNew(contourArea(cv::Mat(self->contours[pos])))); + // info.GetReturnValue().Set(Nan::New(contourArea(self->contours))); + info.GetReturnValue().Set(Nan::New(contourArea(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::ArcLength) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); - bool isClosed = args[1]->BooleanValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); + bool isClosed = info[1]->BooleanValue(); - NanReturnValue(NanNew(arcLength(cv::Mat(self->contours[pos]), isClosed))); + info.GetReturnValue().Set(Nan::New(arcLength(cv::Mat(self->contours[pos]), isClosed))); } NAN_METHOD(Contour::ApproxPolyDP) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); - double epsilon = args[1]->NumberValue(); - bool isClosed = args[2]->BooleanValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); + double epsilon = info[1]->NumberValue(); + bool isClosed = info[2]->BooleanValue(); cv::Mat approxed; approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed); approxed.copyTo(self->contours[pos]); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Contour::ConvexHull) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - int pos = args[0]->NumberValue(); - bool clockwise = args[1]->BooleanValue(); + int pos = info[0]->NumberValue(); + bool clockwise = info[1]->BooleanValue(); cv::Mat hull; cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise); hull.copyTo(self->contours[pos]); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Contour::BoundingRect) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos])); - Local rect = NanNew(); + Local rect = Nan::New(); - rect->Set(NanNew("x"), NanNew(bounding.x)); - rect->Set(NanNew("y"), NanNew(bounding.y)); - rect->Set(NanNew("width"), NanNew(bounding.width)); - rect->Set(NanNew("height"), NanNew(bounding.height)); + rect->Set(Nan::New("x").ToLocalChecked(), Nan::New(bounding.x)); + rect->Set(Nan::New("y").ToLocalChecked(), Nan::New(bounding.y)); + rect->Set(Nan::New("width").ToLocalChecked(), Nan::New(bounding.width)); + rect->Set(Nan::New("height").ToLocalChecked(), Nan::New(bounding.height)); - NanReturnValue(rect); + info.GetReturnValue().Set(rect); } NAN_METHOD(Contour::MinAreaRect) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos])); - Local rect = NanNew(); - rect->Set(NanNew("angle"), NanNew(minimum.angle)); + Local rect = Nan::New(); + rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New(minimum.angle)); - Local size = NanNew(); - size->Set(NanNew("height"), NanNew(minimum.size.height)); - size->Set(NanNew("width"), NanNew(minimum.size.width)); - rect->Set(NanNew("size"), size); + Local size = Nan::New(); + size->Set(Nan::New("height").ToLocalChecked(), Nan::New(minimum.size.height)); + size->Set(Nan::New("width").ToLocalChecked(), Nan::New(minimum.size.width)); + rect->Set(Nan::New("size").ToLocalChecked(), size); - Local center = NanNew(); - center->Set(NanNew("x"), NanNew(minimum.center.x)); - center->Set(NanNew("y"), NanNew(minimum.center.y)); + Local center = Nan::New(); + center->Set(Nan::New("x").ToLocalChecked(), Nan::New(minimum.center.x)); + center->Set(Nan::New("y").ToLocalChecked(), Nan::New(minimum.center.y)); - v8::Local points = NanNew(4); + v8::Local points = Nan::New(4); cv::Point2f rect_points[4]; minimum.points(rect_points); for (unsigned int i=0; i<4; i++) { - Local point = NanNew(); - point->Set(NanNew("x"), NanNew(rect_points[i].x)); - point->Set(NanNew("y"), NanNew(rect_points[i].y)); + Local point = Nan::New(); + point->Set(Nan::New("x").ToLocalChecked(), Nan::New(rect_points[i].x)); + point->Set(Nan::New("y").ToLocalChecked(), Nan::New(rect_points[i].y)); points->Set(i, point); } - rect->Set(NanNew("points"), points); + rect->Set(Nan::New("points").ToLocalChecked(), points); - NanReturnValue(rect); + info.GetReturnValue().Set(rect); } NAN_METHOD(Contour::FitEllipse) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); if (self->contours[pos].size() >= 5) { // Minimum number for an ellipse cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos])); - Local jsEllipse = NanNew(); - jsEllipse->Set(NanNew("angle"), NanNew(ellipse.angle)); + Local jsEllipse = Nan::New(); + jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New(ellipse.angle)); - Local size = NanNew(); - size->Set(NanNew("height"), NanNew(ellipse.size.height)); - size->Set(NanNew("width"), NanNew(ellipse.size.width)); - jsEllipse->Set(NanNew("size"), size); + Local size = Nan::New(); + size->Set(Nan::New("height").ToLocalChecked(), Nan::New(ellipse.size.height)); + size->Set(Nan::New("width").ToLocalChecked(), Nan::New(ellipse.size.width)); + jsEllipse->Set(Nan::New("size").ToLocalChecked(), size); - Local center = NanNew(); - center->Set(NanNew("x"), NanNew(ellipse.center.x)); - center->Set(NanNew("y"), NanNew(ellipse.center.y)); - jsEllipse->Set(NanNew("center"), center); + Local center = Nan::New(); + center->Set(Nan::New("x").ToLocalChecked(), Nan::New(ellipse.center.x)); + center->Set(Nan::New("y").ToLocalChecked(), Nan::New(ellipse.center.y)); + jsEllipse->Set(Nan::New("center").ToLocalChecked(), center); - NanReturnValue(jsEllipse); + info.GetReturnValue().Set(jsEllipse); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Contour::IsConvex) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); - NanReturnValue(NanNew(isContourConvex(cv::Mat(self->contours[pos])))); + info.GetReturnValue().Set(Nan::New(isContourConvex(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::Moments) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->NumberValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->NumberValue(); // Get the moments cv::Moments mu = moments( self->contours[pos], false ); - Local res = NanNew(); + Local res = Nan::New(); - res->Set(NanNew("m00"), NanNew(mu.m00)); - res->Set(NanNew("m10"), NanNew(mu.m10)); - res->Set(NanNew("m01"), NanNew(mu.m01)); - res->Set(NanNew("m11"), NanNew(mu.m11)); + res->Set(Nan::New("m00").ToLocalChecked(), Nan::New(mu.m00)); + res->Set(Nan::New("m10").ToLocalChecked(), Nan::New(mu.m10)); + res->Set(Nan::New("m01").ToLocalChecked(), Nan::New(mu.m01)); + res->Set(Nan::New("m11").ToLocalChecked(), Nan::New(mu.m11)); - NanReturnValue(res); + info.GetReturnValue().Set(res); } NAN_METHOD(Contour::Hierarchy) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); - int pos = args[0]->IntegerValue(); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); + int pos = info[0]->IntegerValue(); cv::Vec4i hierarchy = self->hierarchy[pos]; - Local res = NanNew(4); + Local res = Nan::New(4); - res->Set(0, NanNew(hierarchy[0])); - res->Set(1, NanNew(hierarchy[1])); - res->Set(2, NanNew(hierarchy[2])); - res->Set(3, NanNew(hierarchy[3])); + res->Set(0, Nan::New(hierarchy[0])); + res->Set(1, Nan::New(hierarchy[1])); + res->Set(2, Nan::New(hierarchy[2])); + res->Set(3, Nan::New(hierarchy[3])); - NanReturnValue(res); + info.GetReturnValue().Set(res); } NAN_METHOD(Contour::Serialize) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - Local contours_data = NanNew(self->contours.size()); + Local contours_data = Nan::New(self->contours.size()); for (std::vector::size_type i = 0; i != self->contours.size(); i++) { vector points = self->contours[i]; - Local contour_data = NanNew(points.size()); + Local contour_data = Nan::New(points.size()); for (std::vector::size_type j = 0; j != points.size(); j++) { - Local point_data = NanNew(2); - point_data->Set(0, NanNew(points[j].x)); - point_data->Set(1, NanNew(points[j].y)); + Local point_data = Nan::New(2); + point_data->Set(0, Nan::New(points[j].x)); + point_data->Set(1, Nan::New(points[j].y)); contour_data->Set(j, point_data); } contours_data->Set(i, contour_data); } - Local hierarchy_data = NanNew(self->hierarchy.size()); + Local hierarchy_data = Nan::New(self->hierarchy.size()); for (std::vector::size_type i = 0; i != self->hierarchy.size(); i++) { - Local contour_data = NanNew(4); - contour_data->Set(0, NanNew(self->hierarchy[i][0])); - contour_data->Set(1, NanNew(self->hierarchy[i][1])); - contour_data->Set(2, NanNew(self->hierarchy[i][2])); - contour_data->Set(3, NanNew(self->hierarchy[i][3])); + Local contour_data = Nan::New(4); + contour_data->Set(0, Nan::New(self->hierarchy[i][0])); + contour_data->Set(1, Nan::New(self->hierarchy[i][1])); + contour_data->Set(2, Nan::New(self->hierarchy[i][2])); + contour_data->Set(3, Nan::New(self->hierarchy[i][3])); hierarchy_data->Set(i, contour_data); } - Local data = NanNew(); - data->Set(NanNew("contours"), contours_data); - data->Set(NanNew("hierarchy"), hierarchy_data); + Local data = Nan::New(); + data->Set(Nan::New("contours").ToLocalChecked(), contours_data); + data->Set(Nan::New("hierarchy").ToLocalChecked(), hierarchy_data); - NanReturnValue(data); + info.GetReturnValue().Set(data); } NAN_METHOD(Contour::Deserialize) { - NanScope(); + Nan::HandleScope scope; - Contour *self = ObjectWrap::Unwrap(args.This()); + Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - Handle data = Handle::Cast(args[0]); + Handle data = Handle::Cast(info[0]); - Handle contours_data = Handle::Cast(data->Get(NanNew("contours"))); - Handle hierarchy_data = Handle::Cast(data->Get(NanNew("hierarchy"))); + Handle contours_data = Handle::Cast(data->Get(Nan::New("contours").ToLocalChecked())); + Handle hierarchy_data = Handle::Cast(data->Get(Nan::New("hierarchy").ToLocalChecked())); vector > contours_res; int contours_length = contours_data->Length(); @@ -369,5 +369,5 @@ NAN_METHOD(Contour::Deserialize) { self->contours = contours_res; self->hierarchy = hierarchy_res; - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } diff --git a/src/Contours.h b/src/Contours.h index bd442ea..b1a496a 100755 --- a/src/Contours.h +++ b/src/Contours.h @@ -2,13 +2,13 @@ using namespace std; -class Contour: public node::ObjectWrap { +class Contour: public Nan::ObjectWrap { public: cv::Mat mat; vector > contours; vector hierarchy; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc index 3814d45..1b2eb82 100644 --- a/src/FaceRecognizer.cc +++ b/src/FaceRecognizer.cc @@ -14,11 +14,11 @@ cv::Mat fromMatrixOrFilename(Local v) { cv::Mat im; if (v->IsString()) { - std::string filename = std::string(*NanAsciiString(v->ToString())); + std::string filename = std::string(*Nan::Utf8String(v->ToString())); im = cv::imread(filename); // std::cout<< im.size(); } else { - Matrix *img = ObjectWrap::Unwrap(v->ToObject()); + Matrix *img = Nan::ObjectWrap::Unwrap(v->ToObject()); im = img->mat; } return im; @@ -27,36 +27,36 @@ cv::Mat fromMatrixOrFilename(Local v) { void AsyncPredict(uv_work_t *req); void AfterAsyncPredict(uv_work_t *req); -Persistent FaceRecognizerWrap::constructor; +Nan::Persistent FaceRecognizerWrap::constructor; void FaceRecognizerWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(FaceRecognizerWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(FaceRecognizerWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); }; NAN_METHOD(FaceRecognizerWrap::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } @@ -64,12 +64,12 @@ NAN_METHOD(FaceRecognizerWrap::New) { cv::Ptr f = cv::createLBPHFaceRecognizer(1, 8, 8, 8, 80.0); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); - pt->Wrap(args.This()); - NanReturnValue(args.This()); + pt->Wrap(info.This()); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { - NanScope(); + Nan::HandleScope scope; int radius = 1; int neighbors = 8; @@ -83,17 +83,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { INT_FROM_ARGS(grid_y, 3) DOUBLE_FROM_ARGS(threshold, 4) - Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createLBPHFaceRecognizer(radius, neighbors, grid_x, grid_y, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } NAN_METHOD(FaceRecognizerWrap::CreateEigen) { - NanScope(); + Nan::HandleScope scope; int components = 0; double threshold = DBL_MAX; @@ -101,17 +101,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateEigen) { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createEigenFaceRecognizer(components, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } NAN_METHOD(FaceRecognizerWrap::CreateFisher) { - NanScope(); + Nan::HandleScope scope; int components = 0; double threshold = DBL_MAX; @@ -119,14 +119,14 @@ NAN_METHOD(FaceRecognizerWrap::CreateFisher) { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); + Local n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createFisherFaceRecognizer(components, threshold); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER); pt->Wrap(n); - NanReturnValue( n ); + info.GetReturnValue().Set( n ); } FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, @@ -135,16 +135,16 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, typ = type; } -Handle UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, +Handle UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info, cv::vector* images, cv::vector* labels) { - if (args.Length() < 1 || !args[0]->IsArray()) { + if (info.Length() < 1 || !info[0]->IsArray()) { JSTHROW("FaceRecognizer.train takes a list of [ label, image] tuples") } // Iterate through [[label, image], ...] etc, and add matrix / label to vectors - // const Local tuples = v8::Array::Cast(*args[0]); - const Local tuples = Local::Cast(args[0]); + // const Local tuples = v8::Array::Cast(*info[0]); + const Local tuples = Local::Cast(info[0]); const uint32_t length = tuples->Length(); for (uint32_t i=0; i UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, labels->push_back(label); images->push_back(im); } - return NanUndefined(); + return Nan::Undefined(); } NAN_METHOD(FaceRecognizerWrap::TrainSync) { @@ -176,14 +176,14 @@ NAN_METHOD(FaceRecognizerWrap::TrainSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(args, &images, &labels); + Handle exception = UnwrapTrainingData(info, &images, &labels); if (!exception->IsUndefined()) { - NanReturnValue(exception); // FIXME: not too sure about returning exceptions like this + info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this } self->rec->train(images, labels); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::UpdateSync) { @@ -199,20 +199,20 @@ NAN_METHOD(FaceRecognizerWrap::UpdateSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(args, &images, &labels); + Handle exception = UnwrapTrainingData(info, &images, &labels); if (!exception->IsUndefined()) { JSTHROW(exception); } self->rec->update(images, labels); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::PredictSync) { SETUP_FUNCTION(FaceRecognizerWrap) - cv::Mat im = fromMatrixOrFilename(args[0]); // TODO CHECK! + cv::Mat im = fromMatrixOrFilename(info[0]); // TODO CHECK! cv::cvtColor(im, im, CV_RGB2GRAY); // int predictedLabel = self->rec->predict(im); @@ -220,46 +220,46 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync) { double confidence = 0.0; self->rec->predict(im, predictedLabel, confidence); - v8::Local res = NanNew(); - res->Set(NanNew("id"), NanNew(predictedLabel)); - res->Set(NanNew("confidence"), NanNew(confidence)); + v8::Local res = Nan::New(); + res->Set(Nan::New("id").ToLocalChecked(), Nan::New(predictedLabel)); + res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New(confidence)); - NanReturnValue(res); + info.GetReturnValue().Set(res); } NAN_METHOD(FaceRecognizerWrap::SaveSync) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!args[0]->IsString()) { + if (!info[0]->IsString()) { JSTHROW("Save takes a filename") } - std::string filename = std::string(*NanAsciiString(args[0]->ToString())); + std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); self->rec->save(filename); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::LoadSync) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!args[0]->IsString()) { + if (!info[0]->IsString()) { JSTHROW("Load takes a filename") } - std::string filename = std::string(*NanAsciiString(args[0]->ToString())); + std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); self->rec->load(filename); - NanReturnUndefined(); + return; } NAN_METHOD(FaceRecognizerWrap::GetMat) { SETUP_FUNCTION(FaceRecognizerWrap) - if (!args[0]->IsString()) { + if (!info[0]->IsString()) { JSTHROW("getMat takes a key") } - std::string key = std::string(*NanAsciiString(args[0]->ToString())); + std::string key = std::string(*Nan::Utf8String(info[0]->ToString())); cv::Mat m = self->rec->getMat(key); - Local im = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im); + Local im = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im); img->mat = m; - NanReturnValue(im); + info.GetReturnValue().Set(im); } #endif // End version > 2.4 diff --git a/src/FaceRecognizer.h b/src/FaceRecognizer.h index d9bf2aa..6a19d10 100644 --- a/src/FaceRecognizer.h +++ b/src/FaceRecognizer.h @@ -4,12 +4,12 @@ #include "opencv2/contrib/contrib.hpp" -class FaceRecognizerWrap: public node::ObjectWrap { +class FaceRecognizerWrap: public Nan::ObjectWrap { public: cv::Ptr rec; int typ; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/Features2d.cc b/src/Features2d.cc index e099275..ce09abc 100644 --- a/src/Features2d.cc +++ b/src/Features2d.cc @@ -6,15 +6,15 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) void Features::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - NODE_SET_METHOD(target, "ImageSimilarity", Similarity); + Nan::SetMethod(target, "ImageSimilarity", Similarity); } -class AsyncDetectSimilarity: public NanAsyncWorker { +class AsyncDetectSimilarity: public Nan::AsyncWorker { public: - AsyncDetectSimilarity(NanCallback *callback, cv::Mat image1, cv::Mat image2) : - NanAsyncWorker(callback), + AsyncDetectSimilarity(Nan::Callback *callback, cv::Mat image1, cv::Mat image2) : + Nan::AsyncWorker(callback), image1(image1), image2(image2), dissimilarity(0) { @@ -80,12 +80,12 @@ public: } void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; Handle argv[2]; - argv[0] = NanNull(); - argv[1] = NanNew(dissimilarity); + argv[0] = Nan::Null(); + argv[1] = Nan::New(dissimilarity); callback->Call(2, argv); } @@ -97,17 +97,17 @@ private: }; NAN_METHOD(Features::Similarity) { - NanScope(); + Nan::HandleScope scope; REQ_FUN_ARG(2, cb); - cv::Mat image1 = ObjectWrap::Unwrap(args[0]->ToObject())->mat; - cv::Mat image2 = ObjectWrap::Unwrap(args[1]->ToObject())->mat; + cv::Mat image1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject())->mat; + cv::Mat image2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject())->mat; - NanCallback *callback = new NanCallback(cb.As()); + Nan::Callback *callback = new Nan::Callback(cb.As()); - NanAsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); - NanReturnUndefined(); + Nan::AsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); + return; } #endif diff --git a/src/Features2d.h b/src/Features2d.h index 764bec8..600f646 100644 --- a/src/Features2d.h +++ b/src/Features2d.h @@ -5,9 +5,9 @@ #include #include -class Features: public node::ObjectWrap { +class Features: public Nan::ObjectWrap { public: - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(Similarity); diff --git a/src/HighGUI.cc b/src/HighGUI.cc index 6e09579..b43fb89 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -2,41 +2,41 @@ #include "OpenCV.h" #include "Matrix.h" -Persistent NamedWindow::constructor; +Nan::Persistent NamedWindow::constructor; void NamedWindow::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(NamedWindow::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(NamedWindow::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("NamedWindow")); + ctor->SetClassName(Nan::New("NamedWindow").ToLocalChecked()); // Prototype - 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()); }; NAN_METHOD(NamedWindow::New) { - NanScope(); + Nan::HandleScope scope; - if (args.This()->InternalFieldCount() == 0) { + if (info.This()->InternalFieldCount() == 0) { JSTHROW_TYPE("Cannot Instantiate without new") } NamedWindow* win; - 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()); } NamedWindow::NamedWindow(const std::string& name, int f) { @@ -47,38 +47,38 @@ NamedWindow::NamedWindow(const std::string& name, int f) { NAN_METHOD(NamedWindow::Show) { SETUP_FUNCTION(NamedWindow) - Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *im = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); try { cv::imshow(self->winname, im->mat); } catch (cv::Exception& e) { const char* err_msg = e.what(); - NanThrowError(err_msg); + Nan::ThrowError(err_msg); } - NanReturnValue(args.Holder()); + info.GetReturnValue().Set(info.Holder()); } NAN_METHOD(NamedWindow::Destroy) { SETUP_FUNCTION(NamedWindow) cv::destroyWindow(self->winname); - NanReturnValue(args.Holder()); + info.GetReturnValue().Set(info.Holder()); } NAN_METHOD(NamedWindow::BlockingWaitKey) { - NanScope(); + Nan::HandleScope scope; //SETUP_FUNCTION(NamedWindow) int time = 0; - if (args.Length() > 1) { - time = args[1]->IntegerValue(); + if (info.Length() > 1) { + time = info[1]->IntegerValue(); } else { - if (args.Length() > 0) { - time = args[0]->IntegerValue(); + if (info.Length() > 0) { + time = info[0]->IntegerValue(); } } int res = cv::waitKey(time); - NanReturnValue(NanNew(res)); + info.GetReturnValue().Set(Nan::New(res)); } diff --git a/src/HighGUI.h b/src/HighGUI.h index e88254b..9b7019a 100644 --- a/src/HighGUI.h +++ b/src/HighGUI.h @@ -1,11 +1,11 @@ #include "OpenCV.h" -class NamedWindow: public node::ObjectWrap { +class NamedWindow: public Nan::ObjectWrap { public: std::string winname; int flags; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/ImgProc.cc b/src/ImgProc.cc index 20f32c8..b84e20a 100644 --- a/src/ImgProc.cc +++ b/src/ImgProc.cc @@ -2,34 +2,34 @@ #include "Matrix.h" void ImgProc::Init(Handle target) { - Persistent inner; - Local obj = NanNew(); - NanAssignPersistent(inner, obj); + Nan::Persistent inner; + Local obj = Nan::New(); + 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); } // cv::undistort NAN_METHOD(ImgProc::Undistort) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat inputImage = m0->mat; // Arg 1 is the camera matrix - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat K = m1->mat; // Arg 2 is the distortion coefficents - Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::Mat dist = m2->mat; // Make an mat to hold the result image @@ -39,51 +39,51 @@ NAN_METHOD(ImgProc::Undistort) { cv::undistort(inputImage, outputImage, K, dist); // Wrap the output image - Local outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *outMatrix = ObjectWrap::Unwrap(outMatrixWrap); + Local outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *outMatrix = Nan::ObjectWrap::Unwrap(outMatrixWrap); outMatrix->mat = outputImage; // Return the output image - NanReturnValue(outMatrixWrap); + info.GetReturnValue().Set(outMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::initUndistortRectifyMap NAN_METHOD(ImgProc::InitUndistortRectifyMap) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Arg 0 is the camera matrix - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat K = m0->mat; // Arg 1 is the distortion coefficents - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat dist = m1->mat; // Arg 2 is the recification transformation - Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::Mat R = m2->mat; // Arg 3 is the new camera matrix - Matrix* m3 = ObjectWrap::Unwrap(args[3]->ToObject()); + Matrix* m3 = Nan::ObjectWrap::Unwrap(info[3]->ToObject()); cv::Mat newK = m3->mat; // Arg 4 is the image size cv::Size imageSize; - if (args[4]->IsArray()) { - Local v8sz = args[4]->ToObject(); + if (info[4]->IsArray()) { + Local v8sz = info[4]->ToObject(); imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); } else { JSTHROW_TYPE("Must pass image size"); } // Arg 5 is the first map type, skip for now - int m1type = args[5]->IntegerValue(); + int m1type = info[5]->IntegerValue(); // Make matrices to hold the output maps cv::Mat map1, map2; @@ -92,49 +92,49 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) { cv::initUndistortRectifyMap(K, dist, R, newK, imageSize, m1type, map1, map2); // Wrap the output maps - Local map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *map1Matrix = ObjectWrap::Unwrap(map1Wrap); + Local map1Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *map1Matrix = Nan::ObjectWrap::Unwrap(map1Wrap); map1Matrix->mat = map1; - Local map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *map2Matrix = ObjectWrap::Unwrap(map2Wrap); + Local map2Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *map2Matrix = Nan::ObjectWrap::Unwrap(map2Wrap); map2Matrix->mat = map2; // Make a return object with the two maps - Local ret = NanNew(); - ret->Set(NanNew("map1"), map1Wrap); - ret->Set(NanNew("map2"), map2Wrap); + Local ret = Nan::New(); + ret->Set(Nan::New("map1").ToLocalChecked(), map1Wrap); + ret->Set(Nan::New("map2").ToLocalChecked(), map2Wrap); // Return the maps - NanReturnValue(ret); + info.GetReturnValue().Set(ret); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // cv::remap NAN_METHOD(ImgProc::Remap) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; try { // Get the arguments // Arg 0 is the image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat inputImage = m0->mat; // Arg 1 is the first map - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat map1 = m1->mat; // Arg 2 is the second map - Matrix* m2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix* m2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::Mat map2 = m2->mat; // Arg 3 is the interpolation mode - int interpolation = args[3]->IntegerValue(); + int interpolation = info[3]->IntegerValue(); // Args 4, 5 border settings, skipping for now @@ -145,15 +145,15 @@ NAN_METHOD(ImgProc::Remap) { cv::remap(inputImage, outputImage, map1, map2, interpolation); // Wrap the output image - Local outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *outMatrix = ObjectWrap::Unwrap(outMatrixWrap); + Local outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *outMatrix = Nan::ObjectWrap::Unwrap(outMatrixWrap); outMatrix->mat = outputImage; // Return the image - NanReturnValue(outMatrixWrap); + info.GetReturnValue().Set(outMatrixWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/ImgProc.h b/src/ImgProc.h index 8f7c504..a73220a 100644 --- a/src/ImgProc.h +++ b/src/ImgProc.h @@ -6,7 +6,7 @@ /** * Implementation of imgproc.hpp functions */ -class ImgProc: public node::ObjectWrap { +class ImgProc: public Nan::ObjectWrap { public: static void Init(Handle target); static NAN_METHOD(Undistort); diff --git a/src/Matrix.cc b/src/Matrix.cc index 3fec65b..0be152a 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -3,156 +3,156 @@ #include "OpenCV.h" #include -v8::Persistent Matrix::constructor; +Nan::Persistent Matrix::constructor; cv::Scalar setColor(Local objColor); cv::Point setPoint(Local objPoint); cv::Rect* setRect(Local objRect, cv::Rect &result); void Matrix::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; //Class - Local ctor = NanNew(Matrix::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(Matrix::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("Matrix")); + ctor->SetClassName(Nan::New("Matrix").ToLocalChecked()); // Prototype - 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()); }; NAN_METHOD(Matrix::New) { - 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"); } Matrix *mat; - if (args.Length() == 0) { + if (info.Length() == 0) { mat = new Matrix; - } 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(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(info[0]->ToObject()); + int x = info[1]->IntegerValue(); + int y = info[2]->IntegerValue(); + int w = info[3]->IntegerValue(); + int h = info[4]->IntegerValue(); mat = new Matrix(other->mat, cv::Rect(x, y, w, h)); } - mat->Wrap(args.Holder()); - NanReturnValue(args.Holder()); + mat->Wrap(info.Holder()); + info.GetReturnValue().Set(info.Holder()); } Matrix::Matrix() : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(); } Matrix::Matrix(int rows, int cols) : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(rows, cols, CV_32FC3); } Matrix::Matrix(int rows, int cols, int type) : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(rows, cols, type); } Matrix::Matrix(cv::Mat m, cv::Rect roi) : - ObjectWrap() { + Nan::ObjectWrap() { mat = cv::Mat(m, roi); } @@ -168,13 +168,13 @@ Matrix::Matrix(int rows, int cols, int type, Local scalarObj) { } else if (mat.channels() == 1) { mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue())); } else { - NanThrowError("Only 1-3 channels are supported"); + Nan::ThrowError("Only 1-3 channels are supported"); } } NAN_METHOD(Matrix::Empty) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.empty())); + info.GetReturnValue().Set(Nan::New(self->mat.empty())); } double Matrix::DblGet(cv::Mat mat, int i, int j) { @@ -205,13 +205,13 @@ double Matrix::DblGet(cv::Mat mat, int i, int j) { NAN_METHOD(Matrix::Pixel) { SETUP_FUNCTION(Matrix) - int y = args[0]->IntegerValue(); - int x = args[1]->IntegerValue(); + int y = info[0]->IntegerValue(); + int x = info[1]->IntegerValue(); // cv::Scalar scal = self->mat.at(y, x); - if (args.Length() == 3) { - Local < Object > objColor = args[2]->ToObject(); + if (info.Length() == 3) { + Local < Object > objColor = info[2]->ToObject(); if (self->mat.channels() == 3) { self->mat.at(y, x)[0] = @@ -223,48 +223,48 @@ NAN_METHOD(Matrix::Pixel) { } else if (self->mat.channels() == 1) self->mat.at(y, x) = (uchar) objColor->Get(0)->IntegerValue(); - NanReturnValue(args[2]->ToObject()); + info.GetReturnValue().Set(info[2]->ToObject()); } else { if (self->mat.channels() == 3) { cv::Vec3b intensity = self->mat.at(y, x); - v8::Local < v8::Array > arr = NanNew(3); - arr->Set(0, NanNew(intensity[0])); - arr->Set(1, NanNew(intensity[1])); - arr->Set(2, NanNew(intensity[2])); - NanReturnValue(arr); + v8::Local < v8::Array > arr = Nan::New(3); + arr->Set(0, Nan::New(intensity[0])); + arr->Set(1, Nan::New(intensity[1])); + arr->Set(2, Nan::New(intensity[2])); + info.GetReturnValue().Set(arr); } else if (self->mat.channels() == 1) { uchar intensity = self->mat.at(y, x); - NanReturnValue(NanNew(intensity)); + info.GetReturnValue().Set(Nan::New(intensity)); } } - NanReturnUndefined(); + return; // double val = Matrix::DblGet(t, i, j); - // NanReturnValue(NanNew(val)); + // info.GetReturnValue().Set(Nan::New(val)); } NAN_METHOD(Matrix::Get) { SETUP_FUNCTION(Matrix) - int i = args[0]->IntegerValue(); - int j = args[1]->IntegerValue(); + int i = info[0]->IntegerValue(); + int j = info[1]->IntegerValue(); double val = Matrix::DblGet(self->mat, i, j); - NanReturnValue(NanNew(val)); + info.GetReturnValue().Set(Nan::New(val)); } NAN_METHOD(Matrix::Set) { SETUP_FUNCTION(Matrix) - 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(); int vint = 0; - if (args.Length() == 4) { - self->mat.at(i, j)[args[3]->NumberValue()] = val; - } else if (args.Length() == 3) { + if (info.Length() == 4) { + self->mat.at(i, j)[info[3]->NumberValue()] = val; + } else if (info.Length() == 3) { switch (self->mat.type()) { case CV_32FC3: vint = static_cast(val + 0.5); @@ -278,10 +278,10 @@ NAN_METHOD(Matrix::Set) { } } else { - NanThrowTypeError("Invalid number of arguments"); + Nan::ThrowTypeError("Invalid number of arguments"); } - NanReturnUndefined(); + return; } // @author tualo @@ -290,39 +290,39 @@ NAN_METHOD(Matrix::Set) { NAN_METHOD(Matrix::Put) { SETUP_FUNCTION(Matrix) - 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]); memcpy(self->mat.data, buffer_data, buffer_length); - NanReturnUndefined(); + return; } // @author tualo // getData getting node buffer of image data NAN_METHOD(Matrix::GetData) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); int size = self->mat.rows * self->mat.cols * self->mat.elemSize1(); - Local buf = NanNewBufferHandle(size); + Local buf = Nan::NewBuffer(size).ToLocalChecked(); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, self->mat.data, size); - v8::Local globalObj = NanGetCurrentContext()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); - v8::Handle constructorArgs[3] = {buf, NanNew((unsigned) size), NanNew(0)}; + v8::Local globalObj = Nan::GetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); + v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned) size), Nan::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - NanReturnValue(actualBuffer); + info.GetReturnValue().Set(actualBuffer); } NAN_METHOD(Matrix::Brightness) { - NanScope(); - Matrix *self = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - if (args.Length() == 2) { + if (info.Length() == 2) { cv::Mat image; if (self->mat.channels() == 3) { @@ -331,12 +331,12 @@ NAN_METHOD(Matrix::Brightness) { cv::Mat myimg = self->mat; cv::cvtColor(myimg, image, CV_GRAY2RGB); } else { - NanThrowError("those channels are not supported"); + Nan::ThrowError("those channels are not supported"); } cv::Mat new_image = cv::Mat::zeros( image.size(), image.type() ); - double alpha = args[0]->NumberValue(); - int beta = args[1]->IntegerValue(); + double alpha = info[0]->NumberValue(); + int beta = info[1]->IntegerValue(); // Do the operation new_image(i,j) = alpha*image(i,j) + beta for (int y = 0; y < image.rows; y++ ) { @@ -356,56 +356,56 @@ NAN_METHOD(Matrix::Brightness) { gray.copyTo(self->mat); } } else { - if (args.Length() == 1) { - int diff = args[0]->IntegerValue(); + if (info.Length() == 1) { + int diff = info[0]->IntegerValue(); cv::Mat img = self->mat + diff; img.copyTo(self->mat); } else { - NanReturnValue(NanNew("Insufficient or wrong arguments")); + info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked()); } } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } // @author tualo // normalize wrapper NAN_METHOD(Matrix::Normalize) { - 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)"); } int type = cv::NORM_MINMAX; - if (args[2]->IsNumber()) { - type = args[2]->Uint32Value(); + if (info[2]->IsNumber()) { + type = info[2]->Uint32Value(); if ((type != cv::NORM_MINMAX) || (type != cv::NORM_INF) || (type != cv::NORM_L1) || (type != cv::NORM_L2) || (type != cv::NORM_L2SQR) || (type != cv::NORM_HAMMING) || (type != cv::NORM_HAMMING2) || (type != cv::NORM_RELATIVE) || (type != cv::NORM_TYPE_MASK)) { - 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," " NORM_L2SQR=5, NORM_HAMMING=6, NORM_HAMMING2=7, NORM_TYPE_MASK=7, " "NORM_RELATIVE=8, NORM_MINMAX=32 "); } } int dtype = -1; - 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(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); cv::Mat norm; cv::Mat mask; - if (args[4]->IsObject()) { - Matrix *mmask = ObjectWrap::Unwrap(args[4]->ToObject()); + if (info[4]->IsObject()) { + Matrix *mmask = Nan::ObjectWrap::Unwrap(info[4]->ToObject()); mask = mmask->mat; } @@ -413,52 +413,52 @@ NAN_METHOD(Matrix::Normalize) { norm.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Size) { SETUP_FUNCTION(Matrix) - v8::Local < v8::Array > arr = NanNew(2); - arr->Set(0, NanNew(self->mat.size().height)); - arr->Set(1, NanNew(self->mat.size().width)); + v8::Local < v8::Array > arr = Nan::New(2); + arr->Set(0, Nan::New(self->mat.size().height)); + arr->Set(1, Nan::New(self->mat.size().width)); - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Clone) { SETUP_FUNCTION(Matrix) Local < Object > im_h = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m = ObjectWrap::Unwrap(im_h); + Matrix *m = Nan::ObjectWrap::Unwrap(im_h); m->mat = self->mat.clone(); - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::Crop) { SETUP_FUNCTION(Matrix) - 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(); cv::Rect roi(x, y, width, height); Local < Object > im_h = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m = ObjectWrap::Unwrap(im_h); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m = Nan::ObjectWrap::Unwrap(im_h); m->mat = self->mat(roi); - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } else { - NanReturnValue(NanNew("Insufficient or wrong arguments")); + info.GetReturnValue().Set(Nan::New("Insufficient or wrong arguments").ToLocalChecked()); } } @@ -466,89 +466,89 @@ NAN_METHOD(Matrix::Row) { SETUP_FUNCTION(Matrix) int width = self->mat.size().width; - int y = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(width); + int y = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(width); for (int x = 0; x < width; x++) { double v = Matrix::DblGet(self->mat, y, x); - arr->Set(x, NanNew(v)); + arr->Set(x, Nan::New(v)); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::PixelRow) { SETUP_FUNCTION(Matrix) int width = self->mat.size().width; - int y = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(width * 3); + int y = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(width * 3); for (int x = 0; x < width; x++) { cv::Vec3b pixel = self->mat.at(y, x); int offset = x * 3; - arr->Set(offset, NanNew((double) pixel.val[0])); - arr->Set(offset + 1, NanNew((double) pixel.val[1])); - arr->Set(offset + 2, NanNew((double) pixel.val[2])); + arr->Set(offset, Nan::New((double) pixel.val[0])); + arr->Set(offset + 1, Nan::New((double) pixel.val[1])); + arr->Set(offset + 2, Nan::New((double) pixel.val[2])); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Col) { SETUP_FUNCTION(Matrix) int height = self->mat.size().height; - int x = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(height); + int x = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(height); for (int y = 0; y < height; y++) { double v = Matrix::DblGet(self->mat, y, x); - arr->Set(y, NanNew(v)); + arr->Set(y, Nan::New(v)); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::PixelCol) { SETUP_FUNCTION(Matrix) int height = self->mat.size().height; - int x = args[0]->IntegerValue(); - v8::Local < v8::Array > arr = NanNew(height * 3); + int x = info[0]->IntegerValue(); + v8::Local < v8::Array > arr = Nan::New(height * 3); for (int y = 0; y < height; y++) { cv::Vec3b pixel = self->mat.at(y, x); int offset = y * 3; - arr->Set(offset, NanNew((double) pixel.val[0])); - arr->Set(offset + 1, NanNew((double) pixel.val[1])); - arr->Set(offset + 2, NanNew((double) pixel.val[2])); + arr->Set(offset, Nan::New((double) pixel.val[0])); + arr->Set(offset + 1, Nan::New((double) pixel.val[1])); + arr->Set(offset + 2, Nan::New((double) pixel.val[2])); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Width) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.size().width)); + info.GetReturnValue().Set(Nan::New(self->mat.size().width)); } NAN_METHOD(Matrix::Height) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.size().height)); + info.GetReturnValue().Set(Nan::New(self->mat.size().height)); } NAN_METHOD(Matrix::Channels) { SETUP_FUNCTION(Matrix) - NanReturnValue(NanNew(self->mat.channels())); + info.GetReturnValue().Set(Nan::New(self->mat.channels())); } NAN_METHOD(Matrix::ToBuffer) { SETUP_FUNCTION(Matrix) - if ((args.Length() > 0) && (args[0]->IsFunction())) { - return Matrix::ToBufferAsync(args); + if ((info.Length() > 0) && (info[0]->IsFunction())) { + return Matrix::ToBufferAsync(info); } // SergeMv changes @@ -564,25 +564,25 @@ NAN_METHOD(Matrix::ToBuffer) { std::vector params; // See if the options argument is passed - if ((args.Length() > 0) && (args[0]->IsObject())) { + if ((info.Length() > 0) && (info[0]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(args[0]); + v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); // If the extension (image format) is provided - if (options->Has(NanNew("ext"))) { + if (options->Has(Nan::New("ext").ToLocalChecked())) { v8::String::Utf8Value str( - options->Get(NanNew("ext"))->ToString()); + options->Get(Nan::New("ext").ToLocalChecked())->ToString()); optExt = *str; ext = (const char *) optExt.c_str(); } - if (options->Has(NanNew("jpegQuality"))) { + if (options->Has(Nan::New("jpegQuality").ToLocalChecked())) { int compression = - options->Get(NanNew("jpegQuality"))->IntegerValue(); + options->Get(Nan::New("jpegQuality").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(NanNew("pngCompression"))) { + if (options->Has(Nan::New("pngCompression").ToLocalChecked())) { int compression = - options->Get(NanNew("pngCompression"))->IntegerValue(); + options->Get(Nan::New("pngCompression").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } @@ -593,26 +593,26 @@ NAN_METHOD(Matrix::ToBuffer) { cv::imencode(ext, self->mat, vec, params); - Local < Object > buf = NanNewBufferHandle(vec.size()); + Local < Object > buf = Nan::NewBuffer(vec.size()).ToLocalChecked(); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, &vec[0], vec.size()); - v8::Local < v8::Object > globalObj = NanGetCurrentContext()->Global(); + v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global(); v8::Local < v8::Function > bufferConstructor = v8::Local < v8::Function - > ::Cast(globalObj->Get(NanNew("Buffer"))); + > ::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); v8::Handle constructorArgs[3] = - {buf, NanNew((unsigned)vec.size()), NanNew(0)}; + {buf, Nan::New((unsigned)vec.size()), Nan::New(0)}; v8::Local < v8::Object > actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - NanReturnValue(actualBuffer); + info.GetReturnValue().Set(actualBuffer); } -class AsyncToBufferWorker: public NanAsyncWorker { +class AsyncToBufferWorker: public Nan::AsyncWorker { public: - AsyncToBufferWorker(NanCallback *callback, Matrix* matrix, string ext, + AsyncToBufferWorker(Nan::Callback *callback, Matrix* matrix, string ext, vector params) : - NanAsyncWorker(callback), + Nan::AsyncWorker(callback), matrix(matrix), ext(ext), params(params) { @@ -629,19 +629,19 @@ public: } void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; - Local buf = NanNewBufferHandle(res.size()); + Local buf = Nan::NewBuffer(res.size()).ToLocalChecked(); uchar* data = (uchar*) Buffer::Data(buf); memcpy(data, &res[0], res.size()); - v8::Local globalObj = NanGetCurrentContext()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); - v8::Handle constructorArgs[3] = {buf, NanNew((unsigned)res.size()), NanNew(0)}; + v8::Local globalObj = Nan::GetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); + v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned)res.size()), Nan::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); Local argv[] = { - NanNull(), + Nan::Null(), actualBuffer }; @@ -669,34 +669,34 @@ NAN_METHOD(Matrix::ToBufferAsync) { std::vector params; // See if the options argument is passed - if ((args.Length() > 1) && (args[1]->IsObject())) { + if ((info.Length() > 1) && (info[1]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(args[1]); + v8::Handle < v8::Object > options = v8::Handle::Cast(info[1]); // If the extension (image format) is provided - if (options->Has(NanNew("ext"))) { + if (options->Has(Nan::New("ext").ToLocalChecked())) { v8::String::Utf8Value str( - options->Get(NanNew("ext"))->ToString()); + options->Get(Nan::New("ext").ToLocalChecked())->ToString()); std::string str2 = std::string(*str); ext = str2; } - if (options->Has(NanNew("jpegQuality"))) { + if (options->Has(Nan::New("jpegQuality").ToLocalChecked())) { int compression = - options->Get(NanNew("jpegQuality"))->IntegerValue(); + options->Get(Nan::New("jpegQuality").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(NanNew("pngCompression"))) { + if (options->Has(Nan::New("pngCompression").ToLocalChecked())) { int compression = - options->Get(NanNew("pngCompression"))->IntegerValue(); + options->Get(Nan::New("pngCompression").ToLocalChecked())->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } } - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Ellipse) { @@ -714,73 +714,73 @@ NAN_METHOD(Matrix::Ellipse) { int lineType = 8; int shift = 0; - if (args[0]->IsObject()) { - v8::Handle < v8::Object > options = v8::Handle::Cast(args[0]); - if (options->Has(NanNew("center"))) { + if (info[0]->IsObject()) { + v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); + if (options->Has(Nan::New("center").ToLocalChecked())) { Local < Object > center = - options->Get(NanNew("center"))->ToObject(); - x = center->Get(NanNew("x"))->Uint32Value(); - y = center->Get(NanNew("y"))->Uint32Value(); + options->Get(Nan::New("center").ToLocalChecked())->ToObject(); + x = center->Get(Nan::New("x").ToLocalChecked())->Uint32Value(); + y = center->Get(Nan::New("y").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("axes"))) { - Local < Object > axes = options->Get(NanNew("axes"))->ToObject(); - width = axes->Get(NanNew("width"))->Uint32Value(); - height = axes->Get(NanNew("height"))->Uint32Value(); + if (options->Has(Nan::New("axes").ToLocalChecked())) { + Local < Object > axes = options->Get(Nan::New("axes").ToLocalChecked())->ToObject(); + width = axes->Get(Nan::New("width").ToLocalChecked())->Uint32Value(); + height = axes->Get(Nan::New("height").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("thickness"))) { - thickness = options->Get(NanNew("thickness"))->Uint32Value(); + if (options->Has(Nan::New("thickness").ToLocalChecked())) { + thickness = options->Get(Nan::New("thickness").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("angle"))) { - angle = options->Get(NanNew("angle"))->NumberValue(); + if (options->Has(Nan::New("angle").ToLocalChecked())) { + angle = options->Get(Nan::New("angle").ToLocalChecked())->NumberValue(); } - if (options->Has(NanNew("startAngle"))) { - startAngle = options->Get(NanNew("startAngle"))->NumberValue(); + if (options->Has(Nan::New("startAngle").ToLocalChecked())) { + startAngle = options->Get(Nan::New("startAngle").ToLocalChecked())->NumberValue(); } - if (options->Has(NanNew("endAngle"))) { - endAngle = options->Get(NanNew("endAngle"))->NumberValue(); + if (options->Has(Nan::New("endAngle").ToLocalChecked())) { + endAngle = options->Get(Nan::New("endAngle").ToLocalChecked())->NumberValue(); } - if (options->Has(NanNew("lineType"))) { - lineType = options->Get(NanNew("lineType"))->Uint32Value(); + if (options->Has(Nan::New("lineType").ToLocalChecked())) { + lineType = options->Get(Nan::New("lineType").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("shift"))) { - shift = options->Get(NanNew("shift"))->Uint32Value(); + if (options->Has(Nan::New("shift").ToLocalChecked())) { + shift = options->Get(Nan::New("shift").ToLocalChecked())->Uint32Value(); } - if (options->Has(NanNew("color"))) { + if (options->Has(Nan::New("color").ToLocalChecked())) { Local < Object > objColor = - options->Get(NanNew("color"))->ToObject(); + options->Get(Nan::New("color").ToLocalChecked())->ToObject(); color = setColor(objColor); } } else { - 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(); color = setColor(objColor); } - if (args[5]->IntegerValue()) - thickness = args[5]->IntegerValue(); + if (info[5]->IntegerValue()) + thickness = info[5]->IntegerValue(); } cv::ellipse(self->mat, cv::Point(x, y), cv::Size(width, height), angle, startAngle, endAngle, color, thickness, lineType, shift); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Rectangle) { SETUP_FUNCTION(Matrix) - 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(); cv::Scalar color(0, 0, 255); - if (args[2]->IsArray()) { - Local < Object > objColor = args[2]->ToObject(); + if (info[2]->IsArray()) { + Local < Object > objColor = info[2]->ToObject(); color = setColor(objColor); } @@ -792,27 +792,27 @@ NAN_METHOD(Matrix::Rectangle) { int thickness = 1; - if (args[3]->IntegerValue()) - thickness = args[3]->IntegerValue(); + if (info[3]->IntegerValue()) + thickness = info[3]->IntegerValue(); cv::rectangle(self->mat, cv::Point(x, y), cv::Point(x + width, y + height), color, thickness); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Line) { SETUP_FUNCTION(Matrix) - 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(); cv::Scalar color(0, 0, 255); - if (args[2]->IsArray()) { - Local < Object > objColor = args[2]->ToObject(); + if (info[2]->IsArray()) { + Local < Object > objColor = info[2]->ToObject(); color = setColor(objColor); } @@ -824,20 +824,20 @@ NAN_METHOD(Matrix::Line) { int thickness = 1; - if (args[3]->IntegerValue()) - thickness = args[3]->IntegerValue(); + if (info[3]->IntegerValue()) + thickness = info[3]->IntegerValue(); cv::line(self->mat, cv::Point(x1, y1), cv::Point(x2, y2), color, thickness); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::FillPoly) { SETUP_FUNCTION(Matrix) - 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()); cv::Point **polygons = new cv::Point*[polyArray->Length()]; int *polySizes = new int[polyArray->Length()]; @@ -854,8 +854,8 @@ NAN_METHOD(Matrix::FillPoly) { } cv::Scalar color(0, 0, 255); - if (args[1]->IsArray()) { - Local objColor = args[1]->ToObject(); + if (info[1]->IsArray()) { + Local objColor = info[1]->ToObject(); color = setColor(objColor); } @@ -863,32 +863,32 @@ NAN_METHOD(Matrix::FillPoly) { polyArray->Length(), color); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Save) { SETUP_FUNCTION(Matrix) - 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]); int res = cv::imwrite(*filename, self->mat); - NanReturnValue(NanNew(res)); + info.GetReturnValue().Set(Nan::New(res)); } // All this is for async save, see here for nan example: // https://github.com/rvagg/nan/blob/c579ae858ae3208d7e702e8400042ba9d48fa64b/examples/async_pi_estimate/async.cc -class AsyncSaveWorker: public NanAsyncWorker { +class AsyncSaveWorker: public Nan::AsyncWorker { public: - AsyncSaveWorker(NanCallback *callback, Matrix* matrix, char* filename) : - NanAsyncWorker(callback), + AsyncSaveWorker(Nan::Callback *callback, Matrix* matrix, char* filename) : + Nan::AsyncWorker(callback), matrix(matrix), filename(filename) { } @@ -908,11 +908,11 @@ public: // this function will be run inside the main event loop // so it is safe to use V8 again void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; Local argv[] = { - NanNull(), - NanNew(res) + Nan::Null(), + Nan::New(res) }; TryCatch try_catch; @@ -931,71 +931,71 @@ private: NAN_METHOD(Matrix::SaveAsync) { SETUP_FUNCTION(Matrix) - if (!args[0]->IsString()) { - NanThrowTypeError("filename required"); + if (!info[0]->IsString()) { + Nan::ThrowTypeError("filename required"); } - NanAsciiString filename(args[0]); + Nan::Utf8String filename(info[0]); REQ_FUN_ARG(1, cb); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Zeros) { - 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 im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::zeros(w, h, type); img->mat = mat; - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::Ones) { - 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 im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::ones(w, h, type); img->mat = mat; - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::Eye) { - 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 im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::eye(w, h, type); img->mat = mat; - NanReturnValue(im_h); + info.GetReturnValue().Set(im_h); } NAN_METHOD(Matrix::ConvertGrayscale) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); if (self->mat.channels() != 3) { - NanThrowError("Image is no 3-channel"); + Nan::ThrowError("Image is no 3-channel"); } cv::Mat gray; @@ -1003,15 +1003,15 @@ NAN_METHOD(Matrix::ConvertGrayscale) { cv::cvtColor(self->mat, gray, CV_BGR2GRAY); gray.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::ConvertHSVscale) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); if (self->mat.channels() != 3) { - NanThrowError("Image is no 3-channel"); + Nan::ThrowError("Image is no 3-channel"); } cv::Mat hsv; @@ -1019,29 +1019,29 @@ NAN_METHOD(Matrix::ConvertHSVscale) { cv::cvtColor(self->mat, hsv, CV_BGR2HSV); hsv.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::GaussianBlur) { - NanScope(); + Nan::HandleScope scope; cv::Size ksize; cv::Mat blurred; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - if (args.Length() < 1) { + if (info.Length() < 1) { ksize = cv::Size(5, 5); } else { - 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 array = args[0]->ToObject(); + Local array = info[0]->ToObject(); // TODO: Length check Local x = array->Get(0); Local y = array->Get(1); if (!x->IsNumber() || !y->IsNumber()) { - NanThrowTypeError("'ksize' argument must be a 2 double array"); + Nan::ThrowTypeError("'ksize' argument must be a 2 double array"); } ksize = cv::Size(x->NumberValue(), y->NumberValue()); } @@ -1049,49 +1049,49 @@ NAN_METHOD(Matrix::GaussianBlur) { cv::GaussianBlur(self->mat, blurred, ksize, 0); blurred.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::MedianBlur) { - NanScope(); + Nan::HandleScope scope; cv::Mat blurred; int ksize = 3; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - if (args[0]->IsNumber()) { - ksize = args[0]->IntegerValue(); + if (info[0]->IsNumber()) { + ksize = info[0]->IntegerValue(); if ((ksize % 2) == 0) { - NanThrowTypeError("'ksize' argument must be a positive odd integer"); + Nan::ThrowTypeError("'ksize' argument must be a positive odd integer"); } } else { - NanThrowTypeError("'ksize' argument must be a positive odd integer"); + Nan::ThrowTypeError("'ksize' argument must be a positive odd integer"); } cv::medianBlur(self->mat, blurred, ksize); blurred.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BilateralFilter) { - NanScope(); + Nan::HandleScope scope; cv::Mat filtered; int d = 15; double sigmaColor = 80; double sigmaSpace = 80; int borderType = cv::BORDER_DEFAULT; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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"); } else { - 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(); } } } @@ -1099,276 +1099,276 @@ NAN_METHOD(Matrix::BilateralFilter) { cv::bilateralFilter(self->mat, filtered, d, sigmaColor, sigmaSpace, borderType); filtered.copyTo(self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Copy) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); Local img_to_return = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::Flip) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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 " "(0 = X axis, positive = Y axis, negative = both axis)"); } - int flipCode = args[0]->ToInt32()->Value(); + int flipCode = info[0]->ToInt32()->Value(); - Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Local img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); cv::flip(self->mat, img->mat, flipCode); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::ROI) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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"); } // Although it's an image to return, it is in fact a pointer to ROI of parent matrix - Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Local img_to_return = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(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(); cv::Mat roi(self->mat, cv::Rect(x,y,w,h)); img->mat = roi; - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::Ptr) { - NanScope(); - Matrix *self = ObjectWrap::Unwrap(args.This()); - int line = args[0]->Uint32Value(); + Nan::HandleScope scope; + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int line = info[0]->Uint32Value(); char* data = self->mat.ptr(line); // uchar* data = self->mat.data; // char *mydata = "Random raw data\0"; - Local return_buffer = NanNewBufferHandle((char*)data, self->mat.step); - NanReturnValue( return_buffer ); -// NanReturnUndefined(); + Local return_buffer = Nan::NewBuffer((char*)data, self->mat.step).ToLocalChecked(); + info.GetReturnValue().Set( return_buffer ); +// return; } NAN_METHOD(Matrix::AbsDiff) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::absdiff(src1->mat, src2->mat, self->mat); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::AddWeighted) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); - float alpha = args[1]->NumberValue(); - float beta = args[3]->NumberValue(); + float alpha = info[1]->NumberValue(); + float beta = info[3]->NumberValue(); int gamma = 0; try { cv::addWeighted(src1->mat, alpha, src2->mat, beta, gamma, self->mat); } catch(cv::Exception& e ) { const char* err_msg = e.what(); - NanThrowError(err_msg); + Nan::ThrowError(err_msg); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BitwiseXor) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); - if (args.Length() == 3) { - Matrix *mask = ObjectWrap::Unwrap(args[2]->ToObject()); + if (info.Length() == 3) { + Matrix *mask = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::bitwise_xor(src1->mat, src2->mat, self->mat, mask->mat); } else { cv::bitwise_xor(src1->mat, src2->mat, self->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BitwiseNot) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *dst = ObjectWrap::Unwrap(args[0]->ToObject()); - if (args.Length() == 2) { - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *dst = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + if (info.Length() == 2) { + Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::bitwise_not(self->mat, dst->mat, mask->mat); } else { cv::bitwise_not(self->mat, dst->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::BitwiseAnd) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *src1 = ObjectWrap::Unwrap(args[0]->ToObject()); - Matrix *src2 = ObjectWrap::Unwrap(args[1]->ToObject()); - if (args.Length() == 3) { - Matrix *mask = ObjectWrap::Unwrap(args[2]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *src1 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + Matrix *src2 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); + if (info.Length() == 3) { + Matrix *mask = Nan::ObjectWrap::Unwrap(info[2]->ToObject()); cv::bitwise_and(src1->mat, src2->mat, self->mat, mask->mat); } else { cv::bitwise_and(src1->mat, src2->mat, self->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::CountNonZero) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); double count = (double)cv::countNonZero(self->mat); - NanReturnValue(NanNew(count)); + info.GetReturnValue().Set(Nan::New(count)); } /* NAN_METHOD(Matrix::Split) { - NanScope(); + Nan::HandleScope scope; - //Matrix *self = ObjectWrap::Unwrap(args.This()); + //Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } */ NAN_METHOD(Matrix::Canny) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - int lowThresh = args[0]->NumberValue(); - int highThresh = args[1]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int lowThresh = info[0]->NumberValue(); + int highThresh = info[1]->NumberValue(); cv::Canny(self->mat, self->mat, lowThresh, highThresh); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Dilate) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - int niters = args[0]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int niters = info[0]->NumberValue(); cv::dilate(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::Erode) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - int niters = args[0]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + int niters = info[0]->NumberValue(); cv::erode(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::FindContours) { - NanScope(); + Nan::HandleScope scope; int mode = CV_RETR_LIST; int chain = CV_CHAIN_APPROX_SIMPLE; - 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(args.This()); - Local conts_to_return= NanNew(Contour::constructor)->GetFunction()->NewInstance(); - Contour *contours = ObjectWrap::Unwrap(conts_to_return); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Local conts_to_return= Nan::New(Contour::constructor)->GetFunction()->NewInstance(); + Contour *contours = Nan::ObjectWrap::Unwrap(conts_to_return); cv::findContours(self->mat, contours->contours, contours->hierarchy, mode, chain); - NanReturnValue(conts_to_return); + info.GetReturnValue().Set(conts_to_return); } NAN_METHOD(Matrix::DrawContour) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); - int pos = args[1]->NumberValue(); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *cont = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); + int pos = info[1]->NumberValue(); cv::Scalar color(0, 0, 255); - if (args[2]->IsArray()) { - Local objColor = args[2]->ToObject(); + if (info[2]->IsArray()) { + Local objColor = info[2]->ToObject(); color = setColor(objColor); } - int thickness = args.Length() < 4 ? 1 : args[3]->NumberValue(); + int thickness = info.Length() < 4 ? 1 : info[3]->NumberValue(); cv::drawContours(self->mat, cont->contours, pos, color, thickness); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::DrawAllContours) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Contour *cont = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Scalar color(0, 0, 255); - if (args[1]->IsArray()) { - Local objColor = args[1]->ToObject(); + if (info[1]->IsArray()) { + Local objColor = info[1]->ToObject(); color = setColor(objColor); } - int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue(); + int thickness = info.Length() < 3 ? 1 : info[2]->NumberValue(); cv::drawContours(self->mat, cont->contours, -1, color, thickness); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::GoodFeaturesToTrack) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); std::vector corners; cv::Mat gray; @@ -1376,27 +1376,27 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) { equalizeHist(gray, gray); cv::goodFeaturesToTrack(gray, corners, 500, 0.01, 10); - v8::Local arr = NanNew(corners.size()); + v8::Local arr = Nan::New(corners.size()); for (unsigned int i=0; i pt = NanNew(2); - pt->Set(0, NanNew((double) corners[i].x)); - pt->Set(1, NanNew((double) corners[i].y)); + v8::Local pt = Nan::New(2); + pt->Set(0, Nan::New((double) corners[i].x)); + pt->Set(1, Nan::New((double) corners[i].y)); arr->Set(i, pt); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::HoughLinesP) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(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(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(); std::vector lines; cv::Mat gray; @@ -1405,31 +1405,31 @@ NAN_METHOD(Matrix::HoughLinesP) { // cv::Canny(gray, gray, 50, 200, 3); cv::HoughLinesP(gray, lines, rho, theta, threshold, minLineLength, maxLineGap); - v8::Local arr = NanNew(lines.size()); + v8::Local arr = Nan::New(lines.size()); for (unsigned int i=0; i pt = NanNew(4); - pt->Set(0, NanNew((double) lines[i][0])); - pt->Set(1, NanNew((double) lines[i][1])); - pt->Set(2, NanNew((double) lines[i][2])); - pt->Set(3, NanNew((double) lines[i][3])); + v8::Local pt = Nan::New(4); + pt->Set(0, Nan::New((double) lines[i][0])); + pt->Set(1, Nan::New((double) lines[i][1])); + pt->Set(2, Nan::New((double) lines[i][2])); + pt->Set(3, Nan::New((double) lines[i][3])); arr->Set(i, pt); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::HoughCircles) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(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(); std::vector circles; cv::Mat gray; @@ -1439,17 +1439,17 @@ NAN_METHOD(Matrix::HoughCircles) { cv::HoughCircles(gray, circles, CV_HOUGH_GRADIENT, dp, minDist, higherThreshold, accumulatorThreshold, minRadius, maxRadius); - v8::Local arr = NanNew(circles.size()); + v8::Local arr = Nan::New(circles.size()); for (unsigned int i=0; i < circles.size(); i++) { - v8::Local pt = NanNew(3); - pt->Set(0, NanNew((double) circles[i][0])); // center x - pt->Set(1, NanNew((double) circles[i][1]));// center y - pt->Set(2, NanNew((double) circles[i][2]));// radius + v8::Local pt = Nan::New(3); + pt->Set(0, Nan::New((double) circles[i][0])); // center x + pt->Set(1, Nan::New((double) circles[i][1]));// center y + pt->Set(2, Nan::New((double) circles[i][2]));// radius arr->Set(i, pt); } - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } cv::Scalar setColor(Local objColor) { @@ -1486,10 +1486,10 @@ cv::Rect* setRect(Local objRect, cv::Rect &result) { } NAN_METHOD(Matrix::Resize) { - NanScope(); + Nan::HandleScope scope; - int x = args[0]->Uint32Value(); - int y = args[1]->Uint32Value(); + int x = info[0]->Uint32Value(); + int y = info[1]->Uint32Value(); /* CV_INTER_NN =0, CV_INTER_LINEAR =1, @@ -1497,35 +1497,35 @@ NAN_METHOD(Matrix::Resize) { CV_INTER_AREA =3, CV_INTER_LANCZOS4 =4 */ - 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(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); cv::Mat res = cv::Mat(x, y, CV_32FC3); cv::resize(self->mat, res, cv::Size(x, y), 0, 0, interpolation); ~self->mat; self->mat = res; - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Rotate) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); cv::Mat rotMatrix(2, 3, CV_32FC1); cv::Mat res; - float angle = args[0]->ToNumber()->Value(); + float angle = info[0]->ToNumber()->Value(); // Modification by SergeMv //------------- // If you provide only the angle argument and the angle is multiple of 90, then // we do a fast thing bool rightOrStraight = (ceil(angle) == angle) && (!((int)angle % 90)) - && (args.Length() == 1); + && (info.Length() == 1); if (rightOrStraight) { int angle2 = ((int)angle) % 360; - if (!angle2) {NanReturnUndefined();} + if (!angle2) {return;} if (angle2 < 0) {angle2 += 360;} // See if we do right angle rotation, we transpose the matrix: if (angle2 % 180) { @@ -1540,14 +1540,14 @@ NAN_METHOD(Matrix::Rotate) { // If clockwise, flip around the y-axis if (angle2 == 270) {mode = 1;} cv::flip(self->mat, self->mat, mode); - 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(); cv::Point center = cv::Point(x,y); rotMatrix = getRotationMatrix2D(center, angle, 1.0); @@ -1556,33 +1556,33 @@ NAN_METHOD(Matrix::Rotate) { ~self->mat; self->mat = res; - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::PyrDown) { SETUP_FUNCTION(Matrix) cv::pyrDown(self->mat, self->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::PyrUp) { SETUP_FUNCTION(Matrix) cv::pyrUp(self->mat, self->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::inRange) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); /*if (self->mat.channels() != 3) - 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 args_lowerb = args[0]->ToObject(); - Local args_upperb = args[1]->ToObject(); + if (info[0]->IsArray() && info[1]->IsArray()) { + Local args_lowerb = info[0]->ToObject(); + Local args_upperb = info[1]->ToObject(); cv::Scalar lowerb(0, 0, 0); cv::Scalar upperb(0, 0, 0); @@ -1595,19 +1595,19 @@ NAN_METHOD(Matrix::inRange) { mask.copyTo(self->mat); } - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::AdjustROI) { SETUP_FUNCTION(Matrix) - 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(); self->mat.adjustROI(dtop, dbottom, dleft, dright); - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::LocateROI) { @@ -1618,25 +1618,25 @@ NAN_METHOD(Matrix::LocateROI) { self->mat.locateROI(wholeSize, ofs); - v8::Local < v8::Array > arr = NanNew(4); - arr->Set(0, NanNew(wholeSize.width)); - arr->Set(1, NanNew(wholeSize.height)); - arr->Set(2, NanNew(ofs.x)); - arr->Set(3, NanNew(ofs.y)); + v8::Local < v8::Array > arr = Nan::New(4); + arr->Set(0, Nan::New(wholeSize.width)); + arr->Set(1, Nan::New(wholeSize.height)); + arr->Set(2, Nan::New(ofs.x)); + arr->Set(3, Nan::New(ofs.y)); - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Threshold) { SETUP_FUNCTION(Matrix) - double threshold = args[0]->NumberValue(); - double maxVal = args[1]->NumberValue(); + double threshold = info[0]->NumberValue(); + double maxVal = info[1]->NumberValue(); int typ = cv::THRESH_BINARY; - 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]); if (strcmp(*typstr, "Binary") == 0) { typ = 0; } @@ -1655,52 +1655,52 @@ NAN_METHOD(Matrix::Threshold) { } Local < Object > img_to_return = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); cv::threshold(self->mat, img->mat, threshold, maxVal, typ); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::AdaptiveThreshold) { SETUP_FUNCTION(Matrix) - 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(); Local < Object > img_to_return = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C); - NanReturnValue(img_to_return); + info.GetReturnValue().Set(img_to_return); } NAN_METHOD(Matrix::MeanStdDev) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - Local mean = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_mean = ObjectWrap::Unwrap(mean); - Local stddev = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_stddev = ObjectWrap::Unwrap(stddev); + Local mean = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_mean = Nan::ObjectWrap::Unwrap(mean); + Local stddev = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_stddev = Nan::ObjectWrap::Unwrap(stddev); cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat); - Local data = NanNew(); - data->Set(NanNew("mean"), mean); - data->Set(NanNew("stddev"), stddev); + Local data = Nan::New(); + data->Set(Nan::New("mean").ToLocalChecked(), mean); + data->Set(Nan::New("stddev").ToLocalChecked(), stddev); - NanReturnValue(data); + info.GetReturnValue().Set(data); } // @author SergeMv @@ -1713,34 +1713,34 @@ NAN_METHOD(Matrix::MeanStdDev) { // our.width + x <= destination.width (and the same for y and height) // both x and y must be >= 0 NAN_METHOD(Matrix::CopyTo) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); int width = self->mat.size().width; int height = self->mat.size().height; // param 0 - destination image: - Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *dest = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); // param 1 - x coord of the destination - int x = args[1]->IntegerValue(); + int x = info[1]->IntegerValue(); // param 2 - y coord of the destination - int y = args[2]->IntegerValue(); + int y = info[2]->IntegerValue(); cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height)); self->mat.copyTo(dstROI); - NanReturnUndefined(); + return; } // @author SergeMv // Does in-place color transformation // img.cvtColor('CV_BGR2YCrCb'); NAN_METHOD(Matrix::CvtColor) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); - v8::String::Utf8Value str (args[0]->ToString()); + v8::String::Utf8Value str (info[0]->ToString()); std::string str2 = std::string(*str); const char * sTransform = (const char *) str2.c_str(); int iTransform; @@ -1772,20 +1772,20 @@ NAN_METHOD(Matrix::CvtColor) { else if (!strcmp(sTransform, "CV_BayerGR2BGR")) {iTransform = CV_BayerGR2BGR;} else { iTransform = 0; // to avoid compiler warning - NanThrowTypeError("Conversion code is unsupported"); + Nan::ThrowTypeError("Conversion code is unsupported"); } cv::cvtColor(self->mat, self->mat, iTransform); - NanReturnUndefined(); + return; } // @author SergeMv // arrChannels = img.split(); NAN_METHOD(Matrix::Split) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); unsigned int size = self->mat.channels(); vector channels; @@ -1797,55 +1797,55 @@ NAN_METHOD(Matrix::Split) { cv::split(self->mat, channels); size = channels.size(); - v8::Local arrChannels = NanNew(size); + v8::Local arrChannels = Nan::New(size); for (unsigned int i = 0; i < size; i++) { Local matObject = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix * m = ObjectWrap::Unwrap(matObject); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix * m = Nan::ObjectWrap::Unwrap(matObject); m->mat = channels[i]; arrChannels->Set(i, matObject); } - NanReturnValue(arrChannels); + info.GetReturnValue().Set(arrChannels); } // @author SergeMv // img.merge(arrChannels); NAN_METHOD(Matrix::Merge) { - NanScope(); + Nan::HandleScope scope; - Matrix * self = ObjectWrap::Unwrap(args.This()); - if (!args[0]->IsArray()) { - NanThrowTypeError("The argument must be an array"); + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); + if (!info[0]->IsArray()) { + Nan::ThrowTypeError("The argument must be an array"); } - v8::Handle jsChannels = v8::Handle::Cast(args[0]); + v8::Handle jsChannels = v8::Handle::Cast(info[0]); unsigned int L = jsChannels->Length(); vector vChannels(L); for (unsigned int i = 0; i < L; i++) { - Matrix * matObject = ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); + Matrix * matObject = Nan::ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); vChannels[i] = matObject->mat; } cv::merge(vChannels, self->mat); - NanReturnUndefined(); + return; } // @author SergeMv // Equalizes histogram // img.equalizeHist() NAN_METHOD(Matrix::EqualizeHist) { - NanScope(); - Matrix * self = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + Matrix * self = Nan::ObjectWrap::Unwrap(info.This()); cv::equalizeHist(self->mat, self->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::FloodFill) { SETUP_FUNCTION(Matrix) - // obj->Get(NanNew("x")) + // obj->Get(Nan::New("x").ToLocalChecked()) // int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int) /* mat.floodFill( {seedPoint: [1,1] , @@ -1855,22 +1855,22 @@ NAN_METHOD(Matrix::FloodFill) { upDiff:[10,100,70] }); */ - if (args.Length() < 1 || !args[0]->IsObject()) { + if (info.Length() < 1 || !info[0]->IsObject()) { // error } - Local < Object > obj = args[0]->ToObject(); + Local < Object > obj = info[0]->ToObject(); cv::Rect rect; int ret = cv::floodFill(self->mat, - setPoint(obj->Get(NanNew("seedPoint"))->ToObject()), - setColor(obj->Get(NanNew("newColor"))->ToObject()), - obj->Get(NanNew("rect"))->IsUndefined() ? - 0 : setRect(obj->Get(NanNew("rect"))->ToObject(), rect), - setColor(obj->Get(NanNew("loDiff"))->ToObject()), - setColor(obj->Get(NanNew("upDiff"))->ToObject()), 4); + setPoint(obj->Get(Nan::New("seedPoint").ToLocalChecked())->ToObject()), + setColor(obj->Get(Nan::New("newColor").ToLocalChecked())->ToObject()), + obj->Get(Nan::New("rect").ToLocalChecked())->IsUndefined() ? + 0 : setRect(obj->Get(Nan::New("rect").ToLocalChecked())->ToObject(), rect), + setColor(obj->Get(Nan::New("loDiff").ToLocalChecked())->ToObject()), + setColor(obj->Get(Nan::New("upDiff").ToLocalChecked())->ToObject()), 4); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } // @author olfox @@ -1880,15 +1880,15 @@ NAN_METHOD(Matrix::TemplateMatches) { SETUP_FUNCTION(Matrix) bool filter_min_probability = - (args.Length() >= 1) ? args[0]->IsNumber() : false; + (info.Length() >= 1) ? info[0]->IsNumber() : false; bool filter_max_probability = - (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; cv::Mat_ indices; @@ -1901,7 +1901,7 @@ NAN_METHOD(Matrix::TemplateMatches) { } cv::Mat hit_mask = cv::Mat::zeros(self->mat.size(), CV_64F); - v8::Local < v8::Array > probabilites_array = NanNew(limit); + v8::Local < v8::Array > probabilites_array = Nan::New(limit); cv::Mat_::const_iterator begin = self->mat.begin(); cv::Mat_::const_iterator it = indices.begin(); @@ -1955,37 +1955,37 @@ NAN_METHOD(Matrix::TemplateMatches) { cv::rectangle(hit_mask, top_left, bottom_right, color, CV_FILLED); } - Local x_value = NanNew(pt.x); - Local y_value = NanNew(pt.y); - Local probability_value = NanNew(probability); + Local x_value = Nan::New(pt.x); + Local y_value = Nan::New(pt.y); + Local probability_value = Nan::New(probability); - Local < Object > probability_object = NanNew(); - probability_object->Set(NanNew("x"), x_value); - probability_object->Set(NanNew("y"), y_value); - probability_object->Set(NanNew("probability"), probability_value); + Local < Object > probability_object = Nan::New(); + probability_object->Set(Nan::New("x").ToLocalChecked(), x_value); + probability_object->Set(Nan::New("y").ToLocalChecked(), y_value); + probability_object->Set(Nan::New("probability").ToLocalChecked(), probability_value); probabilites_array->Set(index, probability_object); index++; } - NanReturnValue(probabilites_array); + info.GetReturnValue().Set(probabilites_array); } // @author ytham // Match Template filter // Usage: output = input.matchTemplate("templateFileString", method); NAN_METHOD(Matrix::MatchTemplate) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); - v8::String::Utf8Value args0(args[0]->ToString()); + v8::String::Utf8Value args0(info[0]->ToString()); std::string filename = std::string(*args0); cv::Mat templ; templ = cv::imread(filename, CV_8S); - Local out = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *m_out = ObjectWrap::Unwrap(out); + Local out = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_out = Nan::ObjectWrap::Unwrap(out); int cols = self->mat.cols - templ.cols + 1; int rows = self->mat.rows - templ.rows + 1; m_out->mat.create(cols, rows, CV_32FC1); @@ -1999,70 +1999,70 @@ NAN_METHOD(Matrix::MatchTemplate) { TM_CCOEFF_NORMED =5 */ - 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(); cv::matchTemplate(self->mat, templ, m_out->mat, method); - NanReturnValue(out); + info.GetReturnValue().Set(out); } // @author ytham // Min/Max location NAN_METHOD(Matrix::MinMaxLoc) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; cv::minMaxLoc(self->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); - Local v_minVal = NanNew(minVal); - Local v_maxVal = NanNew(maxVal); - Local v_minLoc_x = NanNew(minLoc.x); - Local v_minLoc_y = NanNew(minLoc.y); - Local v_maxLoc_x = NanNew(maxLoc.x); - Local v_maxLoc_y = NanNew(maxLoc.y); + Local v_minVal = Nan::New(minVal); + Local v_maxVal = Nan::New(maxVal); + Local v_minLoc_x = Nan::New(minLoc.x); + Local v_minLoc_y = Nan::New(minLoc.y); + Local v_maxLoc_x = Nan::New(maxLoc.x); + Local v_maxLoc_y = Nan::New(maxLoc.y); - Local o_minLoc = NanNew(); - o_minLoc->Set(NanNew("x"), v_minLoc_x); - o_minLoc->Set(NanNew("y"), v_minLoc_y); + Local o_minLoc = Nan::New(); + o_minLoc->Set(Nan::New("x").ToLocalChecked(), v_minLoc_x); + o_minLoc->Set(Nan::New("y").ToLocalChecked(), v_minLoc_y); - Local o_maxLoc = NanNew(); - o_maxLoc->Set(NanNew("x"), v_maxLoc_x); - o_maxLoc->Set(NanNew("y"), v_maxLoc_y); + Local o_maxLoc = Nan::New(); + o_maxLoc->Set(Nan::New("x").ToLocalChecked(), v_maxLoc_x); + o_maxLoc->Set(Nan::New("y").ToLocalChecked(), v_maxLoc_y); // Output result object - Local result = NanNew(); - result->Set(NanNew("minVal"), v_minVal); - result->Set(NanNew("maxVal"), v_maxVal); - result->Set(NanNew("minLoc"), o_minLoc); - result->Set(NanNew("maxLoc"), o_maxLoc); + Local result = Nan::New(); + result->Set(Nan::New("minVal").ToLocalChecked(), v_minVal); + result->Set(Nan::New("maxVal").ToLocalChecked(), v_maxVal); + result->Set(Nan::New("minLoc").ToLocalChecked(), o_minLoc); + result->Set(Nan::New("maxLoc").ToLocalChecked(), o_maxLoc); - NanReturnValue(result); + info.GetReturnValue().Set(result); } // @author ytham // Pushes some matrix (argument) the back of a matrix (self) NAN_METHOD(Matrix::PushBack) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - Matrix *m_input = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Matrix *m_input = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); self->mat.push_back(m_input->mat); - NanReturnValue(args.This()); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(Matrix::PutText) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); - NanAsciiString textString(args[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); + Nan::Utf8String textString(info[0]); //FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 char *text = *textString;//(char *) malloc(textString.length() + 1); //strcpy(text, *textString); - 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]); char *font = *fontString;//(char *) malloc(fontString.length() + 1); //strcpy(font, *fontString); int constFont = cv::FONT_HERSHEY_SIMPLEX; @@ -2079,25 +2079,25 @@ NAN_METHOD(Matrix::PutText) { cv::Scalar color(0, 0, 255); - if (args[4]->IsArray()) { - Local objColor = args[4]->ToObject(); + if (info[4]->IsArray()) { + Local objColor = info[4]->ToObject(); color = setColor(objColor); } - 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(); cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, thickness); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::GetPerspectiveTransform) { - NanScope(); + Nan::HandleScope scope; - // extract quad args - Local srcArray = args[0]->ToObject(); - Local tgtArray = args[1]->ToObject(); + // extract quad info + Local srcArray = info[0]->ToObject(); + Local tgtArray = info[1]->ToObject(); std::vector src_corners(4); std::vector tgt_corners(4); @@ -2106,28 +2106,28 @@ NAN_METHOD(Matrix::GetPerspectiveTransform) { tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue(),tgtArray->Get(i*2+1)->IntegerValue()); } - Local xfrm = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *xfrmmat = ObjectWrap::Unwrap(xfrm); + Local xfrm = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *xfrmmat = Nan::ObjectWrap::Unwrap(xfrm); xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners); - NanReturnValue(xfrm); + info.GetReturnValue().Set(xfrm); } NAN_METHOD(Matrix::WarpPerspective) { SETUP_FUNCTION(Matrix) - Matrix *xfrm = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *xfrm = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); - int width = args[1]->IntegerValue(); - int height = args[2]->IntegerValue(); + int width = info[1]->IntegerValue(); + int height = info[2]->IntegerValue(); int flags = cv::INTER_LINEAR; int borderMode = cv::BORDER_REPLICATE; cv::Scalar borderColor(0, 0, 255); - if (args[3]->IsArray()) { - Local < Object > objColor = args[3]->ToObject(); + if (info[3]->IsArray()) { + Local < Object > objColor = info[3]->ToObject(); borderColor = setColor(objColor); } @@ -2139,53 +2139,53 @@ NAN_METHOD(Matrix::WarpPerspective) { ~self->mat; self->mat = res; - NanReturnNull(); + info.GetReturnValue().Set(Nan::Null()); } NAN_METHOD(Matrix::CopyWithMask) { SETUP_FUNCTION(Matrix) // param 0 - destination image: - Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *dest = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); // param 1 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); self->mat.copyTo(dest->mat, mask->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::SetWithMask) { SETUP_FUNCTION(Matrix) // param 0 - target value: - Local < Object > valArray = args[0]->ToObject(); + Local < Object > valArray = info[0]->ToObject(); cv::Scalar newvals; newvals.val[0] = valArray->Get(0)->NumberValue(); newvals.val[1] = valArray->Get(1)->NumberValue(); newvals.val[2] = valArray->Get(2)->NumberValue(); // param 1 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix *mask = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); self->mat.setTo(newvals, mask->mat); - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::MeanWithMask) { SETUP_FUNCTION(Matrix) // param 0 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix *mask = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Scalar means = cv::mean(self->mat, mask->mat); - v8::Local < v8::Array > arr = NanNew(3); - arr->Set(0, NanNew(means[0])); - arr->Set(1, NanNew(means[1])); - arr->Set(2, NanNew(means[2])); + v8::Local < v8::Array > arr = Nan::New(3); + arr->Set(0, Nan::New(means[0])); + arr->Set(1, Nan::New(means[1])); + arr->Set(2, Nan::New(means[2])); - NanReturnValue(arr); + info.GetReturnValue().Set(arr); } NAN_METHOD(Matrix::Shift) { @@ -2193,10 +2193,10 @@ NAN_METHOD(Matrix::Shift) { cv::Mat res; - 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 cv::Point2i deltai(ceil(tx), ceil(ty)); int fill = cv::BORDER_REPLICATE; @@ -2227,14 +2227,14 @@ NAN_METHOD(Matrix::Shift) { ~self->mat; self->mat = res; - NanReturnUndefined(); + return; } NAN_METHOD(Matrix::Release) { - NanScope(); + Nan::HandleScope scope; - Matrix *self = ObjectWrap::Unwrap(args.This()); + Matrix *self = Nan::ObjectWrap::Unwrap(info.This()); self->mat.release(); - NanReturnUndefined(); + return; } diff --git a/src/Matrix.h b/src/Matrix.h index 0367f3b..3c87b38 100755 --- a/src/Matrix.h +++ b/src/Matrix.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class Matrix: public node::ObjectWrap { +class Matrix: public Nan::ObjectWrap { public: cv::Mat mat; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); Matrix(); @@ -119,34 +119,34 @@ public: JSFUNC(Release) /* - static Handle Val(const Arguments& args); - static Handle RowRange(const Arguments& args); - static Handle ColRange(const Arguments& args); - static Handle Diag(const Arguments& args); - static Handle Clone(const Arguments& args); - static Handle CopyTo(const Arguments& args); - static Handle ConvertTo(const Arguments& args); - static Handle AssignTo(const Arguments& args); - static Handle SetTo(const Arguments& args); - static Handle Reshape(const Arguments& args); - static Handle Transpose(const Arguments& args); - static Handle Invert(const Arguments& args); - static Handle Multiply(const Arguments& args); - static Handle Cross(const Arguments& args); - static Handle Dot(const Arguments& args); - static Handle Zeroes(const Arguments& args); - static Handle Ones(const Arguments& args); + static Handle Val(const Arguments& info); + static Handle RowRange(const Arguments& info); + static Handle ColRange(const Arguments& info); + static Handle Diag(const Arguments& info); + static Handle Clone(const Arguments& info); + static Handle CopyTo(const Arguments& info); + static Handle ConvertTo(const Arguments& info); + static Handle AssignTo(const Arguments& info); + static Handle SetTo(const Arguments& info); + static Handle Reshape(const Arguments& info); + static Handle Transpose(const Arguments& info); + static Handle Invert(const Arguments& info); + static Handle Multiply(const Arguments& info); + static Handle Cross(const Arguments& info); + static Handle Dot(const Arguments& info); + static Handle Zeroes(const Arguments& info); + static Handle Ones(const Arguments& info); // create, increment, release - static Handle PushBack(const Arguments& args); - static Handle PopBack(const Arguments& args); - static Handle Total(const Arguments& args); - static Handle IsContinous(const Arguments& args); - static Handle Type(const Arguments& args); - static Handle Depth(const Arguments& args); - static Handle Channels(const Arguments& args); - static Handle StepOne(const Arguments& args); - static Handle GetPerspectiveTransform(const Arguments& args); - static Handle WarpPerspective(const Arguments& args); + static Handle PushBack(const Arguments& info); + static Handle PopBack(const Arguments& info); + static Handle Total(const Arguments& info); + static Handle IsContinous(const Arguments& info); + static Handle Type(const Arguments& info); + static Handle Depth(const Arguments& info); + static Handle Channels(const Arguments& info); + static Handle StepOne(const Arguments& info); + static Handle GetPerspectiveTransform(const Arguments& info); + static Handle WarpPerspective(const Arguments& info); */ }; diff --git a/src/OpenCV.cc b/src/OpenCV.cc index 949cec1..8365138 100755 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -3,66 +3,66 @@ #include void OpenCV::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Version string. char out [21]; int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION); - target->Set(NanNew("version"), NanNew(out, n)); + target->Set(Nan::New("version").ToLocalChecked(), Nan::New(out, n).ToLocalChecked()); - NODE_SET_METHOD(target, "readImage", ReadImage); + Nan::SetMethod(target, "readImage", ReadImage); } NAN_METHOD(OpenCV::ReadImage) { - NanEscapableScope(); + Nan::EscapableHandleScope scope; REQ_FUN_ARG(1, cb); Local argv[2]; - argv[0] = NanNull(); + argv[0] = Nan::Null(); - Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_h); + Local im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_h); argv[1] = im_h; try { cv::Mat mat; - if (args[0]->IsNumber() && args[1]->IsNumber()) { + if (info[0]->IsNumber() && info[1]->IsNumber()) { int width, height; - width = args[0]->Uint32Value(); - height = args[1]->Uint32Value(); + width = info[0]->Uint32Value(); + height = info[1]->Uint32Value(); mat = *(new cv::Mat(width, height, CV_64FC1)); - } 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())); mat = cv::imread(filename); - } 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()); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); mat = cv::imdecode(*mbuf, -1); if (mat.empty()) { - argv[0] = NanError("Error loading file"); + argv[0] = Nan::Error("Error loading file"); } } img->mat = mat; } catch (cv::Exception& e) { - argv[0] = NanError(e.what()); - argv[1] = NanNull(); + argv[0] = Nan::Error(e.what()); + argv[1] = Nan::Null(); } TryCatch try_catch; - cb->Call(NanGetCurrentContext()->Global(), 2, argv); + cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - NanReturnUndefined(); + return; } diff --git a/src/OpenCV.h b/src/OpenCV.h index 79f191a..6e368ae 100755 --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -15,34 +15,34 @@ using namespace v8; using namespace node; #define REQ_FUN_ARG(I, VAR) \ - if (args.Length() <= (I) || !args[I]->IsFunction()) \ - return NanThrowTypeError("Argument " #I " must be a function"); \ - Local VAR = Local::Cast(args[I]); + if (info.Length() <= (I) || !info[I]->IsFunction()) \ + return Nan::ThrowTypeError("Argument " #I " must be a function"); \ + Local VAR = Local::Cast(info[I]); #define SETUP_FUNCTION(TYP) \ - NanScope(); \ - TYP *self = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; \ + TYP *self = Nan::ObjectWrap::Unwrap(info.This()); #define JSFUNC(NAME) \ static NAN_METHOD(NAME); #define JSTHROW_TYPE(ERR) \ - NanThrowTypeError( ERR ); + Nan::ThrowTypeError( ERR ); #define JSTHROW(ERR) \ - NanThrowError( ERR ); + Nan::ThrowError( ERR ); #define INT_FROM_ARGS(NAME, IND) \ - if (args[IND]->IsInt32()){ \ - NAME = args[IND]->Uint32Value(); \ + if (info[IND]->IsInt32()){ \ + NAME = info[IND]->Uint32Value(); \ } #define DOUBLE_FROM_ARGS(NAME, IND) \ - 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 { public: static void Init(Handle target); diff --git a/src/Point.cc b/src/Point.cc index b90119f..060029d 100755 --- a/src/Point.cc +++ b/src/Point.cc @@ -1,72 +1,72 @@ #include "Point.h" #include "OpenCV.h" -v8::Persistent Point::constructor; +Nan::Persistent Point::constructor; void Point::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; // Constructor - Local ctor = NanNew(Point::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(Point::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("Point")); + ctor->SetClassName(Nan::New("Point").ToLocalChecked()); // Prototype Local proto = ctor->PrototypeTemplate(); - 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()); }; NAN_METHOD(Point::New) { - 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"); } double x = 0, y = 0; - 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(); } Point *pt = new Point(x, y); - pt->Wrap(args.This()); - NanReturnValue(args.This()); + pt->Wrap(info.This()); + info.GetReturnValue().Set(info.This()); } NAN_GETTER(Point::GetX) { - NanScope(); - Point *pt = ObjectWrap::Unwrap(args.This()); - NanReturnValue(NanNew(pt->point.x)); + Nan::HandleScope scope; + Point *pt = Nan::ObjectWrap::Unwrap(info.This()); + info.GetReturnValue().Set(Nan::New(pt->point.x)); } NAN_GETTER(Point::GetY) { - NanScope(); - Point *pt = ObjectWrap::Unwrap(args.This()); - NanReturnValue(NanNew(pt->point.y)); + Nan::HandleScope scope; + Point *pt = Nan::ObjectWrap::Unwrap(info.This()); + info.GetReturnValue().Set(Nan::New(pt->point.y)); } NAN_SETTER(Point::RaiseImmutable) { - NanThrowTypeError("Point is immutable"); + Nan::ThrowTypeError("Point is immutable"); } NAN_METHOD(Point::Dot) { - NanScope(); - Point *p1 = ObjectWrap::Unwrap(args.This()); - Point *p2 = ObjectWrap::Unwrap(args[0]->ToObject()); + Nan::HandleScope scope; + Point *p1 = Nan::ObjectWrap::Unwrap(info.This()); + Point *p2 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); // Since V 2.3 Native Dot no longer supported - NanReturnValue(NanNew(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); + info.GetReturnValue().Set(Nan::New(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); } Point::Point(double x, double y) : - ObjectWrap() { + Nan::ObjectWrap() { point = cvPoint2D32f(x, y); } diff --git a/src/Point.h b/src/Point.h index 2aec52d..d72bf60 100755 --- a/src/Point.h +++ b/src/Point.h @@ -2,10 +2,10 @@ #include "OpenCV.h" -class Point: public node::ObjectWrap { +class Point: public Nan::ObjectWrap { public: CvPoint2D32f point; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); Point(double x, double y); diff --git a/src/Stereo.cc b/src/Stereo.cc index e524eef..b5f83f5 100644 --- a/src/Stereo.cc +++ b/src/Stereo.cc @@ -4,54 +4,54 @@ // Block matching -v8::Persistent StereoBM::constructor; +Nan::Persistent StereoBM::constructor; void StereoBM::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew(StereoBM::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(StereoBM::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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("BASIC_PRESET"), NanNew((int)cv::StereoBM::BASIC_PRESET)); - ctor->Set(NanNew("FISH_EYE_PRESET"), NanNew((int)cv::StereoBM::FISH_EYE_PRESET)); - ctor->Set(NanNew("NARROW_PRESET"), NanNew((int)cv::StereoBM::NARROW_PRESET)); + ctor->Set(Nan::New("BASIC_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::BASIC_PRESET)); + ctor->Set(Nan::New("FISH_EYE_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::FISH_EYE_PRESET)); + ctor->Set(Nan::New("NARROW_PRESET").ToLocalChecked(), Nan::New((int)cv::StereoBM::NARROW_PRESET)); - target->Set(NanNew("StereoBM"), ctor->GetFunction()); + target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction()); } NAN_METHOD(StereoBM::New) { - 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"); } StereoBM *stereo; - if (args.Length() == 0) { + if (info.Length() == 0) { stereo = new StereoBM(); - } else if (args.Length() == 1) { + } else if (info.Length() == 1) { // preset - stereo = new StereoBM(args[0]->IntegerValue()); - } else if (args.Length() == 2) { + stereo = new StereoBM(info[0]->IntegerValue()); + } else if (info.Length() == 2) { // preset, disparity search range - stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue()); + stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue()); } else { - stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(), + stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue(), // preset, disparity search range, sum of absolute differences window size - args[2]->IntegerValue()); + info[2]->IntegerValue()); } - stereo->Wrap(args.Holder()); - NanReturnValue(args.Holder()); + stereo->Wrap(info.Holder()); + info.GetReturnValue().Set(info.Holder()); } StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) : - ObjectWrap(), + Nan::ObjectWrap(), stereo(preset, ndisparities, SADWindowSize) { } @@ -63,17 +63,17 @@ NAN_METHOD(StereoBM::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat right = m1->mat; // Optional 3rd arg, the disparty depth int type = CV_16S; - if (args.Length() > 2) { - type = args[2]->IntegerValue(); + if (info.Length() > 2) { + type = info[2]->IntegerValue(); } // Compute stereo using the block matching algorithm @@ -82,108 +82,108 @@ NAN_METHOD(StereoBM::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - NanReturnValue(disparityWrap); + info.GetReturnValue().Set(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // Semi-Global Block matching -v8::Persistent StereoSGBM::constructor; +Nan::Persistent StereoSGBM::constructor; void StereoSGBM::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew(StereoSGBM::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(StereoSGBM::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); } NAN_METHOD(StereoSGBM::New) { - 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"); } StereoSGBM *stereo; - if (args.Length() == 0) { + if (info.Length() == 0) { stereo = new StereoSGBM(); } else { // If passing arguments, must pass the first 3 at least - if (args.Length() >= 3) { - switch (args.Length()) { + if (info.Length() >= 3) { + switch (info.Length()) { case 3: - stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), - args[2]->IntegerValue()); + stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), + info[2]->IntegerValue()); break; case 4: - 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()); break; case 5: - 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()); break; case 6: - 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()); break; case 7: - 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()); break; case 8: - 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()); break; case 9: - 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()); break; case 10: - 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()); break; default: - 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()); break; } } else { - 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()); } StereoSGBM::StereoSGBM() : - ObjectWrap(), + Nan::ObjectWrap(), stereo() { } @@ -191,7 +191,7 @@ StereoSGBM::StereoSGBM() : StereoSGBM::StereoSGBM(int minDisparity, int ndisparities, int SADWindowSize, int p1, int p2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, bool fullDP) : - ObjectWrap(), + Nan::ObjectWrap(), stereo(minDisparity, ndisparities, SADWindowSize, p1, p2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP) { } @@ -204,11 +204,11 @@ NAN_METHOD(StereoSGBM::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat right = m1->mat; // Compute stereo using the block matching algorithm @@ -217,59 +217,59 @@ NAN_METHOD(StereoSGBM::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - NanReturnValue(disparityWrap); + info.GetReturnValue().Set(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } // Graph cut -v8::Persistent StereoGC::constructor; +Nan::Persistent StereoGC::constructor; void StereoGC::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; - Local ctor = NanNew(StereoGC::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(StereoGC::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - 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()); } NAN_METHOD(StereoGC::New) { - 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"); StereoGC *stereo; - if (args.Length() == 0) { + if (info.Length() == 0) { stereo = new StereoGC(); - } else if (args.Length() == 1) { + } else if (info.Length() == 1) { // numberOfDisparities - stereo = new StereoGC(args[0]->IntegerValue()); + stereo = new StereoGC(info[0]->IntegerValue()); } else { // max iterations - 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()); } StereoGC::StereoGC(int numberOfDisparities, int maxIters) : - ObjectWrap() { + Nan::ObjectWrap() { stereo = cvCreateStereoGCState(numberOfDisparities, maxIters); } @@ -281,11 +281,11 @@ NAN_METHOD(StereoGC::Compute) { // Get the arguments // Arg 0, the 'left' image - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + Matrix* m0 = Nan::ObjectWrap::Unwrap(info[0]->ToObject()); cv::Mat left = m0->mat; // Arg 1, the 'right' image - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + Matrix* m1 = Nan::ObjectWrap::Unwrap(info[1]->ToObject()); cv::Mat right = m1->mat; // Compute stereo using the block matching algorithm @@ -301,14 +301,14 @@ NAN_METHOD(StereoGC::Compute) { // Wrap the returned disparity map Local < Object > disparityWrap = - NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = Nan::ObjectWrap::Unwrap(disparityWrap); disp->mat = disparity; - NanReturnValue(disparityWrap); + info.GetReturnValue().Set(disparityWrap); } catch (cv::Exception &e) { const char *err_msg = e.what(); - NanThrowError(err_msg); - NanReturnUndefined(); + Nan::ThrowError(err_msg); + return; } } diff --git a/src/Stereo.h b/src/Stereo.h index a791732..a26a8f8 100644 --- a/src/Stereo.h +++ b/src/Stereo.h @@ -3,11 +3,11 @@ #include "OpenCV.h" -class StereoBM: public node::ObjectWrap { +class StereoBM: public Nan::ObjectWrap { public: cv::StereoBM stereo; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); @@ -18,11 +18,11 @@ public: ; }; -class StereoSGBM: public node::ObjectWrap { +class StereoSGBM: public Nan::ObjectWrap { public: cv::StereoSGBM stereo; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); @@ -37,11 +37,11 @@ public: struct CvStereoGCState; -class StereoGC: public node::ObjectWrap { +class StereoGC: public Nan::ObjectWrap { public: CvStereoGCState *stereo; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index 970419a..ca6da1c 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -5,11 +5,11 @@ #include using namespace std; -v8::Persistent VideoCaptureWrap::constructor; +Nan::Persistent VideoCaptureWrap::constructor; struct videocapture_baton { - Persistent cb; + Nan::Persistent cb; VideoCaptureWrap *vc; Matrix *im; @@ -17,124 +17,124 @@ struct videocapture_baton { }; void VideoCaptureWrap::Init(Handle target) { - NanScope(); + Nan::HandleScope scope; //Class - Local ctor = NanNew(VideoCaptureWrap::New); - NanAssignPersistent(constructor, ctor); + Local ctor = Nan::New(VideoCaptureWrap::New); + constructor.Reset(ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); - ctor->SetClassName(NanNew("VideoCapture")); + ctor->SetClassName(Nan::New("VideoCapture").ToLocalChecked()); // Prototype //Local proto = constructor->PrototypeTemplate(); - 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()); } NAN_METHOD(VideoCaptureWrap::New) { - 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"); VideoCaptureWrap *v; - if (args[0]->IsNumber()) { - v = new VideoCaptureWrap(args[0]->NumberValue()); + if (info[0]->IsNumber()) { + v = new VideoCaptureWrap(info[0]->NumberValue()); } else { //TODO - assumes that we have string, verify - 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()); } VideoCaptureWrap::VideoCaptureWrap(int device) { - NanScope(); + Nan::HandleScope scope; cap.open(device); if(!cap.isOpened()) { - NanThrowError("Camera could not be opened"); + Nan::ThrowError("Camera could not be opened"); } } VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) { - NanScope(); + Nan::HandleScope scope; cap.open(filename); // TODO! At the moment this only takes a full path - do relative too. if(!cap.isOpened()) { - 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)"); } } NAN_METHOD(VideoCaptureWrap::SetWidth) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - if(args.Length() != 1) - NanReturnUndefined(); + if(info.Length() != 1) + return; - int w = args[0]->IntegerValue(); + int w = info[0]->IntegerValue(); if(v->cap.isOpened()) v->cap.set(CV_CAP_PROP_FRAME_WIDTH, w); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::SetHeight) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - if(args.Length() != 1) - NanReturnUndefined(); + if(info.Length() != 1) + return; - int h = args[0]->IntegerValue(); + int h = info[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::SetPosition) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - if(args.Length() != 1) - NanReturnUndefined(); + if(info.Length() != 1) + return; - int pos = args[0]->IntegerValue(); + int pos = info[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_POS_FRAMES, pos); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::Close) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); v->cap.release(); - NanReturnUndefined(); + return; } -class AsyncVCWorker: public NanAsyncWorker { +class AsyncVCWorker: public Nan::AsyncWorker { public: - AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc, + AsyncVCWorker(Nan::Callback *callback, VideoCaptureWrap* vc, bool retrieve = false, int channel = 0) : - NanAsyncWorker(callback), + Nan::AsyncWorker(callback), vc(vc), retrieve(retrieve), channel(channel) { @@ -161,14 +161,14 @@ public: // this function will be run inside the main event loop // so it is safe to use V8 again void HandleOKCallback() { - NanScope(); + Nan::HandleScope scope; - Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_to_return); + Local im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_to_return); img->mat = mat; Local argv[] = { - NanNull() + Nan::Null() , im_to_return }; @@ -187,33 +187,33 @@ private: }; NAN_METHOD(VideoCaptureWrap::Read) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); REQ_FUN_ARG(0, cb); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncVCWorker(callback, v)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v)); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::ReadSync) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); - Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_to_return); + Local im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = Nan::ObjectWrap::Unwrap(im_to_return); v->cap.read(img->mat); - NanReturnValue(im_to_return); + info.GetReturnValue().Set(im_to_return); } -class AsyncGrabWorker: public NanAsyncWorker { +class AsyncGrabWorker: public Nan::AsyncWorker { public: - AsyncGrabWorker(NanCallback *callback, VideoCaptureWrap* vc) : - NanAsyncWorker(callback), + AsyncGrabWorker(Nan::Callback *callback, VideoCaptureWrap* vc) : + Nan::AsyncWorker(callback), vc(vc) { } @@ -231,27 +231,27 @@ private: }; NAN_METHOD(VideoCaptureWrap::Grab) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); REQ_FUN_ARG(0, cb); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncGrabWorker(callback, v)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncGrabWorker(callback, v)); - NanReturnUndefined(); + return; } NAN_METHOD(VideoCaptureWrap::Retrieve) { - NanScope(); - VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap(info.This()); int channel = 0; REQ_FUN_ARG(0, cb); INT_FROM_ARGS(channel, 1); - NanCallback *callback = new NanCallback(cb.As()); - NanAsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); + Nan::Callback *callback = new Nan::Callback(cb.As()); + Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); - NanReturnUndefined(); + return; } diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h index fb16c4d..a9b3b03 100755 --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -1,10 +1,10 @@ #include "OpenCV.h" -class VideoCaptureWrap: public node::ObjectWrap { +class VideoCaptureWrap: public Nan::ObjectWrap { public: cv::VideoCapture cap; - static Persistent constructor; + static Nan::Persistent constructor; static void Init(Handle target); static NAN_METHOD(New); diff --git a/src/init.cc b/src/init.cc index 56495c3..9e1b2fc 100755 --- a/src/init.cc +++ b/src/init.cc @@ -16,7 +16,7 @@ #include "BackgroundSubtractor.h" extern "C" void init(Handle target) { - NanScope(); + Nan::HandleScope scope; OpenCV::Init(target); Point::Init(target); diff --git a/upgrade-log.html b/upgrade-log.html new file mode 100644 index 0000000..58592d3 --- /dev/null +++ b/upgrade-log.html @@ -0,0 +1,5333 @@ + + + Upgrade utils report + + + + + + +
+ +

Upgrade utils report

+
+ +
+
+

Your files were updated according to the changes described below, to complete the update follow these steps:

+
    +
  • Remove your Nan dependency with npm remove nan --save +
  • Add Nan with npm install nan --save to get the last version +
  • Rebuild your module node-gyp rebuild +
  • Check if there are errors and manually fix those
    • +
+
+
+
+

Lines changed in src/BackgroundSubtractor.cc

+
+ 
- 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;
+
+
+
+
+

Lines changed in src/Calib3D.cc

+
+ 
-       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;
+
+
+
+
+

Lines changed in src/BackgroundSubtractor.h

+
+ 
- class BackgroundSubtractorWrap: public node::ObjectWrap {
+
+ 
+ class BackgroundSubtractorWrap: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/CamShift.cc

+
+ 
- 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);
+
+
+
+
+

Lines changed in src/Calib3D.h

+
+ 
- class Calib3D: public node::ObjectWrap {
+
+ 
+ class Calib3D: public Nan::ObjectWrap {
+
+
+
+
+

Lines changed in src/CascadeClassifierWrap.cc

+
+ 
- 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;
+
+
+
+
+

Lines changed in src/CascadeClassifierWrap.h

+
+ 
- class CascadeClassifierWrap: public node::ObjectWrap {
+
+ 
+ class CascadeClassifierWrap: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/CamShift.h

+
+ 
- class TrackedObject: public node::ObjectWrap {
+
+ 
+ class TrackedObject: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/Constants.h

+
+ 
- class Constants: public node::ObjectWrap {
+
+ 
+ class Constants: public Nan::ObjectWrap {
+
+
+
+
+

Lines changed in src/Constants.cc

+
+ 
-   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);
+
+
+
+
+

Lines changed in src/Contours.cc

+
+ 
- 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());
+
+
+
+
+

Lines changed in src/Contours.h

+
+ 
- class Contour: public node::ObjectWrap {
+
+ 
+ class Contour: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/FaceRecognizer.cc

+
+ 
-     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);
+
+
+
+
+

Lines changed in src/FaceRecognizer.h

+
+ 
- class FaceRecognizerWrap: public node::ObjectWrap {
+
+ 
+ class FaceRecognizerWrap: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/Features2d.cc

+
+ 
-   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;
+
+
+
+
+

Lines changed in src/Features2d.h

+
+ 
- class Features: public node::ObjectWrap {
+
+ 
+ class Features: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/HighGUI.cc

+
+ 
- 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));
+
+
+
+
+

Lines changed in src/HighGUI.h

+
+ 
- class NamedWindow: public node::ObjectWrap {
+
+ 
+ class NamedWindow: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/ImgProc.cc

+
+ 
-   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;
+
+
+
+
+

Lines changed in src/ImgProc.h

+
+ 
- class ImgProc: public node::ObjectWrap {
+
+ 
+ class ImgProc: public Nan::ObjectWrap {
+
+
+
+
+

Lines changed in src/Matrix.h

+
+ 
- 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);
+
+
+
+
+

Lines changed in src/OpenCV.cc

+
+ 
-   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;
+
+
+
+
+

Lines changed in src/OpenCV.h

+
+ 
-   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 {
+
+
+
+
+

Lines changed in src/Matrix.cc

+
+ 
- 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;
+
+
+
+
+

Lines changed in src/Point.cc

+
+ 
- 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() {
+
+
+
+
+

Lines changed in src/Point.h

+
+ 
- class Point: public node::ObjectWrap {
+
+ 
+ class Point: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/Stereo.cc

+
+ 
- 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;
+
+
+
+
+

Lines changed in src/Stereo.h

+
+ 
- 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;
+
+
+
+
+

Lines changed in src/VideoCaptureWrap.cc

+
+ 
- 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;
+
+
+
+
+

Lines changed in src/VideoCaptureWrap.h

+
+ 
- class VideoCaptureWrap: public node::ObjectWrap {
+
+ 
+ class VideoCaptureWrap: public Nan::ObjectWrap {
+
+ 
-   static Persistent<FunctionTemplate> constructor;
+
+ 
+   static Nan::Persistent<FunctionTemplate> constructor;
+
+
+
+
+

Lines changed in src/init.cc

+
+ 
-   NanScope();
+
+ 
+   Nan::HandleScope scope;
+
+
+
+
+ +
+

Suggested changes in your JavaScript files

+
+

buffer

+

Please review changes in Node API for buffer module used in these files:

+
    +
  • examples/face-proxy.js
    • +
  • examples/mat-put.js
    • +
  • examples/mat-normalize.js
    • +
  • lib/opencv.js
    • +
  • test/unit.js
    • +
+
+

[Docs]

+
    +
  • External memory is now allocated using TypedArrays, instead of using SlowBuffer or smalloc as the parent backing. +
    • +
+
+
    +
  • Buffer.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. +
    • +
  • Buffer.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. +
    • +
  • Buffer.prototype.parent is now a getter that points to buffer.buffer if the buffer's size is greater than zero. +
    • +
  • Buffer.prototype.offset is now a read-only getter that returns buffer.byteOffset. +
    • +
  • Buffer.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. +
    • +
  • Buffer.prototype._charsWritten no longer is written to, nor exists. +
    • +
+

Buffer changes from V8

+

Implementation 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.
    • +
  • Invalid unicode characters are replaced to no longer become invalid. +
    • +
+ +
+
+
+
+

process

+

Please review changes in Node API for process module used in these files:

+
    +
  • lib/opencv.js
    • +
  • test/examples.js
    • +
+
+

[Docs]

+
    +
  • Added the concept of beforeExit time.
      +
    • Before the process emits '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.
      • +
    • Refs: a2eeb43
      • +
    +
    • +
  • Chunked writes to sdtout/stderr will now be lost if the process is terminated early.
      +
    • Chunked writes happen when the string to be written is beyond a certain, fairly large, size.
      • +
    • Refs: #784, #1771
      • +
    +
    • +
  • process.kill() now throws errors on non-numeric input.
      +
    • Strings that can be coerced to numbers still work. e.g. process.kill('0').
      • +
    • Refs: 832ec1c, 743a009
      • +
    +
    • +
  • process.maxTickDepth has been removed, allowing process.nextTick() to starve I/O indefinitely.
      +
    • This is due to adding setImmediate() in 0.10.
      • +
    • It is suggested you use 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.
      • +
    • Refs: 0761c90, 9a6c085
      • +
    +
    • +
  • process.send() is now always asynchronous, where previously it was blocking on Unix.
      +
    • Pull request #2620, which should land before 4.0.0, will make send() accept a callback as the last argument, with will be called with one argument: null if it succeeded, or an Error if it failed.
      • +
    • Refs: #760, #2620
      • +
    +
    • +
+

Signal handling

+

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.

+ +
+
+
+
+

util

+

Please review changes in Node API for util module used in these files:

+
    +
  • lib/opencv.js
    • +
+
+

[Docs]

+
    +
  • util.is*() (isArray() ... isUndefined()) type-checking functions were added in 0.12 but are scheduled for deprecation. Please use user-land solutions instead.
      +
    • The type checking these use will be come brittle with the eventual addition of Symbol.toStringTag.
      • +
    • Refs: #2447
      • +
    +
    • +
  • Updated util.format() to receive several changes:
      +
    • -0 is now displayed as such, instead of as 0. +
      • +
    • Anything that is instanceof Error is now formatted as an error. +
      • +
    • Circular references in JavaScript objects are now handled for the %j specifier. +
      • +
    • Custom inspect functions now receive any arguments passed to util.inspect. +
      • +
    • Displays the constructor name if available. +
      • +
    +
    • +
  • The following utilities were deprecated in 896b2aa: +
    • +
+ +
+
+
+
+ + From a0faef9e654ba838ad709fb4d219bbb02aae0b66 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Mon, 5 Oct 2015 13:53:34 -0500 Subject: [PATCH 6/9] Here goes nothing... MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit So apparently Nan v2 has removed Handle and uses Local instead. Not sure wtf that’s all about. I have no idea if this works, but it builds in both node v4.1.1 and v0.12.7 and passes the included tests in both. --- src/CascadeClassifierWrap.cc | 2 +- src/FaceRecognizer.cc | 8 ++++---- src/FaceRecognizer.h | 2 +- src/Features2d.cc | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index c3dce38..49d347f 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -82,7 +82,7 @@ public: Nan::HandleScope scope; // this->matrix->Unref(); - Handle < Value > argv[2]; + Local < Value > argv[2]; v8::Local < v8::Array > arr = Nan::New < v8::Array > (this->res.size()); for (unsigned int i = 0; i < this->res.size(); i++) { diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc index 1b2eb82..8bb1bfa 100644 --- a/src/FaceRecognizer.cc +++ b/src/FaceRecognizer.cc @@ -29,7 +29,7 @@ void AfterAsyncPredict(uv_work_t *req); Nan::Persistent FaceRecognizerWrap::constructor; -void FaceRecognizerWrap::Init(Handle target) { +void FaceRecognizerWrap::Init(Local target) { Nan::HandleScope scope; // Constructor @@ -135,7 +135,7 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, typ = type; } -Handle UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info, +Local UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info, cv::vector* images, cv::vector* labels) { if (info.Length() < 1 || !info[0]->IsArray()) { @@ -176,7 +176,7 @@ NAN_METHOD(FaceRecognizerWrap::TrainSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(info, &images, &labels); + Local exception = UnwrapTrainingData(info, &images, &labels); if (!exception->IsUndefined()) { info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this } @@ -199,7 +199,7 @@ NAN_METHOD(FaceRecognizerWrap::UpdateSync) { cv::vector images; cv::vector labels; - Handle exception = UnwrapTrainingData(info, &images, &labels); + Local exception = UnwrapTrainingData(info, &images, &labels); if (!exception->IsUndefined()) { JSTHROW(exception); } diff --git a/src/FaceRecognizer.h b/src/FaceRecognizer.h index 6a19d10..e4db0df 100644 --- a/src/FaceRecognizer.h +++ b/src/FaceRecognizer.h @@ -10,7 +10,7 @@ public: int typ; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); FaceRecognizerWrap(cv::Ptr f, int type); diff --git a/src/Features2d.cc b/src/Features2d.cc index ce09abc..d6c7179 100644 --- a/src/Features2d.cc +++ b/src/Features2d.cc @@ -82,7 +82,7 @@ public: void HandleOKCallback() { Nan::HandleScope scope; - Handle argv[2]; + Local argv[2]; argv[0] = Nan::Null(); argv[1] = Nan::New(dissimilarity); From ec09e0bdde15ddd865e238e662ed2da451fbb96d Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Mon, 5 Oct 2015 14:33:12 -0500 Subject: [PATCH 7/9] Swapped out all "handle" for "local" Now building and passing tests locally in node v0.10.40 v0.12.7 and v4.1.1. Other modules would not build at node lower than v0.10, so I stopped there. --- package.json | 2 +- src/BackgroundSubtractor.cc | 2 +- src/BackgroundSubtractor.h | 2 +- src/Calib3D.cc | 14 +++++++------- src/Calib3D.h | 2 +- src/CamShift.cc | 2 +- src/CamShift.h | 2 +- src/CascadeClassifierWrap.cc | 2 +- src/CascadeClassifierWrap.h | 2 +- src/Constants.cc | 2 +- src/Constants.h | 2 +- src/Contours.cc | 14 +++++++------- src/Contours.h | 2 +- src/Features2d.cc | 2 +- src/Features2d.h | 2 +- src/HighGUI.cc | 2 +- src/HighGUI.h | 2 +- src/ImgProc.cc | 2 +- src/ImgProc.h | 2 +- src/Matrix.cc | 16 ++++++++-------- src/Matrix.h | 2 +- src/OpenCV.cc | 2 +- src/OpenCV.h | 2 +- src/Point.cc | 2 +- src/Point.h | 2 +- src/Stereo.cc | 6 +++--- src/Stereo.h | 6 +++--- src/VideoCaptureWrap.cc | 2 +- src/VideoCaptureWrap.h | 2 +- src/init.cc | 2 +- 30 files changed, 53 insertions(+), 53 deletions(-) diff --git a/package.json b/package.json index 357626d..88dda82 100644 --- a/package.json +++ b/package.json @@ -32,7 +32,7 @@ "main": "./lib/opencv", "repository": { "type": "git", - "url": "https://github.com/keeganbrown/node-opencv.git" + "url": "https://github.com/peterbraden/node-opencv.git" }, "engines": { "node": ">=0.12" diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index 7bf1741..69b703d 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -7,7 +7,7 @@ Nan::Persistent BackgroundSubtractorWrap::constructor; -void BackgroundSubtractorWrap::Init(Handle target) { +void BackgroundSubtractorWrap::Init(Local target) { Nan::HandleScope scope; // Constructor diff --git a/src/BackgroundSubtractor.h b/src/BackgroundSubtractor.h index b237699..551d212 100644 --- a/src/BackgroundSubtractor.h +++ b/src/BackgroundSubtractor.h @@ -9,7 +9,7 @@ public: cv::Ptr subtractor; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); BackgroundSubtractorWrap(cv::Ptr bg); diff --git a/src/Calib3D.cc b/src/Calib3D.cc index a49ed31..885cbeb 100644 --- a/src/Calib3D.cc +++ b/src/Calib3D.cc @@ -10,12 +10,12 @@ inline Local matrixFromMat(cv::Mat &input) { return matrixWrap; } -inline cv::Mat matFromMatrix(Handle matrix) { +inline cv::Mat matFromMatrix(Local matrix) { Matrix* m = Nan::ObjectWrap::Unwrap(matrix->ToObject()); return m->mat; } -inline cv::Size sizeFromArray(Handle jsArray) { +inline cv::Size sizeFromArray(Local jsArray) { cv::Size patternSize; if (jsArray->IsArray()) { @@ -30,7 +30,7 @@ inline cv::Size sizeFromArray(Handle jsArray) { return patternSize; } -inline std::vector points2fFromArray(Handle array) { +inline std::vector points2fFromArray(Local array) { std::vector points; if (array->IsArray()) { Local pointsArray = Local::Cast(array->ToObject()); @@ -48,7 +48,7 @@ inline std::vector points2fFromArray(Handle array) { return points; } -inline std::vector points3fFromArray(Handle array) { +inline std::vector points3fFromArray(Local array) { std::vector points; if (array->IsArray()) { Local pointsArray = Local::Cast(array->ToObject()); @@ -68,7 +68,7 @@ inline std::vector points3fFromArray(Handle array) { } inline std::vector > points2fFromArrayOfArrays( - Handle array) { + Local array) { std::vector > points; if (array->IsArray()) { Local pointsArray = Local::Cast(array->ToObject()); @@ -84,7 +84,7 @@ inline std::vector > points2fFromArrayOfArrays( } inline std::vector > points3fFromArrayOfArrays( - Handle array) { + Local array) { std::vector > points; if (array->IsArray()) { Local pointsArray = Local::Cast(array->ToObject()); @@ -99,7 +99,7 @@ inline std::vector > points3fFromArrayOfArrays( return points; } -void Calib3D::Init(Handle target) { +void Calib3D::Init(Local target) { Nan::Persistent inner; Local obj = Nan::New(); inner.Reset(obj); diff --git a/src/Calib3D.h b/src/Calib3D.h index 9617757..7d94943 100644 --- a/src/Calib3D.h +++ b/src/Calib3D.h @@ -8,7 +8,7 @@ */ class Calib3D: public Nan::ObjectWrap { public: - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(FindChessboardCorners); static NAN_METHOD(DrawChessboardCorners); static NAN_METHOD(CalibrateCamera); diff --git a/src/CamShift.cc b/src/CamShift.cc index 5e08324..fed246a 100644 --- a/src/CamShift.cc +++ b/src/CamShift.cc @@ -10,7 +10,7 @@ Nan::Persistent TrackedObject::constructor; -void TrackedObject::Init(Handle target) { +void TrackedObject::Init(Local target) { Nan::HandleScope scope; // Constructor diff --git a/src/CamShift.h b/src/CamShift.h index ac049f3..7524408 100644 --- a/src/CamShift.h +++ b/src/CamShift.h @@ -13,7 +13,7 @@ public: cv::Rect prev_rect; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); TrackedObject(cv::Mat image, cv::Rect rect, int channel); diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index 49d347f..9642722 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -5,7 +5,7 @@ Nan::Persistent CascadeClassifierWrap::constructor; -void CascadeClassifierWrap::Init(Handle target) { +void CascadeClassifierWrap::Init(Local target) { Nan::HandleScope scope; Local ctor = Nan::New (CascadeClassifierWrap::New); diff --git a/src/CascadeClassifierWrap.h b/src/CascadeClassifierWrap.h index c0016d9..0f80ba1 100755 --- a/src/CascadeClassifierWrap.h +++ b/src/CascadeClassifierWrap.h @@ -5,7 +5,7 @@ public: cv::CascadeClassifier cc; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); CascadeClassifierWrap(v8::Value* fileName); diff --git a/src/Constants.cc b/src/Constants.cc index 5d9fa22..814cd65 100644 --- a/src/Constants.cc +++ b/src/Constants.cc @@ -7,7 +7,7 @@ #define CONST_ENUM(C) \ obj->Set(Nan::New(#C).ToLocalChecked(), Nan::New((int)(cv::C))); -void Constants::Init(Handle target) { +void Constants::Init(Local target) { Nan::Persistent inner; Local obj = Nan::New(); inner.Reset(obj); diff --git a/src/Constants.h b/src/Constants.h index 9bb818e..2a2a580 100644 --- a/src/Constants.h +++ b/src/Constants.h @@ -2,5 +2,5 @@ class Constants: public Nan::ObjectWrap { public: - static void Init(Handle target); + static void Init(Local target); }; diff --git a/src/Contours.cc b/src/Contours.cc index f8eb726..406140a 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -6,7 +6,7 @@ Nan::Persistent Contour::constructor; -void Contour::Init(Handle target) { +void Contour::Init(Local target) { Nan::HandleScope scope; // Class/contructor @@ -331,21 +331,21 @@ NAN_METHOD(Contour::Deserialize) { Contour *self = Nan::ObjectWrap::Unwrap(info.This()); - Handle data = Handle::Cast(info[0]); + Local data = Local::Cast(info[0]); - Handle contours_data = Handle::Cast(data->Get(Nan::New("contours").ToLocalChecked())); - Handle hierarchy_data = Handle::Cast(data->Get(Nan::New("hierarchy").ToLocalChecked())); + Local contours_data = Local::Cast(data->Get(Nan::New("contours").ToLocalChecked())); + Local hierarchy_data = Local::Cast(data->Get(Nan::New("hierarchy").ToLocalChecked())); vector > contours_res; int contours_length = contours_data->Length(); for (int i = 0; i < contours_length; i++) { - Handle contour_data = Handle::Cast(contours_data->Get(i)); + Local contour_data = Local::Cast(contours_data->Get(i)); vector points; int contour_length = contour_data->Length(); for (int j = 0; j < contour_length; j++) { - Handle point_data = Handle::Cast(contour_data->Get(j)); + Local point_data = Local::Cast(contour_data->Get(j)); int x = point_data->Get(0)->IntegerValue(); int y = point_data->Get(1)->IntegerValue(); points.push_back(cv::Point(x, y)); @@ -358,7 +358,7 @@ NAN_METHOD(Contour::Deserialize) { int hierarchy_length = hierarchy_data->Length(); for (int i = 0; i < hierarchy_length; i++) { - Handle contour_data = Handle::Cast(hierarchy_data->Get(i)); + Local contour_data = Local::Cast(hierarchy_data->Get(i)); int a = contour_data->Get(0)->IntegerValue(); int b = contour_data->Get(1)->IntegerValue(); int c = contour_data->Get(2)->IntegerValue(); diff --git a/src/Contours.h b/src/Contours.h index b1a496a..cbbff01 100755 --- a/src/Contours.h +++ b/src/Contours.h @@ -9,7 +9,7 @@ public: vector hierarchy; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); Contour(); diff --git a/src/Features2d.cc b/src/Features2d.cc index d6c7179..596ce98 100644 --- a/src/Features2d.cc +++ b/src/Features2d.cc @@ -5,7 +5,7 @@ #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) -void Features::Init(Handle target) { +void Features::Init(Local target) { Nan::HandleScope scope; Nan::SetMethod(target, "ImageSimilarity", Similarity); diff --git a/src/Features2d.h b/src/Features2d.h index 600f646..6ae2b21 100644 --- a/src/Features2d.h +++ b/src/Features2d.h @@ -8,7 +8,7 @@ class Features: public Nan::ObjectWrap { public: static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(Similarity); }; diff --git a/src/HighGUI.cc b/src/HighGUI.cc index b43fb89..b61b1fa 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -4,7 +4,7 @@ Nan::Persistent NamedWindow::constructor; -void NamedWindow::Init(Handle target) { +void NamedWindow::Init(Local target) { Nan::HandleScope scope; // Constructor diff --git a/src/HighGUI.h b/src/HighGUI.h index 9b7019a..d47bc4b 100644 --- a/src/HighGUI.h +++ b/src/HighGUI.h @@ -6,7 +6,7 @@ public: int flags; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); NamedWindow(const std::string& winname, int flags); diff --git a/src/ImgProc.cc b/src/ImgProc.cc index b84e20a..719fd8b 100644 --- a/src/ImgProc.cc +++ b/src/ImgProc.cc @@ -1,7 +1,7 @@ #include "ImgProc.h" #include "Matrix.h" -void ImgProc::Init(Handle target) { +void ImgProc::Init(Local target) { Nan::Persistent inner; Local obj = Nan::New(); inner.Reset(obj); diff --git a/src/ImgProc.h b/src/ImgProc.h index a73220a..a1ef503 100644 --- a/src/ImgProc.h +++ b/src/ImgProc.h @@ -8,7 +8,7 @@ */ class ImgProc: public Nan::ObjectWrap { public: - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(Undistort); static NAN_METHOD(InitUndistortRectifyMap); static NAN_METHOD(Remap); diff --git a/src/Matrix.cc b/src/Matrix.cc index 0be152a..1396781 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -9,7 +9,7 @@ cv::Scalar setColor(Local objColor); cv::Point setPoint(Local objPoint); cv::Rect* setRect(Local objRect, cv::Rect &result); -void Matrix::Init(Handle target) { +void Matrix::Init(Local target) { Nan::HandleScope scope; //Class @@ -312,7 +312,7 @@ NAN_METHOD(Matrix::GetData) { v8::Local globalObj = Nan::GetCurrentContext()->Global(); v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); - v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned) size), Nan::New(0)}; + v8::Local constructorArgs[3] = {buf, Nan::New((unsigned) size), Nan::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); info.GetReturnValue().Set(actualBuffer); @@ -566,7 +566,7 @@ NAN_METHOD(Matrix::ToBuffer) { // See if the options argument is passed if ((info.Length() > 0) && (info[0]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); + v8::Handle < v8::Object > options = v8::Local::Cast(info[0]); // If the extension (image format) is provided if (options->Has(Nan::New("ext").ToLocalChecked())) { v8::String::Utf8Value str( @@ -600,7 +600,7 @@ NAN_METHOD(Matrix::ToBuffer) { v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global(); v8::Local < v8::Function > bufferConstructor = v8::Local < v8::Function > ::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); - v8::Handle constructorArgs[3] = + v8::Local constructorArgs[3] = {buf, Nan::New((unsigned)vec.size()), Nan::New(0)}; v8::Local < v8::Object > actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); @@ -637,7 +637,7 @@ public: v8::Local globalObj = Nan::GetCurrentContext()->Global(); v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(Nan::New("Buffer").ToLocalChecked())); - v8::Handle constructorArgs[3] = {buf, Nan::New((unsigned)res.size()), Nan::New(0)}; + v8::Local constructorArgs[3] = {buf, Nan::New((unsigned)res.size()), Nan::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); Local argv[] = { @@ -671,7 +671,7 @@ NAN_METHOD(Matrix::ToBufferAsync) { // See if the options argument is passed if ((info.Length() > 1) && (info[1]->IsObject())) { // Get this options argument - v8::Handle < v8::Object > options = v8::Handle::Cast(info[1]); + v8::Handle < v8::Object > options = v8::Local::Cast(info[1]); // If the extension (image format) is provided if (options->Has(Nan::New("ext").ToLocalChecked())) { v8::String::Utf8Value str( @@ -715,7 +715,7 @@ NAN_METHOD(Matrix::Ellipse) { int shift = 0; if (info[0]->IsObject()) { - v8::Handle < v8::Object > options = v8::Handle::Cast(info[0]); + v8::Handle < v8::Object > options = v8::Local::Cast(info[0]); if (options->Has(Nan::New("center").ToLocalChecked())) { Local < Object > center = options->Get(Nan::New("center").ToLocalChecked())->ToObject(); @@ -1818,7 +1818,7 @@ NAN_METHOD(Matrix::Merge) { if (!info[0]->IsArray()) { Nan::ThrowTypeError("The argument must be an array"); } - v8::Handle jsChannels = v8::Handle::Cast(info[0]); + v8::Local jsChannels = v8::Local::Cast(info[0]); unsigned int L = jsChannels->Length(); vector vChannels(L); diff --git a/src/Matrix.h b/src/Matrix.h index 3c87b38..826b12e 100755 --- a/src/Matrix.h +++ b/src/Matrix.h @@ -5,7 +5,7 @@ public: cv::Mat mat; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); Matrix(); Matrix(cv::Mat other, cv::Rect roi); diff --git a/src/OpenCV.cc b/src/OpenCV.cc index 8365138..20692df 100755 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -2,7 +2,7 @@ #include "Matrix.h" #include -void OpenCV::Init(Handle target) { +void OpenCV::Init(Local target) { Nan::HandleScope scope; // Version string. diff --git a/src/OpenCV.h b/src/OpenCV.h index 6e368ae..0d8eb90 100755 --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -44,7 +44,7 @@ using namespace node; class OpenCV: public Nan::ObjectWrap { public: - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(ReadImage); }; diff --git a/src/Point.cc b/src/Point.cc index 060029d..d1ce841 100755 --- a/src/Point.cc +++ b/src/Point.cc @@ -3,7 +3,7 @@ Nan::Persistent Point::constructor; -void Point::Init(Handle target) { +void Point::Init(Local target) { Nan::HandleScope scope; // Constructor diff --git a/src/Point.h b/src/Point.h index d72bf60..3a5dc06 100755 --- a/src/Point.h +++ b/src/Point.h @@ -6,7 +6,7 @@ class Point: public Nan::ObjectWrap { public: CvPoint2D32f point; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); Point(double x, double y); diff --git a/src/Stereo.cc b/src/Stereo.cc index b5f83f5..f8d1c11 100644 --- a/src/Stereo.cc +++ b/src/Stereo.cc @@ -6,7 +6,7 @@ Nan::Persistent StereoBM::constructor; -void StereoBM::Init(Handle target) { +void StereoBM::Init(Local target) { Nan::HandleScope scope; Local ctor = Nan::New(StereoBM::New); @@ -98,7 +98,7 @@ NAN_METHOD(StereoBM::Compute) { // Semi-Global Block matching Nan::Persistent StereoSGBM::constructor; -void StereoSGBM::Init(Handle target) { +void StereoSGBM::Init(Local target) { Nan::HandleScope scope; Local ctor = Nan::New(StereoSGBM::New); @@ -233,7 +233,7 @@ NAN_METHOD(StereoSGBM::Compute) { Nan::Persistent StereoGC::constructor; -void StereoGC::Init(Handle target) { +void StereoGC::Init(Local target) { Nan::HandleScope scope; Local ctor = Nan::New(StereoGC::New); diff --git a/src/Stereo.h b/src/Stereo.h index a26a8f8..fbbdb58 100644 --- a/src/Stereo.h +++ b/src/Stereo.h @@ -8,7 +8,7 @@ public: cv::StereoBM stereo; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); StereoBM(int preset = cv::StereoBM::BASIC_PRESET, int ndisparities = 0, @@ -23,7 +23,7 @@ public: cv::StereoSGBM stereo; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); StereoSGBM(); @@ -42,7 +42,7 @@ public: CvStereoGCState *stereo; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); StereoGC(int numberOfDisparities = 16, int maxIterations = 2); diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index ca6da1c..cb4fcfd 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -16,7 +16,7 @@ struct videocapture_baton { uv_work_t request; }; -void VideoCaptureWrap::Init(Handle target) { +void VideoCaptureWrap::Init(Local target) { Nan::HandleScope scope; //Class diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h index a9b3b03..3cb5a04 100755 --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -5,7 +5,7 @@ public: cv::VideoCapture cap; static Nan::Persistent constructor; - static void Init(Handle target); + static void Init(Local target); static NAN_METHOD(New); VideoCaptureWrap(const std::string& filename); diff --git a/src/init.cc b/src/init.cc index 9e1b2fc..44a7c3b 100755 --- a/src/init.cc +++ b/src/init.cc @@ -15,7 +15,7 @@ #include "Stereo.h" #include "BackgroundSubtractor.h" -extern "C" void init(Handle target) { +extern "C" void init(Local target) { Nan::HandleScope scope; OpenCV::Init(target); From 420cd12c60c4ee9f2359f3a054827f4fdd9474f6 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Mon, 5 Oct 2015 17:57:13 -0500 Subject: [PATCH 8/9] clean up vagrant folder --- vagrant/scripts/setup-node.sh | 11 +++++++++-- vagrant/setup.sh | 7 ------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/vagrant/scripts/setup-node.sh b/vagrant/scripts/setup-node.sh index de3bbb2..149aa0b 100755 --- a/vagrant/scripts/setup-node.sh +++ b/vagrant/scripts/setup-node.sh @@ -1,6 +1,13 @@ apt-get install gcc make build-essential -y apt-get install -y curl apt-get install -y git -curl --silent --location https://deb.nodesource.com/setup_4.x | sudo bash - -apt-get install -y nodejs +# curl --silent --location https://deb.nodesource.com/setup_4.x | sudo bash - +# apt-get install -y nodejs +su vagrant +wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.27.1/install.sh | bash +nvm install v0.10 +nvm install v0.12 +nvm install v4.1 + + diff --git a/vagrant/setup.sh b/vagrant/setup.sh index e51e282..1915326 100755 --- a/vagrant/setup.sh +++ b/vagrant/setup.sh @@ -9,13 +9,6 @@ $include "/vagrant/scripts/base.sh" #COMMENT OUT OR IN LINES AS APPROPRIATE INCLUDED_TECH=() INCLUDED_TECH+=("node") -#INCLUDED_TECH+=("mongodb") -#INCLUDED_TECH+=("meteor") -#INCLUDED_TECH+=("redis") -#INCLUDED_TECH+=("apache") -#INCLUDED_TECH+=("nginx") -#INCLUDED_TECH+=("mysql") -#INCLUDED_TECH+=("php") SCRIPT_LOCATION="/vagrant/scripts/setup-" From 8b3e747c35ecaaece432aa542b8e56047fa1e387 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Tue, 6 Oct 2015 12:46:44 -0500 Subject: [PATCH 9/9] Eliminated deprecation warnings while building in Node v4.1.2 --- src/BackgroundSubtractor.cc | 4 ++-- src/CascadeClassifierWrap.cc | 4 ++-- src/Matrix.cc | 8 ++++---- src/OpenCV.cc | 4 ++-- src/VideoCaptureWrap.cc | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index 69b703d..fdbbaed 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -104,11 +104,11 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { argv[0] = Nan::Null(); argv[1] = fgMask; - TryCatch try_catch; + Nan::TryCatch try_catch; cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { - FatalException(try_catch); + Nan::FatalException(try_catch); } return; } catch (cv::Exception& e) { diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index 9642722..b8c5a49 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -97,10 +97,10 @@ public: argv[0] = Nan::Null(); argv[1] = arr; - TryCatch try_catch; + Nan::TryCatch try_catch; callback->Call(2, argv); if (try_catch.HasCaught()) { - FatalException(try_catch); + Nan::FatalException(try_catch); } } diff --git a/src/Matrix.cc b/src/Matrix.cc index 1396781..fb6a145 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -645,10 +645,10 @@ public: actualBuffer }; - TryCatch try_catch; + Nan::TryCatch try_catch; callback->Call(2, argv); if (try_catch.HasCaught()) { - FatalException(try_catch); + Nan::FatalException(try_catch); } } @@ -915,10 +915,10 @@ public: Nan::New(res) }; - TryCatch try_catch; + Nan::TryCatch try_catch; callback->Call(2, argv); if (try_catch.HasCaught()) { - FatalException(try_catch); + Nan::FatalException(try_catch); } } diff --git a/src/OpenCV.cc b/src/OpenCV.cc index 20692df..62007a4 100755 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -57,11 +57,11 @@ NAN_METHOD(OpenCV::ReadImage) { argv[1] = Nan::Null(); } - TryCatch try_catch; + Nan::TryCatch try_catch; cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { - FatalException(try_catch); + Nan::FatalException(try_catch); } return; diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index cb4fcfd..8bfc453 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -172,10 +172,10 @@ public: , im_to_return }; - TryCatch try_catch; + Nan::TryCatch try_catch; callback->Call(2, argv); if (try_catch.HasCaught()) { - FatalException(try_catch); + Nan::FatalException(try_catch); } }