From 1974fd6d00a2954edcefa1978bfbd20600b64a56 Mon Sep 17 00:00:00 2001 From: Keegan Brown Date: Thu, 1 Oct 2015 11:03:08 -0500 Subject: [PATCH] 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