archive-gh-me/node-opencv
1
0
Fork 0
mirror of https://github.com/peterbraden/node-opencv.git synced 2025-12-08 19:45:55 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #309 from keeganbrown/master

Browse Source 
Attempt to upgrade to NAN2
This commit is contained in:
Peter Braden 2015-10-07 16:02:14 +02:00
commit e7cf37b9cc
38 changed files with 7047 additions and 1619 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -7,3 +7,4 @@ out*.jpg
out*.png out*.png
examples/*.avi examples/*.avi
examples/tmp/* examples/tmp/*
vagrant/.vagrant

6
package.json
View File

@ -3,9 +3,9 @@
"description": "Node Bindings to OpenCV", "description": "Node Bindings to OpenCV",
"author": "Peter Braden <peterbraden@peterbraden.co.uk>", "author": "Peter Braden <peterbraden@peterbraden.co.uk>",
"dependencies": { "dependencies": {
"buffers": "0.1.1", "buffers": "^0.1.1",
"nan": "^1.7.0", "nan": "^2.0.9",
"node-pre-gyp": "^0.6.4" "node-pre-gyp": "^0.6.11"
}, },
"version": "3.2.0", "version": "3.2.0",
"devDependencies": { "devDependencies": {

72
src/BackgroundSubtractor.cc
View File

@ -5,60 +5,60 @@
#if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4))
Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor; Nan::Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor;
void BackgroundSubtractorWrap::Init(Handle<Object> target) { void BackgroundSubtractorWrap::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Constructor // Constructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(BackgroundSubtractorWrap::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(BackgroundSubtractorWrap::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("BackgroundSubtractor")); ctor->SetClassName(Nan::New("BackgroundSubtractor").ToLocalChecked());
NODE_SET_METHOD(ctor, "createMOG", CreateMOG); Nan::SetMethod(ctor, "createMOG", CreateMOG);
NODE_SET_PROTOTYPE_METHOD(ctor, "applyMOG", ApplyMOG); Nan::SetPrototypeMethod(ctor, "applyMOG", ApplyMOG);
target->Set(NanNew("BackgroundSubtractor"), ctor->GetFunction()); target->Set(Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(BackgroundSubtractorWrap::New) { NAN_METHOD(BackgroundSubtractorWrap::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
JSTHROW_TYPE("Cannot Instantiate without new") JSTHROW_TYPE("Cannot Instantiate without new")
} }
// Create MOG by default // Create MOG by default
cv::Ptr<cv::BackgroundSubtractor> bg; cv::Ptr<cv::BackgroundSubtractor> bg;
BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg);
pt->Wrap(args.This()); pt->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) { NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) {
NanScope(); Nan::HandleScope scope;
// int history = 200; // int history = 200;
// int nmixtures = 5; // int nmixtures = 5;
// double backgroundRatio = 0.7; // double backgroundRatio = 0.7;
// double noiseSigma = 0; // double noiseSigma = 0;
// //
// if(args.Length() > 1){ // if(info.Length() > 1){
// INT_FROM_ARGS(history, 0) // INT_FROM_ARGS(history, 0)
// INT_FROM_ARGS(nmixtures, 1) // INT_FROM_ARGS(nmixtures, 1)
// DOUBLE_FROM_ARGS(backgroundRatio, 2) // DOUBLE_FROM_ARGS(backgroundRatio, 2)
// DOUBLE_FROM_ARGS(noiseSigma, 3) // DOUBLE_FROM_ARGS(noiseSigma, 3)
// } // }
Local<Object> n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = Nan::New(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::BackgroundSubtractor> bg; cv::Ptr<cv::BackgroundSubtractor> bg;
BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg);
pt->Wrap(n); pt->Wrap(n);
NanReturnValue( n ); info.GetReturnValue().Set( n );
} }
// Fetch foreground mask // Fetch foreground mask
@ -67,32 +67,32 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) {
REQ_FUN_ARG(1, cb); REQ_FUN_ARG(1, cb);
Local<Value> argv[2]; Local<Value> argv[2];
if (args.Length() == 0) { if (info.Length() == 0) {
argv[0] = NanNew("Input image missing"); argv[0] = Nan::New("Input image missing").ToLocalChecked();
argv[1] = NanNull(); argv[1] = Nan::Null();
cb->Call(NanGetCurrentContext()->Global(), 2, argv); cb->Call(Nan::GetCurrentContext()->Global(), 2, argv);
NanReturnUndefined(); return;
} }
try { try {
Local<Object> fgMask = Local<Object> fgMask =
NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(fgMask); Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(fgMask);
cv::Mat mat; cv::Mat mat;
if (Buffer::HasInstance(args[0])) { if (Buffer::HasInstance(info[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject()); uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject());
unsigned len = Buffer::Length(args[0]->ToObject()); unsigned len = Buffer::Length(info[0]->ToObject());
cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf);
mat = cv::imdecode(*mbuf, -1); mat = cv::imdecode(*mbuf, -1);
//mbuf->release(); //mbuf->release();
} else { } else {
Matrix *_img = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix *_img = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
mat = (_img->mat).clone(); mat = (_img->mat).clone();
} }
if (mat.empty()) { if (mat.empty()) {
return NanThrowTypeError("Error loading file"); return Nan::ThrowTypeError("Error loading file");
} }
cv::Mat _fgMask; cv::Mat _fgMask;
@ -101,20 +101,20 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) {
img->mat = _fgMask; img->mat = _fgMask;
mat.release(); mat.release();
argv[0] = NanNull(); argv[0] = Nan::Null();
argv[1] = fgMask; argv[1] = fgMask;
TryCatch try_catch; Nan::TryCatch try_catch;
cb->Call(NanGetCurrentContext()->Global(), 2, argv); cb->Call(Nan::GetCurrentContext()->Global(), 2, argv);
if (try_catch.HasCaught()) { if (try_catch.HasCaught()) {
FatalException(try_catch); Nan::FatalException(try_catch);
} }
NanReturnUndefined(); return;
} catch (cv::Exception& e) { } catch (cv::Exception& e) {
const char* err_msg = e.what(); const char* err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }

6
src/BackgroundSubtractor.h
View File

@ -4,12 +4,12 @@
#include <opencv2/video/background_segm.hpp> #include <opencv2/video/background_segm.hpp>
class BackgroundSubtractorWrap: public node::ObjectWrap { class BackgroundSubtractorWrap: public Nan::ObjectWrap {
public: public:
cv::Ptr<cv::BackgroundSubtractor> subtractor; cv::Ptr<cv::BackgroundSubtractor> subtractor;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
BackgroundSubtractorWrap(cv::Ptr<cv::BackgroundSubtractor> bg); BackgroundSubtractorWrap(cv::Ptr<cv::BackgroundSubtractor> bg);

278
src/Calib3D.cc
View File

@ -3,19 +3,19 @@
inline Local<Object> matrixFromMat(cv::Mat &input) { inline Local<Object> matrixFromMat(cv::Mat &input) {
Local<Object> matrixWrap = Local<Object> matrixWrap =
NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *matrix = ObjectWrap::Unwrap<Matrix>(matrixWrap); Matrix *matrix = Nan::ObjectWrap::Unwrap<Matrix>(matrixWrap);
matrix->mat = input; matrix->mat = input;
return matrixWrap; return matrixWrap;
} }
inline cv::Mat matFromMatrix(Handle<Value> matrix) { inline cv::Mat matFromMatrix(Local<Value> matrix) {
Matrix* m = ObjectWrap::Unwrap<Matrix>(matrix->ToObject()); Matrix* m = Nan::ObjectWrap::Unwrap<Matrix>(matrix->ToObject());
return m->mat; return m->mat;
} }
inline cv::Size sizeFromArray(Handle<Value> jsArray) { inline cv::Size sizeFromArray(Local<Value> jsArray) {
cv::Size patternSize; cv::Size patternSize;
if (jsArray->IsArray()) { if (jsArray->IsArray()) {
@ -30,7 +30,7 @@ inline cv::Size sizeFromArray(Handle<Value> jsArray) {
return patternSize; return patternSize;
} }
inline std::vector<cv::Point2f> points2fFromArray(Handle<Value> array) { inline std::vector<cv::Point2f> points2fFromArray(Local<Value> array) {
std::vector<cv::Point2f> points; std::vector<cv::Point2f> points;
if (array->IsArray()) { if (array->IsArray()) {
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject()); Local<Array> pointsArray = Local<Array>::Cast(array->ToObject());
@ -38,8 +38,8 @@ inline std::vector<cv::Point2f> points2fFromArray(Handle<Value> array) {
for (unsigned int i = 0; i < pointsArray->Length(); i++) { for (unsigned int i = 0; i < pointsArray->Length(); i++) {
Local<Object> pt = pointsArray->Get(i)->ToObject(); Local<Object> pt = pointsArray->Get(i)->ToObject();
points.push_back( points.push_back(
cv::Point2f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(), cv::Point2f(pt->Get(Nan::New<String>("x").ToLocalChecked())->ToNumber()->Value(),
pt->Get(NanNew<String>("y"))->ToNumber()->Value())); pt->Get(Nan::New<String>("y").ToLocalChecked())->ToNumber()->Value()));
} }
} else { } else {
JSTHROW_TYPE("Points not a valid array"); JSTHROW_TYPE("Points not a valid array");
@ -48,7 +48,7 @@ inline std::vector<cv::Point2f> points2fFromArray(Handle<Value> array) {
return points; return points;
} }
inline std::vector<cv::Point3f> points3fFromArray(Handle<Value> array) { inline std::vector<cv::Point3f> points3fFromArray(Local<Value> array) {
std::vector<cv::Point3f> points; std::vector<cv::Point3f> points;
if (array->IsArray()) { if (array->IsArray()) {
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject()); Local<Array> pointsArray = Local<Array>::Cast(array->ToObject());
@ -56,9 +56,9 @@ inline std::vector<cv::Point3f> points3fFromArray(Handle<Value> array) {
for (unsigned int i = 0; i < pointsArray->Length(); i++) { for (unsigned int i = 0; i < pointsArray->Length(); i++) {
Local<Object> pt = pointsArray->Get(i)->ToObject(); Local<Object> pt = pointsArray->Get(i)->ToObject();
points.push_back( points.push_back(
cv::Point3f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(), cv::Point3f(pt->Get(Nan::New<String>("x").ToLocalChecked())->ToNumber()->Value(),
pt->Get(NanNew<String>("y"))->ToNumber()->Value(), pt->Get(Nan::New<String>("y").ToLocalChecked())->ToNumber()->Value(),
pt->Get(NanNew<String>("z"))->ToNumber()->Value())); pt->Get(Nan::New<String>("z").ToLocalChecked())->ToNumber()->Value()));
} }
} else { } else {
JSTHROW_TYPE("Must pass array of object points for each frame") JSTHROW_TYPE("Must pass array of object points for each frame")
@ -68,7 +68,7 @@ inline std::vector<cv::Point3f> points3fFromArray(Handle<Value> array) {
} }
inline std::vector<std::vector<cv::Point2f> > points2fFromArrayOfArrays( inline std::vector<std::vector<cv::Point2f> > points2fFromArrayOfArrays(
Handle<Value> array) { Local<Value> array) {
std::vector<std::vector<cv::Point2f> > points; std::vector<std::vector<cv::Point2f> > points;
if (array->IsArray()) { if (array->IsArray()) {
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject()); Local<Array> pointsArray = Local<Array>::Cast(array->ToObject());
@ -84,7 +84,7 @@ inline std::vector<std::vector<cv::Point2f> > points2fFromArrayOfArrays(
} }
inline std::vector<std::vector<cv::Point3f> > points3fFromArrayOfArrays( inline std::vector<std::vector<cv::Point3f> > points3fFromArrayOfArrays(
Handle<Value> array) { Local<Value> array) {
std::vector<std::vector<cv::Point3f> > points; std::vector<std::vector<cv::Point3f> > points;
if (array->IsArray()) { if (array->IsArray()) {
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject()); Local<Array> pointsArray = Local<Array>::Cast(array->ToObject());
@ -99,36 +99,36 @@ inline std::vector<std::vector<cv::Point3f> > points3fFromArrayOfArrays(
return points; return points;
} }
void Calib3D::Init(Handle<Object> target) { void Calib3D::Init(Local<Object> target) {
Persistent<Object> inner; Nan::Persistent<Object> inner;
Local<Object> obj = NanNew<Object>(); Local<Object> obj = Nan::New<Object>();
NanAssignPersistent(inner, obj); inner.Reset(obj);
NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners); Nan::SetMethod(obj, "findChessboardCorners", FindChessboardCorners);
NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners); Nan::SetMethod(obj, "drawChessboardCorners", DrawChessboardCorners);
NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera); Nan::SetMethod(obj, "calibrateCamera", CalibrateCamera);
NODE_SET_METHOD(obj, "solvePnP", SolvePnP); Nan::SetMethod(obj, "solvePnP", SolvePnP);
NODE_SET_METHOD(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix); Nan::SetMethod(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix);
NODE_SET_METHOD(obj, "stereoCalibrate", StereoCalibrate); Nan::SetMethod(obj, "stereoCalibrate", StereoCalibrate);
NODE_SET_METHOD(obj, "stereoRectify", StereoRectify); Nan::SetMethod(obj, "stereoRectify", StereoRectify);
NODE_SET_METHOD(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines); Nan::SetMethod(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines);
NODE_SET_METHOD(obj, "reprojectImageTo3d", ReprojectImageTo3D); Nan::SetMethod(obj, "reprojectImageTo3d", ReprojectImageTo3D);
target->Set(NanNew("calib3d"), obj); target->Set(Nan::New("calib3d").ToLocalChecked(), obj);
} }
// cv::findChessboardCorners // cv::findChessboardCorners
NAN_METHOD(Calib3D::FindChessboardCorners) { NAN_METHOD(Calib3D::FindChessboardCorners) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments from javascript // Get the arguments from javascript
// Arg 0 is the image // Arg 0 is the image
cv::Mat mat = matFromMatrix(args[0]); cv::Mat mat = matFromMatrix(info[0]);
// Arg 1 is the pattern size // Arg 1 is the pattern size
cv::Size patternSize = sizeFromArray(args[1]); cv::Size patternSize = sizeFromArray(info[1]);
// Arg 2 would normally be the flags, ignoring this for now and using the // Arg 2 would normally be the flags, ignoring this for now and using the
// default flags // default flags
@ -138,77 +138,77 @@ NAN_METHOD(Calib3D::FindChessboardCorners) {
bool found = cv::findChessboardCorners(mat, patternSize, corners); bool found = cv::findChessboardCorners(mat, patternSize, corners);
// Make the return value // Make the return value
Local<Object> ret = NanNew<Object>(); Local<Object> ret = Nan::New<Object>();
ret->Set(NanNew<String>("found"), NanNew<Boolean>(found)); ret->Set(Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found));
Local<Array> cornersArray = NanNew<Array>(corners.size()); Local<Array> cornersArray = Nan::New<Array>(corners.size());
for (unsigned int i = 0; i < corners.size(); i++) { for (unsigned int i = 0; i < corners.size(); i++) {
Local<Object> point_data = NanNew<Object>(); Local<Object> point_data = Nan::New<Object>();
point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x)); point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x));
point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y)); point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y));
cornersArray->Set(NanNew<Number>(i), point_data); cornersArray->Set(Nan::New<Number>(i), point_data);
} }
ret->Set(NanNew<String>("corners"), cornersArray); ret->Set(Nan::New<String>("corners").ToLocalChecked(), cornersArray);
NanReturnValue(ret); info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::drawChessboardCorners // cv::drawChessboardCorners
NAN_METHOD(Calib3D::DrawChessboardCorners) { NAN_METHOD(Calib3D::DrawChessboardCorners) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the image // Arg 0 is the image
cv::Mat mat = matFromMatrix(args[0]); cv::Mat mat = matFromMatrix(info[0]);
// Arg 1 is the pattern size // Arg 1 is the pattern size
cv::Size patternSize = sizeFromArray(args[1]); cv::Size patternSize = sizeFromArray(info[1]);
// Arg 2 is the corners array // Arg 2 is the corners array
std::vector<cv::Point2f> corners = points2fFromArray(args[2]); std::vector<cv::Point2f> corners = points2fFromArray(info[2]);
// Arg 3, pattern found boolean // Arg 3, pattern found boolean
bool patternWasFound = args[3]->ToBoolean()->Value(); bool patternWasFound = info[3]->ToBoolean()->Value();
// Draw the corners // Draw the corners
cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound); cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound);
// Return the passed image, now with corners drawn on it // Return the passed image, now with corners drawn on it
NanReturnValue(args[0]); info.GetReturnValue().Set(info[0]);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::calibrateCamera // cv::calibrateCamera
NAN_METHOD(Calib3D::CalibrateCamera) { NAN_METHOD(Calib3D::CalibrateCamera) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0, the array of object points, an array of arrays // Arg 0, the array of object points, an array of arrays
std::vector<std::vector<cv::Point3f> > objectPoints = std::vector<std::vector<cv::Point3f> > objectPoints =
points3fFromArrayOfArrays(args[0]); points3fFromArrayOfArrays(info[0]);
// Arg 1, the image points, another array of arrays // Arg 1, the image points, another array of arrays
std::vector<std::vector<cv::Point2f> > imagePoints = std::vector<std::vector<cv::Point2f> > imagePoints =
points2fFromArrayOfArrays(args[1]); points2fFromArrayOfArrays(info[1]);
// Arg 2, the image size // Arg 2, the image size
cv::Size imageSize = sizeFromArray(args[2]); cv::Size imageSize = sizeFromArray(info[2]);
// Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, // Arg 3, 4, input guesses for the camrea matrix and distortion coefficients,
// skipping for now // skipping for now
@ -223,48 +223,48 @@ NAN_METHOD(Calib3D::CalibrateCamera) {
dist, rvecs, tvecs); dist, rvecs, tvecs);
// make the return values // make the return values
Local<Object> ret = NanNew<Object>(); Local<Object> ret = Nan::New<Object>();
// Reprojection error // Reprojection error
ret->Set(NanNew<String>("reprojectionError"), NanNew<Number>(error)); ret->Set(Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error));
// K // K
Local<Object> KMatrixWrap = matrixFromMat(K); Local<Object> KMatrixWrap = matrixFromMat(K);
ret->Set(NanNew<String>("K"), KMatrixWrap); ret->Set(Nan::New<String>("K").ToLocalChecked(), KMatrixWrap);
// dist // dist
Local<Object> distMatrixWrap = matrixFromMat(dist); Local<Object> distMatrixWrap = matrixFromMat(dist);
ret->Set(NanNew<String>("distortion"), distMatrixWrap); ret->Set(Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap);
// Per frame R and t, skiping for now // Per frame R and t, skiping for now
// Return // Return
NanReturnValue(ret); info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::solvePnP // cv::solvePnP
NAN_METHOD(Calib3D::SolvePnP) { NAN_METHOD(Calib3D::SolvePnP) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0, the array of object points // Arg 0, the array of object points
std::vector<cv::Point3f> objectPoints = points3fFromArray(args[0]); std::vector<cv::Point3f> objectPoints = points3fFromArray(info[0]);
// Arg 1, the image points // Arg 1, the image points
std::vector<cv::Point2f> imagePoints = points2fFromArray(args[1]); std::vector<cv::Point2f> imagePoints = points2fFromArray(info[1]);
// Arg 2, the camera matrix // Arg 2, the camera matrix
cv::Mat K = matFromMatrix(args[2]); cv::Mat K = matFromMatrix(info[2]);
// Arg 3, the distortion coefficients // Arg 3, the distortion coefficients
cv::Mat dist = matFromMatrix(args[3]); cv::Mat dist = matFromMatrix(info[3]);
// Arg 4, use extrinsic guess, skipped for now // Arg 4, use extrinsic guess, skipped for now
@ -276,47 +276,47 @@ NAN_METHOD(Calib3D::SolvePnP) {
cv::solvePnP(objectPoints, imagePoints, K, dist, rvec, tvec); cv::solvePnP(objectPoints, imagePoints, K, dist, rvec, tvec);
// make the return values // make the return values
Local<Object> ret = NanNew<Object>(); Local<Object> ret = Nan::New<Object>();
// rvec // rvec
Local<Object> rMatrixWrap = matrixFromMat(rvec); Local<Object> rMatrixWrap = matrixFromMat(rvec);
ret->Set(NanNew<String>("rvec"), rMatrixWrap); ret->Set(Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap);
// tvec // tvec
Local<Object> tMatrixWrap = matrixFromMat(tvec); Local<Object> tMatrixWrap = matrixFromMat(tvec);
ret->Set(NanNew<String>("tvec"), tMatrixWrap); ret->Set(Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap);
// Return // Return
NanReturnValue(ret); info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::getOptimalNewCameraMAtrix // cv::getOptimalNewCameraMAtrix
NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the original camera matrix // Arg 0 is the original camera matrix
cv::Mat Kin = matFromMatrix(args[0]); cv::Mat Kin = matFromMatrix(info[0]);
// Arg 1 is the distortion coefficients // Arg 1 is the distortion coefficients
cv::Mat dist = matFromMatrix(args[1]); cv::Mat dist = matFromMatrix(info[1]);
// Arg 2, the image size // Arg 2, the image size
cv::Size imageSize = sizeFromArray(args[2]); cv::Size imageSize = sizeFromArray(info[2]);
// Arg 3 is the alpha free scaling parameter // Arg 3 is the alpha free scaling parameter
double alpha = args[3]->ToNumber()->Value(); double alpha = info[3]->ToNumber()->Value();
// Arg 4, the new image size // Arg 4, the new image size
cv::Size newImageSize = sizeFromArray(args[4]); cv::Size newImageSize = sizeFromArray(info[4]);
// Arg 5, valid ROI, skip for now // Arg 5, valid ROI, skip for now
// Arg 6, center principal point, skip for now // Arg 6, center principal point, skip for now
@ -329,46 +329,46 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) {
Local<Object> KMatrixWrap = matrixFromMat(Kout); Local<Object> KMatrixWrap = matrixFromMat(Kout);
// Return the new K matrix // Return the new K matrix
NanReturnValue(KMatrixWrap); info.GetReturnValue().Set(KMatrixWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::stereoCalibrate // cv::stereoCalibrate
NAN_METHOD(Calib3D::StereoCalibrate) { NAN_METHOD(Calib3D::StereoCalibrate) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0, the array of object points, an array of arrays // Arg 0, the array of object points, an array of arrays
std::vector<std::vector<cv::Point3f> > objectPoints = std::vector<std::vector<cv::Point3f> > objectPoints =
points3fFromArrayOfArrays(args[0]); points3fFromArrayOfArrays(info[0]);
// Arg 1, the image points1, another array of arrays // Arg 1, the image points1, another array of arrays
std::vector<std::vector<cv::Point2f> > imagePoints1 = std::vector<std::vector<cv::Point2f> > imagePoints1 =
points2fFromArrayOfArrays(args[1]); points2fFromArrayOfArrays(info[1]);
// Arg 2, the image points2, another array of arrays =( // Arg 2, the image points2, another array of arrays =(
std::vector<std::vector<cv::Point2f> > imagePoints2 = std::vector<std::vector<cv::Point2f> > imagePoints2 =
points2fFromArrayOfArrays(args[2]); points2fFromArrayOfArrays(info[2]);
// Arg 3 is the image size (follows the PYTHON api not the C++ api since all // Arg 3 is the image size (follows the PYTHON api not the C++ api since all
// following arguments are optional or outputs) // following arguments are optional or outputs)
cv::Size imageSize = sizeFromArray(args[3]); cv::Size imageSize = sizeFromArray(info[3]);
// Arg 4,5,6,7 is the camera matrix and distortion coefficients // Arg 4,5,6,7 is the camera matrix and distortion coefficients
// (optional but must pass all 4 or none) // (optional but must pass all 4 or none)
cv::Mat k1, d1, k2, d2; cv::Mat k1, d1, k2, d2;
if (args.Length() >= 8) { if (info.Length() >= 8) {
k1 = matFromMatrix(args[4]); k1 = matFromMatrix(info[4]);
d1 = matFromMatrix(args[5]); d1 = matFromMatrix(info[5]);
k2 = matFromMatrix(args[6]); k2 = matFromMatrix(info[6]);
d2 = matFromMatrix(args[7]); d2 = matFromMatrix(info[7]);
} }
// Last argument is flags, skipping for now // Last argument is flags, skipping for now
@ -381,7 +381,7 @@ NAN_METHOD(Calib3D::StereoCalibrate) {
d2, imageSize, R, t, E, F); d2, imageSize, R, t, E, F);
// make the return value // make the return value
Local<Object> ret = NanNew<Object>(); Local<Object> ret = Nan::New<Object>();
// Make the output arguments // Make the output arguments
@ -410,51 +410,51 @@ NAN_METHOD(Calib3D::StereoCalibrate) {
Local<Object> FMatrixWrap = matrixFromMat(F); Local<Object> FMatrixWrap = matrixFromMat(F);
// Add to return object // Add to return object
ret->Set(NanNew<String>("K1"), K1MatrixWrap); ret->Set(Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap);
ret->Set(NanNew<String>("distortion1"), d1MatrixWrap); ret->Set(Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap);
ret->Set(NanNew<String>("K2"), K2MatrixWrap); ret->Set(Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap);
ret->Set(NanNew<String>("distortion2"), d2MatrixWrap); ret->Set(Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap);
ret->Set(NanNew<String>("R"), RMatrixWrap); ret->Set(Nan::New<String>("R").ToLocalChecked(), RMatrixWrap);
ret->Set(NanNew<String>("t"), tMatrixWrap); ret->Set(Nan::New<String>("t").ToLocalChecked(), tMatrixWrap);
ret->Set(NanNew<String>("E"), EMatrixWrap); ret->Set(Nan::New<String>("E").ToLocalChecked(), EMatrixWrap);
ret->Set(NanNew<String>("F"), FMatrixWrap); ret->Set(Nan::New<String>("F").ToLocalChecked(), FMatrixWrap);
// Return // Return
NanReturnValue(ret); info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::stereoRectify // cv::stereoRectify
NAN_METHOD(Calib3D::StereoRectify) { NAN_METHOD(Calib3D::StereoRectify) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg0, the first camera matrix // Arg0, the first camera matrix
cv::Mat K1 = matFromMatrix(args[0]); cv::Mat K1 = matFromMatrix(info[0]);
// Arg1, the first distortion coefficients // Arg1, the first distortion coefficients
cv::Mat d1 = matFromMatrix(args[1]); cv::Mat d1 = matFromMatrix(info[1]);
// Arg2, the second camera matrix // Arg2, the second camera matrix
cv::Mat K2 = matFromMatrix(args[2]); cv::Mat K2 = matFromMatrix(info[2]);
// Arg3, the second distortion coefficients // Arg3, the second distortion coefficients
cv::Mat d2 = matFromMatrix(args[3]); cv::Mat d2 = matFromMatrix(info[3]);
// Arg4, the image size // Arg4, the image size
cv::Size imageSize = sizeFromArray(args[4]); cv::Size imageSize = sizeFromArray(info[4]);
// arg5, the intercamera rotation matrix // arg5, the intercamera rotation matrix
cv::Mat R = matFromMatrix(args[5]); cv::Mat R = matFromMatrix(info[5]);
// Arg6, the intercamera translation vector // Arg6, the intercamera translation vector
cv::Mat t = matFromMatrix(args[6]); cv::Mat t = matFromMatrix(info[6]);
// Arg8, flags, skipping for now // 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); cv::stereoRectify(K1, d1, K2, d2, imageSize, R, t, R1, R2, P1, P2, Q);
// Make the return object // Make the return object
Local<Object> ret = NanNew<Object>(); Local<Object> ret = Nan::New<Object>();
ret->Set(NanNew<String>("R1"), matrixFromMat(R1)); ret->Set(Nan::New<String>("R1").ToLocalChecked(), matrixFromMat(R1));
ret->Set(NanNew<String>("R2"), matrixFromMat(R2)); ret->Set(Nan::New<String>("R2").ToLocalChecked(), matrixFromMat(R2));
ret->Set(NanNew<String>("P1"), matrixFromMat(P1)); ret->Set(Nan::New<String>("P1").ToLocalChecked(), matrixFromMat(P1));
ret->Set(NanNew<String>("P2"), matrixFromMat(P2)); ret->Set(Nan::New<String>("P2").ToLocalChecked(), matrixFromMat(P2));
ret->Set(NanNew<String>("Q"), matrixFromMat(Q)); ret->Set(Nan::New<String>("Q").ToLocalChecked(), matrixFromMat(Q));
// Return the rectification parameters // Return the rectification parameters
NanReturnValue(ret); info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::computeCorrespondEpilines // cv::computeCorrespondEpilines
NAN_METHOD(Calib3D::ComputeCorrespondEpilines) { NAN_METHOD(Calib3D::ComputeCorrespondEpilines) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg0, the image points // Arg0, the image points
std::vector<cv::Point2f> points = points2fFromArray(args[0]); std::vector<cv::Point2f> points = points2fFromArray(info[0]);
// Arg1, the image index (1 or 2) // Arg1, the image index (1 or 2)
int whichImage = int(args[1]->ToNumber()->Value()); int whichImage = int(info[1]->ToNumber()->Value());
// Arg2, the fundamental matrix // Arg2, the fundamental matrix
cv::Mat F = matFromMatrix(args[2]); cv::Mat F = matFromMatrix(info[2]);
// compute the lines // compute the lines
std::vector<cv::Vec3f> lines; std::vector<cv::Vec3f> lines;
cv::computeCorrespondEpilines(points, whichImage, F, lines); cv::computeCorrespondEpilines(points, whichImage, F, lines);
// Convert the lines to an array of objects (ax + by + c = 0) // Convert the lines to an array of objects (ax + by + c = 0)
Local<Array> linesArray = NanNew<Array>(lines.size()); Local<Array> linesArray = Nan::New<Array>(lines.size());
for(unsigned int i = 0; i < lines.size(); i++) for(unsigned int i = 0; i < lines.size(); i++)
{ {
Local<Object> line_data = NanNew<Object>(); Local<Object> line_data = Nan::New<Object>();
line_data->Set(NanNew<String>("a"), NanNew<Number>(lines[i][0])); line_data->Set(Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0]));
line_data->Set(NanNew<String>("b"), NanNew<Number>(lines[i][1])); line_data->Set(Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1]));
line_data->Set(NanNew<String>("c"), NanNew<Number>(lines[i][2])); line_data->Set(Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2]));
linesArray->Set(NanNew<Number>(i), line_data); linesArray->Set(Nan::New<Number>(i), line_data);
} }
// Return the lines // Return the lines
NanReturnValue(linesArray); info.GetReturnValue().Set(linesArray);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::reprojectImageTo3D // cv::reprojectImageTo3D
NAN_METHOD(Calib3D::ReprojectImageTo3D) { NAN_METHOD(Calib3D::ReprojectImageTo3D) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg0, the disparity image // Arg0, the disparity image
cv::Mat disparity = matFromMatrix(args[0]); cv::Mat disparity = matFromMatrix(info[0]);
// Arg1, the depth-to-disparity transformation Q // Arg1, the depth-to-disparity transformation Q
cv::Mat Q = matFromMatrix(args[1]); cv::Mat Q = matFromMatrix(info[1]);
// Arg 2, handle missing values, skipped for now // Arg 2, handle missing values, skipped for now
@ -551,10 +551,10 @@ NAN_METHOD(Calib3D::ReprojectImageTo3D) {
// Wrap the depth image // Wrap the depth image
Local<Object> depthImageMatrix = matrixFromMat(depthImage); Local<Object> depthImageMatrix = matrixFromMat(depthImage);
NanReturnValue(depthImageMatrix); info.GetReturnValue().Set(depthImageMatrix);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }

4
src/Calib3D.h
View File

@ -6,9 +6,9 @@
/** /**
* Implementation of calib3d.hpp functions * Implementation of calib3d.hpp functions
*/ */
class Calib3D: public node::ObjectWrap { class Calib3D: public Nan::ObjectWrap {
public: public:
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(FindChessboardCorners); static NAN_METHOD(FindChessboardCorners);
static NAN_METHOD(DrawChessboardCorners); static NAN_METHOD(DrawChessboardCorners);
static NAN_METHOD(CalibrateCamera); static NAN_METHOD(CalibrateCamera);

64
src/CamShift.cc
View File

@ -8,38 +8,38 @@
#define CHANNEL_VALUE 2 #define CHANNEL_VALUE 2
Persistent<FunctionTemplate> TrackedObject::constructor; Nan::Persistent<FunctionTemplate> TrackedObject::constructor;
void TrackedObject::Init(Handle<Object> target) { void TrackedObject::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Constructor // Constructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(TrackedObject::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(TrackedObject::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("TrackedObject")); ctor->SetClassName(Nan::New("TrackedObject").ToLocalChecked());
// Prototype // Prototype
// Local<ObjectTemplate> proto = constructor->PrototypeTemplate(); // Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
NODE_SET_PROTOTYPE_METHOD(ctor, "track", Track); Nan::SetPrototypeMethod(ctor, "track", Track);
target->Set(NanNew("TrackedObject"), ctor->GetFunction()); target->Set(Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(TrackedObject::New) { NAN_METHOD(TrackedObject::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
JSTHROW_TYPE("Cannot Instantiate without new") JSTHROW_TYPE("Cannot Instantiate without new")
} }
Matrix* m = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Rect r; cv::Rect r;
int channel = CHANNEL_HUE; int channel = CHANNEL_HUE;
if (args[1]->IsArray()) { if (info[1]->IsArray()) {
Local<Object> v8rec = args[1]->ToObject(); Local<Object> v8rec = info[1]->ToObject();
r = cv::Rect( r = cv::Rect(
v8rec->Get(0)->IntegerValue(), v8rec->Get(0)->IntegerValue(),
v8rec->Get(1)->IntegerValue(), v8rec->Get(1)->IntegerValue(),
@ -49,11 +49,11 @@ NAN_METHOD(TrackedObject::New) {
JSTHROW_TYPE("Must pass rectangle to track") JSTHROW_TYPE("Must pass rectangle to track")
} }
if (args[2]->IsObject()) { if (info[2]->IsObject()) {
Local<Object> opts = args[2]->ToObject(); Local<Object> opts = info[2]->ToObject();
if (opts->Get(NanNew("channel"))->IsString()) { if (opts->Get(Nan::New("channel").ToLocalChecked())->IsString()) {
v8::String::Utf8Value c(opts->Get(NanNew("channel"))->ToString()); v8::String::Utf8Value c(opts->Get(Nan::New("channel").ToLocalChecked())->ToString());
std::string cc = std::string(*c); std::string cc = std::string(*c);
if (cc == "hue" || cc == "h") { if (cc == "hue" || cc == "h") {
@ -72,8 +72,8 @@ NAN_METHOD(TrackedObject::New) {
TrackedObject *to = new TrackedObject(m->mat, r, channel); TrackedObject *to = new TrackedObject(m->mat, r, channel);
to->Wrap(args.This()); to->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
void update_chann_image(TrackedObject* t, cv::Mat image) { 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) { NAN_METHOD(TrackedObject::Track) {
SETUP_FUNCTION(TrackedObject) SETUP_FUNCTION(TrackedObject)
if (args.Length() != 1) { if (info.Length() != 1) {
NanThrowTypeError("track takes an image param"); Nan::ThrowTypeError("track takes an image param");
NanReturnUndefined(); return;
} }
Matrix *im = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix *im = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::RotatedRect r; cv::RotatedRect r;
if ((self->prev_rect.x < 0) || (self->prev_rect.y < 0) if ((self->prev_rect.x < 0) || (self->prev_rect.y < 0)
|| (self->prev_rect.width <= 1) || (self->prev_rect.height <= 1)) { || (self->prev_rect.width <= 1) || (self->prev_rect.height <= 1)) {
return NanThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); return Nan::ThrowTypeError("OPENCV ERROR: prev rectangle is illogical");
} }
update_chann_image(self, im->mat); update_chann_image(self, im->mat);
@ -155,21 +155,21 @@ NAN_METHOD(TrackedObject::Track) {
self->prev_rect = backup_prev_rect; self->prev_rect = backup_prev_rect;
} }
v8::Local<v8::Array> arr = NanNew<Array>(4); v8::Local<v8::Array> arr = Nan::New<Array>(4);
arr->Set(0, NanNew<Number>(bounds.x)); arr->Set(0, Nan::New<Number>(bounds.x));
arr->Set(1, NanNew<Number>(bounds.y)); arr->Set(1, Nan::New<Number>(bounds.y));
arr->Set(2, NanNew<Number>(bounds.x + bounds.width)); arr->Set(2, Nan::New<Number>(bounds.x + bounds.width));
arr->Set(3, NanNew<Number>(bounds.y + bounds.height)); arr->Set(3, Nan::New<Number>(bounds.y + bounds.height));
/* /*
cv::Point2f pts[4]; cv::Point2f pts[4];
r.points(pts); r.points(pts);
for (int i = 0; i < 8; i += 2) { for (int i = 0; i < 8; i += 2) {
arr->Set(i, NanNew<Number>(pts[i].x)); arr->Set(i, Nan::New<Number>(pts[i].x));
arr->Set(i + 1, NanNew<Number>(pts[i].y)); arr->Set(i + 1, Nan::New<Number>(pts[i].y));
} */ } */
NanReturnValue(arr); info.GetReturnValue().Set(arr);
} }

6
src/CamShift.h
View File

@ -1,7 +1,7 @@
#include "OpenCV.h" #include "OpenCV.h"
class TrackedObject: public node::ObjectWrap { class TrackedObject: public Nan::ObjectWrap {
public: public:
int channel; int channel;
cv::Mat hsv; cv::Mat hsv;
@ -12,8 +12,8 @@ public:
cv::Mat hist; cv::Mat hist;
cv::Rect prev_rect; cv::Rect prev_rect;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
TrackedObject(cv::Mat image, cv::Rect rect, int channel); TrackedObject(cv::Mat image, cv::Rect rect, int channel);

90
src/CascadeClassifierWrap.cc
View File

@ -3,50 +3,50 @@
#include "Matrix.h" #include "Matrix.h"
#include <nan.h> #include <nan.h>
Persistent<FunctionTemplate> CascadeClassifierWrap::constructor; Nan::Persistent<FunctionTemplate> CascadeClassifierWrap::constructor;
void CascadeClassifierWrap::Init(Handle<Object> target) { void CascadeClassifierWrap::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate> (CascadeClassifierWrap::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate> (CascadeClassifierWrap::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("CascadeClassifier")); ctor->SetClassName(Nan::New("CascadeClassifier").ToLocalChecked());
// Prototype // Prototype
// Local<ObjectTemplate> proto = constructor->PrototypeTemplate(); // Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
NODE_SET_PROTOTYPE_METHOD(ctor, "detectMultiScale", DetectMultiScale); Nan::SetPrototypeMethod(ctor, "detectMultiScale", DetectMultiScale);
target->Set(NanNew("CascadeClassifier"), ctor->GetFunction()); target->Set(Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(CascadeClassifierWrap::New) { NAN_METHOD(CascadeClassifierWrap::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new"); Nan::ThrowTypeError("Cannot instantiate without new");
} }
CascadeClassifierWrap *pt = new CascadeClassifierWrap(*args[0]); CascadeClassifierWrap *pt = new CascadeClassifierWrap(*info[0]);
pt->Wrap(args.This()); pt->Wrap(info.This());
NanReturnValue( args.This() ); info.GetReturnValue().Set( info.This() );
} }
CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName) { CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName) {
std::string filename; std::string filename;
filename = std::string(*NanAsciiString(fileName->ToString())); filename = std::string(*Nan::Utf8String(fileName->ToString()));
if (!cc.load(filename.c_str())) { if (!cc.load(filename.c_str())) {
NanThrowTypeError("Error loading file"); Nan::ThrowTypeError("Error loading file");
} }
} }
class AsyncDetectMultiScale: public NanAsyncWorker { class AsyncDetectMultiScale: public Nan::AsyncWorker {
public: public:
AsyncDetectMultiScale(NanCallback *callback, CascadeClassifierWrap *cc, AsyncDetectMultiScale(Nan::Callback *callback, CascadeClassifierWrap *cc,
Matrix* im, double scale, int neighbors, int minw, int minh) : Matrix* im, double scale, int neighbors, int minw, int minh) :
NanAsyncWorker(callback), Nan::AsyncWorker(callback),
cc(cc), cc(cc),
im(im), im(im),
scale(scale), scale(scale),
@ -79,28 +79,28 @@ public:
} }
void HandleOKCallback() { void HandleOKCallback() {
NanScope(); Nan::HandleScope scope;
// this->matrix->Unref(); // this->matrix->Unref();
Handle < Value > argv[2]; Local < Value > argv[2];
v8::Local < v8::Array > arr = NanNew < v8::Array > (this->res.size()); v8::Local < v8::Array > arr = Nan::New < v8::Array > (this->res.size());
for (unsigned int i = 0; i < this->res.size(); i++) { for (unsigned int i = 0; i < this->res.size(); i++) {
v8::Local < v8::Object > x = NanNew<v8::Object>(); v8::Local < v8::Object > x = Nan::New<v8::Object>();
x->Set(NanNew("x"), NanNew < Number > (this->res[i].x)); x->Set(Nan::New("x").ToLocalChecked(), Nan::New < Number > (this->res[i].x));
x->Set(NanNew("y"), NanNew < Number > (this->res[i].y)); x->Set(Nan::New("y").ToLocalChecked(), Nan::New < Number > (this->res[i].y));
x->Set(NanNew("width"), NanNew < Number > (this->res[i].width)); x->Set(Nan::New("width").ToLocalChecked(), Nan::New < Number > (this->res[i].width));
x->Set(NanNew("height"), NanNew < Number > (this->res[i].height)); x->Set(Nan::New("height").ToLocalChecked(), Nan::New < Number > (this->res[i].height));
arr->Set(i, x); arr->Set(i, x);
} }
argv[0] = NanNull(); argv[0] = Nan::Null();
argv[1] = arr; argv[1] = arr;
TryCatch try_catch; Nan::TryCatch try_catch;
callback->Call(2, argv); callback->Call(2, argv);
if (try_catch.HasCaught()) { if (try_catch.HasCaught()) {
FatalException(try_catch); Nan::FatalException(try_catch);
} }
} }
@ -115,37 +115,37 @@ private:
}; };
NAN_METHOD(CascadeClassifierWrap::DetectMultiScale) { NAN_METHOD(CascadeClassifierWrap::DetectMultiScale) {
NanScope(); Nan::HandleScope scope;
CascadeClassifierWrap *self = ObjectWrap::Unwrap<CascadeClassifierWrap> (args.This()); CascadeClassifierWrap *self = Nan::ObjectWrap::Unwrap<CascadeClassifierWrap> (info.This());
if (args.Length() < 2) { if (info.Length() < 2) {
NanThrowTypeError("detectMultiScale takes at least 2 args"); Nan::ThrowTypeError("detectMultiScale takes at least 2 info");
} }
Matrix *im = ObjectWrap::Unwrap < Matrix > (args[0]->ToObject()); Matrix *im = Nan::ObjectWrap::Unwrap < Matrix > (info[0]->ToObject());
REQ_FUN_ARG(1, cb); REQ_FUN_ARG(1, cb);
double scale = 1.1; double scale = 1.1;
if (args.Length() > 2 && args[2]->IsNumber()) { if (info.Length() > 2 && info[2]->IsNumber()) {
scale = args[2]->NumberValue(); scale = info[2]->NumberValue();
} }
int neighbors = 2; int neighbors = 2;
if (args.Length() > 3 && args[3]->IsInt32()) { if (info.Length() > 3 && info[3]->IsInt32()) {
neighbors = args[3]->IntegerValue(); neighbors = info[3]->IntegerValue();
} }
int minw = 30; int minw = 30;
int minh = 30; int minh = 30;
if (args.Length() > 5 && args[4]->IsInt32() && args[5]->IsInt32()) { if (info.Length() > 5 && info[4]->IsInt32() && info[5]->IsInt32()) {
minw = args[4]->IntegerValue(); minw = info[4]->IntegerValue();
minh = args[5]->IntegerValue(); minh = info[5]->IntegerValue();
} }
NanCallback *callback = new NanCallback(cb.As<Function>()); Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, Nan::AsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale,
neighbors, minw, minh)); neighbors, minw, minh));
NanReturnUndefined(); return;
} }

6
src/CascadeClassifierWrap.h
View File

@ -1,11 +1,11 @@
#include "OpenCV.h" #include "OpenCV.h"
class CascadeClassifierWrap: public node::ObjectWrap { class CascadeClassifierWrap: public Nan::ObjectWrap {
public: public:
cv::CascadeClassifier cc; cv::CascadeClassifier cc;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
CascadeClassifierWrap(v8::Value* fileName); CascadeClassifierWrap(v8::Value* fileName);

14
src/Constants.cc
View File

@ -2,15 +2,15 @@
#include "Constants.h" #include "Constants.h"
#define CONST(C) \ #define CONST(C) \
obj->Set(NanNew<String>(#C), NanNew<Integer>(C)); obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>(C));
#define CONST_ENUM(C) \ #define CONST_ENUM(C) \
obj->Set(NanNew<String>(#C), NanNew<Integer>((int)(cv::C))); obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)(cv::C)));
void Constants::Init(Handle<Object> target) { void Constants::Init(Local<Object> target) {
Persistent<Object> inner; Nan::Persistent<Object> inner;
Local<Object> obj = NanNew<Object>(); Local<Object> obj = Nan::New<Object>();
NanAssignPersistent(inner, obj); inner.Reset(obj);
CONST(CV_8U); CONST(CV_8U);
CONST(CV_8S); CONST(CV_8S);
@ -72,7 +72,7 @@ void Constants::Init(Handle<Object> target) {
CONST_ENUM(NORM_RELATIVE); CONST_ENUM(NORM_RELATIVE);
CONST_ENUM(NORM_TYPE_MASK); CONST_ENUM(NORM_TYPE_MASK);
target->Set(NanNew("Constants"), obj); target->Set(Nan::New("Constants").ToLocalChecked(), obj);
} }
#undef CONST #undef CONST

4
src/Constants.h
View File

@ -1,6 +1,6 @@
#include "OpenCV.h" #include "OpenCV.h"
class Constants: public node::ObjectWrap { class Constants: public Nan::ObjectWrap {
public: public:
static void Init(Handle<Object> target); static void Init(Local<Object> target);
}; };

324
src/Contours.cc
View File

@ -4,348 +4,348 @@
#include <iostream> #include <iostream>
v8::Persistent<FunctionTemplate> Contour::constructor; Nan::Persistent<FunctionTemplate> Contour::constructor;
void Contour::Init(Handle<Object> target) { void Contour::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Class/contructor // Class/contructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Contour::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(Contour::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("Contours")); ctor->SetClassName(Nan::New("Contours").ToLocalChecked());
// Prototype // Prototype
// Local<ObjectTemplate> proto = constructor->PrototypeTemplate(); // Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
NODE_SET_PROTOTYPE_METHOD(ctor, "point", Point); Nan::SetPrototypeMethod(ctor, "point", Point);
NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size); Nan::SetPrototypeMethod(ctor, "size", Size);
NODE_SET_PROTOTYPE_METHOD(ctor, "cornerCount", CornerCount); Nan::SetPrototypeMethod(ctor, "cornerCount", CornerCount);
NODE_SET_PROTOTYPE_METHOD(ctor, "area", Area); Nan::SetPrototypeMethod(ctor, "area", Area);
NODE_SET_PROTOTYPE_METHOD(ctor, "arcLength", ArcLength); Nan::SetPrototypeMethod(ctor, "arcLength", ArcLength);
NODE_SET_PROTOTYPE_METHOD(ctor, "approxPolyDP", ApproxPolyDP); Nan::SetPrototypeMethod(ctor, "approxPolyDP", ApproxPolyDP);
NODE_SET_PROTOTYPE_METHOD(ctor, "convexHull", ConvexHull); Nan::SetPrototypeMethod(ctor, "convexHull", ConvexHull);
NODE_SET_PROTOTYPE_METHOD(ctor, "boundingRect", BoundingRect); Nan::SetPrototypeMethod(ctor, "boundingRect", BoundingRect);
NODE_SET_PROTOTYPE_METHOD(ctor, "minAreaRect", MinAreaRect); Nan::SetPrototypeMethod(ctor, "minAreaRect", MinAreaRect);
NODE_SET_PROTOTYPE_METHOD(ctor, "fitEllipse", FitEllipse); Nan::SetPrototypeMethod(ctor, "fitEllipse", FitEllipse);
NODE_SET_PROTOTYPE_METHOD(ctor, "isConvex", IsConvex); Nan::SetPrototypeMethod(ctor, "isConvex", IsConvex);
NODE_SET_PROTOTYPE_METHOD(ctor, "moments", Moments); Nan::SetPrototypeMethod(ctor, "moments", Moments);
NODE_SET_PROTOTYPE_METHOD(ctor, "hierarchy", Hierarchy); Nan::SetPrototypeMethod(ctor, "hierarchy", Hierarchy);
NODE_SET_PROTOTYPE_METHOD(ctor, "serialize", Serialize); Nan::SetPrototypeMethod(ctor, "serialize", Serialize);
NODE_SET_PROTOTYPE_METHOD(ctor, "deserialize", Deserialize); Nan::SetPrototypeMethod(ctor, "deserialize", Deserialize);
target->Set(NanNew("Contours"), ctor->GetFunction()); target->Set(Nan::New("Contours").ToLocalChecked(), ctor->GetFunction());
}; };
NAN_METHOD(Contour::New) { NAN_METHOD(Contour::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new"); Nan::ThrowTypeError("Cannot instantiate without new");
} }
Contour *contours; Contour *contours;
contours = new Contour; contours = new Contour;
contours->Wrap(args.Holder()); contours->Wrap(info.Holder());
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
Contour::Contour() : Contour::Contour() :
ObjectWrap() { Nan::ObjectWrap() {
} }
NAN_METHOD(Contour::Point) { NAN_METHOD(Contour::Point) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
int index = args[1]->NumberValue(); int index = info[1]->NumberValue();
cv::Point point = self->contours[pos][index]; cv::Point point = self->contours[pos][index];
Local<Object> data = NanNew<Object>(); Local<Object> data = Nan::New<Object>();
data->Set(NanNew("x"), NanNew<Number>(point.x)); data->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x));
data->Set(NanNew("y"), NanNew<Number>(point.y)); data->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y));
NanReturnValue(data); info.GetReturnValue().Set(data);
} }
NAN_METHOD(Contour::Points) { NAN_METHOD(Contour::Points) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
vector<cv::Point> points = self->contours[pos]; vector<cv::Point> points = self->contours[pos];
Local<Array> data = NanNew<Array>(points.size()); Local<Array> data = Nan::New<Array>(points.size());
for (std::vector<int>::size_type i = 0; i != points.size(); i++) { for (std::vector<int>::size_type i = 0; i != points.size(); i++) {
Local<Object> point_data = NanNew<Object>(); Local<Object> point_data = Nan::New<Object>();
point_data->Set(NanNew<String>("x"), NanNew<Number>(points[i].x)); point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x));
point_data->Set(NanNew<String>("y"), NanNew<Number>(points[i].y)); point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y));
data->Set(i, point_data); data->Set(i, point_data);
} }
NanReturnValue(data); info.GetReturnValue().Set(data);
} }
// FIXME: this should better be called "Length" as ``Contours`` is an Array like // 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 // structure also, this would allow to use ``Size`` for the function returning
// the number of corners in the contour for better consistency with OpenCV. // the number of corners in the contour for better consistency with OpenCV.
NAN_METHOD(Contour::Size) { NAN_METHOD(Contour::Size) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
NanReturnValue(NanNew<Number>(self->contours.size())); info.GetReturnValue().Set(Nan::New<Number>(self->contours.size()));
} }
NAN_METHOD(Contour::CornerCount) { NAN_METHOD(Contour::CornerCount) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
NanReturnValue(NanNew<Number>(self->contours[pos].size())); info.GetReturnValue().Set(Nan::New<Number>(self->contours[pos].size()));
} }
NAN_METHOD(Contour::Area) { NAN_METHOD(Contour::Area) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
// NanReturnValue(NanNew<Number>(contourArea(self->contours))); // info.GetReturnValue().Set(Nan::New<Number>(contourArea(self->contours)));
NanReturnValue(NanNew<Number>(contourArea(cv::Mat(self->contours[pos])))); info.GetReturnValue().Set(Nan::New<Number>(contourArea(cv::Mat(self->contours[pos]))));
} }
NAN_METHOD(Contour::ArcLength) { NAN_METHOD(Contour::ArcLength) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
bool isClosed = args[1]->BooleanValue(); bool isClosed = info[1]->BooleanValue();
NanReturnValue(NanNew<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed))); info.GetReturnValue().Set(Nan::New<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
} }
NAN_METHOD(Contour::ApproxPolyDP) { NAN_METHOD(Contour::ApproxPolyDP) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
double epsilon = args[1]->NumberValue(); double epsilon = info[1]->NumberValue();
bool isClosed = args[2]->BooleanValue(); bool isClosed = info[2]->BooleanValue();
cv::Mat approxed; cv::Mat approxed;
approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed); approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed);
approxed.copyTo(self->contours[pos]); approxed.copyTo(self->contours[pos]);
NanReturnNull(); info.GetReturnValue().Set(Nan::Null());
} }
NAN_METHOD(Contour::ConvexHull) { NAN_METHOD(Contour::ConvexHull) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
bool clockwise = args[1]->BooleanValue(); bool clockwise = info[1]->BooleanValue();
cv::Mat hull; cv::Mat hull;
cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise); cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise);
hull.copyTo(self->contours[pos]); hull.copyTo(self->contours[pos]);
NanReturnNull(); info.GetReturnValue().Set(Nan::Null());
} }
NAN_METHOD(Contour::BoundingRect) { NAN_METHOD(Contour::BoundingRect) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos])); cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos]));
Local<Object> rect = NanNew<Object>(); Local<Object> rect = Nan::New<Object>();
rect->Set(NanNew("x"), NanNew<Number>(bounding.x)); rect->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x));
rect->Set(NanNew("y"), NanNew<Number>(bounding.y)); rect->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y));
rect->Set(NanNew("width"), NanNew<Number>(bounding.width)); rect->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width));
rect->Set(NanNew("height"), NanNew<Number>(bounding.height)); rect->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height));
NanReturnValue(rect); info.GetReturnValue().Set(rect);
} }
NAN_METHOD(Contour::MinAreaRect) { NAN_METHOD(Contour::MinAreaRect) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos])); cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos]));
Local<Object> rect = NanNew<Object>(); Local<Object> rect = Nan::New<Object>();
rect->Set(NanNew("angle"), NanNew<Number>(minimum.angle)); rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle));
Local<Object> size = NanNew<Object>(); Local<Object> size = Nan::New<Object>();
size->Set(NanNew("height"), NanNew<Number>(minimum.size.height)); size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height));
size->Set(NanNew("width"), NanNew<Number>(minimum.size.width)); size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width));
rect->Set(NanNew("size"), size); rect->Set(Nan::New("size").ToLocalChecked(), size);
Local<Object> center = NanNew<Object>(); Local<Object> center = Nan::New<Object>();
center->Set(NanNew("x"), NanNew<Number>(minimum.center.x)); center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x));
center->Set(NanNew("y"), NanNew<Number>(minimum.center.y)); center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y));
v8::Local<v8::Array> points = NanNew<Array>(4); v8::Local<v8::Array> points = Nan::New<Array>(4);
cv::Point2f rect_points[4]; cv::Point2f rect_points[4];
minimum.points(rect_points); minimum.points(rect_points);
for (unsigned int i=0; i<4; i++) { for (unsigned int i=0; i<4; i++) {
Local<Object> point = NanNew<Object>(); Local<Object> point = Nan::New<Object>();
point->Set(NanNew("x"), NanNew<Number>(rect_points[i].x)); point->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x));
point->Set(NanNew("y"), NanNew<Number>(rect_points[i].y)); point->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y));
points->Set(i, point); points->Set(i, point);
} }
rect->Set(NanNew("points"), points); rect->Set(Nan::New("points").ToLocalChecked(), points);
NanReturnValue(rect); info.GetReturnValue().Set(rect);
} }
NAN_METHOD(Contour::FitEllipse) { NAN_METHOD(Contour::FitEllipse) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
if (self->contours[pos].size() >= 5) { // Minimum number for an ellipse if (self->contours[pos].size() >= 5) { // Minimum number for an ellipse
cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos])); cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos]));
Local<Object> jsEllipse = NanNew<Object>(); Local<Object> jsEllipse = Nan::New<Object>();
jsEllipse->Set(NanNew("angle"), NanNew<Number>(ellipse.angle)); jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle));
Local<Object> size = NanNew<Object>(); Local<Object> size = Nan::New<Object>();
size->Set(NanNew("height"), NanNew<Number>(ellipse.size.height)); size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height));
size->Set(NanNew("width"), NanNew<Number>(ellipse.size.width)); size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width));
jsEllipse->Set(NanNew("size"), size); jsEllipse->Set(Nan::New("size").ToLocalChecked(), size);
Local<Object> center = NanNew<Object>(); Local<Object> center = Nan::New<Object>();
center->Set(NanNew("x"), NanNew<Number>(ellipse.center.x)); center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x));
center->Set(NanNew("y"), NanNew<Number>(ellipse.center.y)); center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y));
jsEllipse->Set(NanNew("center"), center); jsEllipse->Set(Nan::New("center").ToLocalChecked(), center);
NanReturnValue(jsEllipse); info.GetReturnValue().Set(jsEllipse);
} }
NanReturnNull(); info.GetReturnValue().Set(Nan::Null());
} }
NAN_METHOD(Contour::IsConvex) { NAN_METHOD(Contour::IsConvex) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
NanReturnValue(NanNew<Boolean>(isContourConvex(cv::Mat(self->contours[pos])))); info.GetReturnValue().Set(Nan::New<Boolean>(isContourConvex(cv::Mat(self->contours[pos]))));
} }
NAN_METHOD(Contour::Moments) { NAN_METHOD(Contour::Moments) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->NumberValue(); int pos = info[0]->NumberValue();
// Get the moments // Get the moments
cv::Moments mu = moments( self->contours[pos], false ); cv::Moments mu = moments( self->contours[pos], false );
Local<Object> res = NanNew<Object>(); Local<Object> res = Nan::New<Object>();
res->Set(NanNew("m00"), NanNew<Number>(mu.m00)); res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00));
res->Set(NanNew("m10"), NanNew<Number>(mu.m10)); res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10));
res->Set(NanNew("m01"), NanNew<Number>(mu.m01)); res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01));
res->Set(NanNew("m11"), NanNew<Number>(mu.m11)); res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11));
NanReturnValue(res); info.GetReturnValue().Set(res);
} }
NAN_METHOD(Contour::Hierarchy) { NAN_METHOD(Contour::Hierarchy) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = args[0]->IntegerValue(); int pos = info[0]->IntegerValue();
cv::Vec4i hierarchy = self->hierarchy[pos]; cv::Vec4i hierarchy = self->hierarchy[pos];
Local<Array> res = NanNew<Array>(4); Local<Array> res = Nan::New<Array>(4);
res->Set(0, NanNew<Number>(hierarchy[0])); res->Set(0, Nan::New<Number>(hierarchy[0]));
res->Set(1, NanNew<Number>(hierarchy[1])); res->Set(1, Nan::New<Number>(hierarchy[1]));
res->Set(2, NanNew<Number>(hierarchy[2])); res->Set(2, Nan::New<Number>(hierarchy[2]));
res->Set(3, NanNew<Number>(hierarchy[3])); res->Set(3, Nan::New<Number>(hierarchy[3]));
NanReturnValue(res); info.GetReturnValue().Set(res);
} }
NAN_METHOD(Contour::Serialize) { NAN_METHOD(Contour::Serialize) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
Local<Array> contours_data = NanNew<Array>(self->contours.size()); Local<Array> contours_data = Nan::New<Array>(self->contours.size());
for (std::vector<int>::size_type i = 0; i != self->contours.size(); i++) { for (std::vector<int>::size_type i = 0; i != self->contours.size(); i++) {
vector<cv::Point> points = self->contours[i]; vector<cv::Point> points = self->contours[i];
Local<Array> contour_data = NanNew<Array>(points.size()); Local<Array> contour_data = Nan::New<Array>(points.size());
for (std::vector<int>::size_type j = 0; j != points.size(); j++) { for (std::vector<int>::size_type j = 0; j != points.size(); j++) {
Local<Array> point_data = NanNew<Array>(2); Local<Array> point_data = Nan::New<Array>(2);
point_data->Set(0, NanNew<Number>(points[j].x)); point_data->Set(0, Nan::New<Number>(points[j].x));
point_data->Set(1, NanNew<Number>(points[j].y)); point_data->Set(1, Nan::New<Number>(points[j].y));
contour_data->Set(j, point_data); contour_data->Set(j, point_data);
} }
contours_data->Set(i, contour_data); contours_data->Set(i, contour_data);
} }
Local<Array> hierarchy_data = NanNew<Array>(self->hierarchy.size()); Local<Array> hierarchy_data = Nan::New<Array>(self->hierarchy.size());
for (std::vector<int>::size_type i = 0; i != self->hierarchy.size(); i++) { for (std::vector<int>::size_type i = 0; i != self->hierarchy.size(); i++) {
Local<Array> contour_data = NanNew<Array>(4); Local<Array> contour_data = Nan::New<Array>(4);
contour_data->Set(0, NanNew<Number>(self->hierarchy[i][0])); contour_data->Set(0, Nan::New<Number>(self->hierarchy[i][0]));
contour_data->Set(1, NanNew<Number>(self->hierarchy[i][1])); contour_data->Set(1, Nan::New<Number>(self->hierarchy[i][1]));
contour_data->Set(2, NanNew<Number>(self->hierarchy[i][2])); contour_data->Set(2, Nan::New<Number>(self->hierarchy[i][2]));
contour_data->Set(3, NanNew<Number>(self->hierarchy[i][3])); contour_data->Set(3, Nan::New<Number>(self->hierarchy[i][3]));
hierarchy_data->Set(i, contour_data); hierarchy_data->Set(i, contour_data);
} }
Local<Object> data = NanNew<Object>(); Local<Object> data = Nan::New<Object>();
data->Set(NanNew<String>("contours"), contours_data); data->Set(Nan::New<String>("contours").ToLocalChecked(), contours_data);
data->Set(NanNew<String>("hierarchy"), hierarchy_data); data->Set(Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data);
NanReturnValue(data); info.GetReturnValue().Set(data);
} }
NAN_METHOD(Contour::Deserialize) { NAN_METHOD(Contour::Deserialize) {
NanScope(); Nan::HandleScope scope;
Contour *self = ObjectWrap::Unwrap<Contour>(args.This()); Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
Handle<Object> data = Handle<Object>::Cast(args[0]); Local<Object> data = Local<Object>::Cast(info[0]);
Handle<Array> contours_data = Handle<Array>::Cast(data->Get(NanNew<String>("contours"))); Local<Array> contours_data = Local<Array>::Cast(data->Get(Nan::New<String>("contours").ToLocalChecked()));
Handle<Array> hierarchy_data = Handle<Array>::Cast(data->Get(NanNew<String>("hierarchy"))); Local<Array> hierarchy_data = Local<Array>::Cast(data->Get(Nan::New<String>("hierarchy").ToLocalChecked()));
vector<vector<cv::Point> > contours_res; vector<vector<cv::Point> > contours_res;
int contours_length = contours_data->Length(); int contours_length = contours_data->Length();
for (int i = 0; i < contours_length; i++) { for (int i = 0; i < contours_length; i++) {
Handle<Array> contour_data = Handle<Array>::Cast(contours_data->Get(i)); Local<Array> contour_data = Local<Array>::Cast(contours_data->Get(i));
vector<cv::Point> points; vector<cv::Point> points;
int contour_length = contour_data->Length(); int contour_length = contour_data->Length();
for (int j = 0; j < contour_length; j++) { for (int j = 0; j < contour_length; j++) {
Handle<Array> point_data = Handle<Array>::Cast(contour_data->Get(j)); Local<Array> point_data = Local<Array>::Cast(contour_data->Get(j));
int x = point_data->Get(0)->IntegerValue(); int x = point_data->Get(0)->IntegerValue();
int y = point_data->Get(1)->IntegerValue(); int y = point_data->Get(1)->IntegerValue();
points.push_back(cv::Point(x, y)); points.push_back(cv::Point(x, y));
@ -358,7 +358,7 @@ NAN_METHOD(Contour::Deserialize) {
int hierarchy_length = hierarchy_data->Length(); int hierarchy_length = hierarchy_data->Length();
for (int i = 0; i < hierarchy_length; i++) { for (int i = 0; i < hierarchy_length; i++) {
Handle<Array> contour_data = Handle<Array>::Cast(hierarchy_data->Get(i)); Local<Array> contour_data = Local<Array>::Cast(hierarchy_data->Get(i));
int a = contour_data->Get(0)->IntegerValue(); int a = contour_data->Get(0)->IntegerValue();
int b = contour_data->Get(1)->IntegerValue(); int b = contour_data->Get(1)->IntegerValue();
int c = contour_data->Get(2)->IntegerValue(); int c = contour_data->Get(2)->IntegerValue();
@ -369,5 +369,5 @@ NAN_METHOD(Contour::Deserialize) {
self->contours = contours_res; self->contours = contours_res;
self->hierarchy = hierarchy_res; self->hierarchy = hierarchy_res;
NanReturnNull(); info.GetReturnValue().Set(Nan::Null());
} }

6
src/Contours.h
View File

@ -2,14 +2,14 @@
using namespace std; using namespace std;
class Contour: public node::ObjectWrap { class Contour: public Nan::ObjectWrap {
public: public:
cv::Mat mat; cv::Mat mat;
vector<vector<cv::Point> > contours; vector<vector<cv::Point> > contours;
vector<cv::Vec4i> hierarchy; vector<cv::Vec4i> hierarchy;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
Contour(); Contour();

114
src/FaceRecognizer.cc
View File

@ -14,11 +14,11 @@
cv::Mat fromMatrixOrFilename(Local<Value> v) { cv::Mat fromMatrixOrFilename(Local<Value> v) {
cv::Mat im; cv::Mat im;
if (v->IsString()) { if (v->IsString()) {
std::string filename = std::string(*NanAsciiString(v->ToString())); std::string filename = std::string(*Nan::Utf8String(v->ToString()));
im = cv::imread(filename); im = cv::imread(filename);
// std::cout<< im.size(); // std::cout<< im.size();
} else { } else {
Matrix *img = ObjectWrap::Unwrap<Matrix>(v->ToObject()); Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(v->ToObject());
im = img->mat; im = img->mat;
} }
return im; return im;
@ -27,36 +27,36 @@ cv::Mat fromMatrixOrFilename(Local<Value> v) {
void AsyncPredict(uv_work_t *req); void AsyncPredict(uv_work_t *req);
void AfterAsyncPredict(uv_work_t *req); void AfterAsyncPredict(uv_work_t *req);
Persistent<FunctionTemplate> FaceRecognizerWrap::constructor; Nan::Persistent<FunctionTemplate> FaceRecognizerWrap::constructor;
void FaceRecognizerWrap::Init(Handle<Object> target) { void FaceRecognizerWrap::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Constructor // Constructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(FaceRecognizerWrap::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(FaceRecognizerWrap::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("FaceRecognizer")); ctor->SetClassName(Nan::New("FaceRecognizer").ToLocalChecked());
NODE_SET_METHOD(ctor, "createLBPHFaceRecognizer", CreateLBPH); Nan::SetMethod(ctor, "createLBPHFaceRecognizer", CreateLBPH);
NODE_SET_METHOD(ctor, "createEigenFaceRecognizer", CreateEigen); Nan::SetMethod(ctor, "createEigenFaceRecognizer", CreateEigen);
NODE_SET_METHOD(ctor, "createFisherFaceRecognizer", CreateFisher); Nan::SetMethod(ctor, "createFisherFaceRecognizer", CreateFisher);
NODE_SET_PROTOTYPE_METHOD(ctor, "trainSync", TrainSync); Nan::SetPrototypeMethod(ctor, "trainSync", TrainSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "updateSync", UpdateSync); Nan::SetPrototypeMethod(ctor, "updateSync", UpdateSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "predictSync", PredictSync); Nan::SetPrototypeMethod(ctor, "predictSync", PredictSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "saveSync", SaveSync); Nan::SetPrototypeMethod(ctor, "saveSync", SaveSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "loadSync", LoadSync); Nan::SetPrototypeMethod(ctor, "loadSync", LoadSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "getMat", GetMat); Nan::SetPrototypeMethod(ctor, "getMat", GetMat);
target->Set(NanNew("FaceRecognizer"), ctor->GetFunction()); target->Set(Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction());
}; };
NAN_METHOD(FaceRecognizerWrap::New) { NAN_METHOD(FaceRecognizerWrap::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
JSTHROW_TYPE("Cannot Instantiate without new") JSTHROW_TYPE("Cannot Instantiate without new")
} }
@ -64,12 +64,12 @@ NAN_METHOD(FaceRecognizerWrap::New) {
cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(1, 8, 8, 8, 80.0); cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(1, 8, 8, 8, 80.0);
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH);
pt->Wrap(args.This()); pt->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { NAN_METHOD(FaceRecognizerWrap::CreateLBPH) {
NanScope(); Nan::HandleScope scope;
int radius = 1; int radius = 1;
int neighbors = 8; int neighbors = 8;
@ -83,17 +83,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateLBPH) {
INT_FROM_ARGS(grid_y, 3) INT_FROM_ARGS(grid_y, 3)
DOUBLE_FROM_ARGS(threshold, 4) DOUBLE_FROM_ARGS(threshold, 4)
Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(radius, cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(radius,
neighbors, grid_x, grid_y, threshold); neighbors, grid_x, grid_y, threshold);
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH);
pt->Wrap(n); pt->Wrap(n);
NanReturnValue( n ); info.GetReturnValue().Set( n );
} }
NAN_METHOD(FaceRecognizerWrap::CreateEigen) { NAN_METHOD(FaceRecognizerWrap::CreateEigen) {
NanScope(); Nan::HandleScope scope;
int components = 0; int components = 0;
double threshold = DBL_MAX; double threshold = DBL_MAX;
@ -101,17 +101,17 @@ NAN_METHOD(FaceRecognizerWrap::CreateEigen) {
INT_FROM_ARGS(components, 0) INT_FROM_ARGS(components, 0)
DOUBLE_FROM_ARGS(threshold, 1) DOUBLE_FROM_ARGS(threshold, 1)
Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::FaceRecognizer> f = cv::createEigenFaceRecognizer(components, cv::Ptr<cv::FaceRecognizer> f = cv::createEigenFaceRecognizer(components,
threshold); threshold);
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN);
pt->Wrap(n); pt->Wrap(n);
NanReturnValue( n ); info.GetReturnValue().Set( n );
} }
NAN_METHOD(FaceRecognizerWrap::CreateFisher) { NAN_METHOD(FaceRecognizerWrap::CreateFisher) {
NanScope(); Nan::HandleScope scope;
int components = 0; int components = 0;
double threshold = DBL_MAX; double threshold = DBL_MAX;
@ -119,14 +119,14 @@ NAN_METHOD(FaceRecognizerWrap::CreateFisher) {
INT_FROM_ARGS(components, 0) INT_FROM_ARGS(components, 0)
DOUBLE_FROM_ARGS(threshold, 1) DOUBLE_FROM_ARGS(threshold, 1)
Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::FaceRecognizer> f = cv::createFisherFaceRecognizer(components, cv::Ptr<cv::FaceRecognizer> f = cv::createFisherFaceRecognizer(components,
threshold); threshold);
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER); FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER);
pt->Wrap(n); pt->Wrap(n);
NanReturnValue( n ); info.GetReturnValue().Set( n );
} }
FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f,
@ -135,16 +135,16 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f,
typ = type; typ = type;
} }
Handle<Value> UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, Local<Value> UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info,
cv::vector<cv::Mat>* images, cv::vector<int>* labels) { cv::vector<cv::Mat>* images, cv::vector<int>* labels) {
if (args.Length() < 1 || !args[0]->IsArray()) { if (info.Length() < 1 || !info[0]->IsArray()) {
JSTHROW("FaceRecognizer.train takes a list of [<int> label, image] tuples") JSTHROW("FaceRecognizer.train takes a list of [<int> label, image] tuples")
} }
// Iterate through [[label, image], ...] etc, and add matrix / label to vectors // Iterate through [[label, image], ...] etc, and add matrix / label to vectors
// const Local<Array> tuples = v8::Array::Cast(*args[0]); // const Local<Array> tuples = v8::Array::Cast(*info[0]);
const Local<Array> tuples = Local<Array>::Cast(args[0]); const Local<Array> tuples = Local<Array>::Cast(info[0]);
const uint32_t length = tuples->Length(); const uint32_t length = tuples->Length();
for (uint32_t i=0; i<length; ++i) { for (uint32_t i=0; i<length; ++i) {
@ -167,7 +167,7 @@ Handle<Value> UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args,
labels->push_back(label); labels->push_back(label);
images->push_back(im); images->push_back(im);
} }
return NanUndefined(); return Nan::Undefined();
} }
NAN_METHOD(FaceRecognizerWrap::TrainSync) { NAN_METHOD(FaceRecognizerWrap::TrainSync) {
@ -176,14 +176,14 @@ NAN_METHOD(FaceRecognizerWrap::TrainSync) {
cv::vector<cv::Mat> images; cv::vector<cv::Mat> images;
cv::vector<int> labels; cv::vector<int> labels;
Handle<Value> exception = UnwrapTrainingData(args, &images, &labels); Local<Value> exception = UnwrapTrainingData(info, &images, &labels);
if (!exception->IsUndefined()) { if (!exception->IsUndefined()) {
NanReturnValue(exception); // FIXME: not too sure about returning exceptions like this info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this
} }
self->rec->train(images, labels); self->rec->train(images, labels);
NanReturnUndefined(); return;
} }
NAN_METHOD(FaceRecognizerWrap::UpdateSync) { NAN_METHOD(FaceRecognizerWrap::UpdateSync) {
@ -199,20 +199,20 @@ NAN_METHOD(FaceRecognizerWrap::UpdateSync) {
cv::vector<cv::Mat> images; cv::vector<cv::Mat> images;
cv::vector<int> labels; cv::vector<int> labels;
Handle<Value> exception = UnwrapTrainingData(args, &images, &labels); Local<Value> exception = UnwrapTrainingData(info, &images, &labels);
if (!exception->IsUndefined()) { if (!exception->IsUndefined()) {
JSTHROW(exception); JSTHROW(exception);
} }
self->rec->update(images, labels); self->rec->update(images, labels);
NanReturnUndefined(); return;
} }
NAN_METHOD(FaceRecognizerWrap::PredictSync) { NAN_METHOD(FaceRecognizerWrap::PredictSync) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
cv::Mat im = fromMatrixOrFilename(args[0]); // TODO CHECK! cv::Mat im = fromMatrixOrFilename(info[0]); // TODO CHECK!
cv::cvtColor(im, im, CV_RGB2GRAY); cv::cvtColor(im, im, CV_RGB2GRAY);
// int predictedLabel = self->rec->predict(im); // int predictedLabel = self->rec->predict(im);
@ -220,46 +220,46 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync) {
double confidence = 0.0; double confidence = 0.0;
self->rec->predict(im, predictedLabel, confidence); self->rec->predict(im, predictedLabel, confidence);
v8::Local<v8::Object> res = NanNew<Object>(); v8::Local<v8::Object> res = Nan::New<Object>();
res->Set(NanNew("id"), NanNew<Number>(predictedLabel)); res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
res->Set(NanNew("confidence"), NanNew<Number>(confidence)); res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
NanReturnValue(res); info.GetReturnValue().Set(res);
} }
NAN_METHOD(FaceRecognizerWrap::SaveSync) { NAN_METHOD(FaceRecognizerWrap::SaveSync) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
if (!args[0]->IsString()) { if (!info[0]->IsString()) {
JSTHROW("Save takes a filename") JSTHROW("Save takes a filename")
} }
std::string filename = std::string(*NanAsciiString(args[0]->ToString())); std::string filename = std::string(*Nan::Utf8String(info[0]->ToString()));
self->rec->save(filename); self->rec->save(filename);
NanReturnUndefined(); return;
} }
NAN_METHOD(FaceRecognizerWrap::LoadSync) { NAN_METHOD(FaceRecognizerWrap::LoadSync) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
if (!args[0]->IsString()) { if (!info[0]->IsString()) {
JSTHROW("Load takes a filename") JSTHROW("Load takes a filename")
} }
std::string filename = std::string(*NanAsciiString(args[0]->ToString())); std::string filename = std::string(*Nan::Utf8String(info[0]->ToString()));
self->rec->load(filename); self->rec->load(filename);
NanReturnUndefined(); return;
} }
NAN_METHOD(FaceRecognizerWrap::GetMat) { NAN_METHOD(FaceRecognizerWrap::GetMat) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
if (!args[0]->IsString()) { if (!info[0]->IsString()) {
JSTHROW("getMat takes a key") JSTHROW("getMat takes a key")
} }
std::string key = std::string(*NanAsciiString(args[0]->ToString())); std::string key = std::string(*Nan::Utf8String(info[0]->ToString()));
cv::Mat m = self->rec->getMat(key); cv::Mat m = self->rec->getMat(key);
Local<Object> im = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im); Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im);
img->mat = m; img->mat = m;
NanReturnValue(im); info.GetReturnValue().Set(im);
} }
#endif // End version > 2.4 #endif // End version > 2.4

6
src/FaceRecognizer.h
View File

@ -4,13 +4,13 @@
#include "opencv2/contrib/contrib.hpp" #include "opencv2/contrib/contrib.hpp"
class FaceRecognizerWrap: public node::ObjectWrap { class FaceRecognizerWrap: public Nan::ObjectWrap {
public: public:
cv::Ptr<cv::FaceRecognizer> rec; cv::Ptr<cv::FaceRecognizer> rec;
int typ; int typ;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, int type); FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, int type);

32
src/Features2d.cc
View File

@ -5,16 +5,16 @@
#if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4)) #if ((CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >=4))
void Features::Init(Handle<Object> target) { void Features::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
NODE_SET_METHOD(target, "ImageSimilarity", Similarity); Nan::SetMethod(target, "ImageSimilarity", Similarity);
} }
class AsyncDetectSimilarity: public NanAsyncWorker { class AsyncDetectSimilarity: public Nan::AsyncWorker {
public: public:
AsyncDetectSimilarity(NanCallback *callback, cv::Mat image1, cv::Mat image2) : AsyncDetectSimilarity(Nan::Callback *callback, cv::Mat image1, cv::Mat image2) :
NanAsyncWorker(callback), Nan::AsyncWorker(callback),
image1(image1), image1(image1),
image2(image2), image2(image2),
dissimilarity(0) { dissimilarity(0) {
@ -80,12 +80,12 @@ public:
} }
void HandleOKCallback() { void HandleOKCallback() {
NanScope(); Nan::HandleScope scope;
Handle<Value> argv[2]; Local<Value> argv[2];
argv[0] = NanNull(); argv[0] = Nan::Null();
argv[1] = NanNew<Number>(dissimilarity); argv[1] = Nan::New<Number>(dissimilarity);
callback->Call(2, argv); callback->Call(2, argv);
} }
@ -97,17 +97,17 @@ private:
}; };
NAN_METHOD(Features::Similarity) { NAN_METHOD(Features::Similarity) {
NanScope(); Nan::HandleScope scope;
REQ_FUN_ARG(2, cb); REQ_FUN_ARG(2, cb);
cv::Mat image1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject())->mat; cv::Mat image1 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject())->mat;
cv::Mat image2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject())->mat; cv::Mat image2 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject())->mat;
NanCallback *callback = new NanCallback(cb.As<Function>()); Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
NanAsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) ); Nan::AsyncQueueWorker( new AsyncDetectSimilarity(callback, image1, image2) );
NanReturnUndefined(); return;
} }
#endif #endif

6
src/Features2d.h
View File

@ -5,10 +5,10 @@
#include <opencv2/core/core.hpp> #include <opencv2/core/core.hpp>
#include <opencv2/features2d/features2d.hpp> #include <opencv2/features2d/features2d.hpp>
class Features: public node::ObjectWrap { class Features: public Nan::ObjectWrap {
public: public:
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(Similarity); static NAN_METHOD(Similarity);
}; };

56
src/HighGUI.cc
View File

@ -2,41 +2,41 @@
#include "OpenCV.h" #include "OpenCV.h"
#include "Matrix.h" #include "Matrix.h"
Persistent<FunctionTemplate> NamedWindow::constructor; Nan::Persistent<FunctionTemplate> NamedWindow::constructor;
void NamedWindow::Init(Handle<Object> target) { void NamedWindow::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Constructor // Constructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(NamedWindow::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(NamedWindow::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("NamedWindow")); ctor->SetClassName(Nan::New("NamedWindow").ToLocalChecked());
// Prototype // Prototype
NODE_SET_PROTOTYPE_METHOD(ctor, "show", Show); Nan::SetPrototypeMethod(ctor, "show", Show);
NODE_SET_PROTOTYPE_METHOD(ctor, "destroy", Destroy); Nan::SetPrototypeMethod(ctor, "destroy", Destroy);
NODE_SET_PROTOTYPE_METHOD(ctor, "blockingWaitKey", BlockingWaitKey); Nan::SetPrototypeMethod(ctor, "blockingWaitKey", BlockingWaitKey);
target->Set(NanNew("NamedWindow"), ctor->GetFunction()); target->Set(Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction());
}; };
NAN_METHOD(NamedWindow::New) { NAN_METHOD(NamedWindow::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
JSTHROW_TYPE("Cannot Instantiate without new") JSTHROW_TYPE("Cannot Instantiate without new")
} }
NamedWindow* win; NamedWindow* win;
if (args.Length() == 1) { if (info.Length() == 1) {
win = new NamedWindow(std::string(*NanAsciiString(args[0]->ToString())), 0); win = new NamedWindow(std::string(*Nan::Utf8String(info[0]->ToString())), 0);
} else { //if (args.Length() == 2){ } else { //if (info.Length() == 2){
win = new NamedWindow(std::string(*NanAsciiString(args[0]->ToString())), 0); win = new NamedWindow(std::string(*Nan::Utf8String(info[0]->ToString())), 0);
} }
win->Wrap(args.Holder()); win->Wrap(info.Holder());
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
NamedWindow::NamedWindow(const std::string& name, int f) { NamedWindow::NamedWindow(const std::string& name, int f) {
@ -47,38 +47,38 @@ NamedWindow::NamedWindow(const std::string& name, int f) {
NAN_METHOD(NamedWindow::Show) { NAN_METHOD(NamedWindow::Show) {
SETUP_FUNCTION(NamedWindow) SETUP_FUNCTION(NamedWindow)
Matrix *im = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix *im = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
try { try {
cv::imshow(self->winname, im->mat); cv::imshow(self->winname, im->mat);
} catch (cv::Exception& e) { } catch (cv::Exception& e) {
const char* err_msg = e.what(); const char* err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
} }
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
NAN_METHOD(NamedWindow::Destroy) { NAN_METHOD(NamedWindow::Destroy) {
SETUP_FUNCTION(NamedWindow) SETUP_FUNCTION(NamedWindow)
cv::destroyWindow(self->winname); cv::destroyWindow(self->winname);
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
NAN_METHOD(NamedWindow::BlockingWaitKey) { NAN_METHOD(NamedWindow::BlockingWaitKey) {
NanScope(); Nan::HandleScope scope;
//SETUP_FUNCTION(NamedWindow) //SETUP_FUNCTION(NamedWindow)
int time = 0; int time = 0;
if (args.Length() > 1) { if (info.Length() > 1) {
time = args[1]->IntegerValue(); time = info[1]->IntegerValue();
} else { } else {
if (args.Length() > 0) { if (info.Length() > 0) {
time = args[0]->IntegerValue(); time = info[0]->IntegerValue();
} }
} }
int res = cv::waitKey(time); int res = cv::waitKey(time);
NanReturnValue(NanNew<Number>(res)); info.GetReturnValue().Set(Nan::New<Number>(res));
} }

6
src/HighGUI.h
View File

@ -1,12 +1,12 @@
#include "OpenCV.h" #include "OpenCV.h"
class NamedWindow: public node::ObjectWrap { class NamedWindow: public Nan::ObjectWrap {
public: public:
std::string winname; std::string winname;
int flags; int flags;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
NamedWindow(const std::string& winname, int flags); NamedWindow(const std::string& winname, int flags);

90
src/ImgProc.cc
View File

@ -1,35 +1,35 @@
#include "ImgProc.h" #include "ImgProc.h"
#include "Matrix.h" #include "Matrix.h"
void ImgProc::Init(Handle<Object> target) { void ImgProc::Init(Local<Object> target) {
Persistent<Object> inner; Nan::Persistent<Object> inner;
Local<Object> obj = NanNew<Object>(); Local<Object> obj = Nan::New<Object>();
NanAssignPersistent(inner, obj); inner.Reset(obj);
NODE_SET_METHOD(obj, "undistort", Undistort); Nan::SetMethod(obj, "undistort", Undistort);
NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap); Nan::SetMethod(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
NODE_SET_METHOD(obj, "remap", Remap); Nan::SetMethod(obj, "remap", Remap);
target->Set(NanNew("imgproc"), obj); target->Set(Nan::New("imgproc").ToLocalChecked(), obj);
} }
// cv::undistort // cv::undistort
NAN_METHOD(ImgProc::Undistort) { NAN_METHOD(ImgProc::Undistort) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the image // Arg 0 is the image
Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Mat inputImage = m0->mat; cv::Mat inputImage = m0->mat;
// Arg 1 is the camera matrix // Arg 1 is the camera matrix
Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject()); Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
cv::Mat K = m1->mat; cv::Mat K = m1->mat;
// Arg 2 is the distortion coefficents // Arg 2 is the distortion coefficents
Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject()); Matrix* m2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
cv::Mat dist = m2->mat; cv::Mat dist = m2->mat;
// Make an mat to hold the result image // Make an mat to hold the result image
@ -39,51 +39,51 @@ NAN_METHOD(ImgProc::Undistort) {
cv::undistort(inputImage, outputImage, K, dist); cv::undistort(inputImage, outputImage, K, dist);
// Wrap the output image // Wrap the output image
Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap); Matrix *outMatrix = Nan::ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
outMatrix->mat = outputImage; outMatrix->mat = outputImage;
// Return the output image // Return the output image
NanReturnValue(outMatrixWrap); info.GetReturnValue().Set(outMatrixWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::initUndistortRectifyMap // cv::initUndistortRectifyMap
NAN_METHOD(ImgProc::InitUndistortRectifyMap) { NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Arg 0 is the camera matrix // Arg 0 is the camera matrix
Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Mat K = m0->mat; cv::Mat K = m0->mat;
// Arg 1 is the distortion coefficents // Arg 1 is the distortion coefficents
Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject()); Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
cv::Mat dist = m1->mat; cv::Mat dist = m1->mat;
// Arg 2 is the recification transformation // Arg 2 is the recification transformation
Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject()); Matrix* m2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
cv::Mat R = m2->mat; cv::Mat R = m2->mat;
// Arg 3 is the new camera matrix // Arg 3 is the new camera matrix
Matrix* m3 = ObjectWrap::Unwrap<Matrix>(args[3]->ToObject()); Matrix* m3 = Nan::ObjectWrap::Unwrap<Matrix>(info[3]->ToObject());
cv::Mat newK = m3->mat; cv::Mat newK = m3->mat;
// Arg 4 is the image size // Arg 4 is the image size
cv::Size imageSize; cv::Size imageSize;
if (args[4]->IsArray()) { if (info[4]->IsArray()) {
Local<Object> v8sz = args[4]->ToObject(); Local<Object> v8sz = info[4]->ToObject();
imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
} else { } else {
JSTHROW_TYPE("Must pass image size"); JSTHROW_TYPE("Must pass image size");
} }
// Arg 5 is the first map type, skip for now // Arg 5 is the first map type, skip for now
int m1type = args[5]->IntegerValue(); int m1type = info[5]->IntegerValue();
// Make matrices to hold the output maps // Make matrices to hold the output maps
cv::Mat map1, map2; cv::Mat map1, map2;
@ -92,49 +92,49 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
cv::initUndistortRectifyMap(K, dist, R, newK, imageSize, m1type, map1, map2); cv::initUndistortRectifyMap(K, dist, R, newK, imageSize, m1type, map1, map2);
// Wrap the output maps // Wrap the output maps
Local<Object> map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> map1Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map1Matrix = ObjectWrap::Unwrap<Matrix>(map1Wrap); Matrix *map1Matrix = Nan::ObjectWrap::Unwrap<Matrix>(map1Wrap);
map1Matrix->mat = map1; map1Matrix->mat = map1;
Local<Object> map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> map2Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map2Matrix = ObjectWrap::Unwrap<Matrix>(map2Wrap); Matrix *map2Matrix = Nan::ObjectWrap::Unwrap<Matrix>(map2Wrap);
map2Matrix->mat = map2; map2Matrix->mat = map2;
// Make a return object with the two maps // Make a return object with the two maps
Local<Object> ret = NanNew<Object>(); Local<Object> ret = Nan::New<Object>();
ret->Set(NanNew<String>("map1"), map1Wrap); ret->Set(Nan::New<String>("map1").ToLocalChecked(), map1Wrap);
ret->Set(NanNew<String>("map2"), map2Wrap); ret->Set(Nan::New<String>("map2").ToLocalChecked(), map2Wrap);
// Return the maps // Return the maps
NanReturnValue(ret); info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// cv::remap // cv::remap
NAN_METHOD(ImgProc::Remap) { NAN_METHOD(ImgProc::Remap) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the image // Arg 0 is the image
Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Mat inputImage = m0->mat; cv::Mat inputImage = m0->mat;
// Arg 1 is the first map // Arg 1 is the first map
Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject()); Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
cv::Mat map1 = m1->mat; cv::Mat map1 = m1->mat;
// Arg 2 is the second map // Arg 2 is the second map
Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject()); Matrix* m2 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject());
cv::Mat map2 = m2->mat; cv::Mat map2 = m2->mat;
// Arg 3 is the interpolation mode // Arg 3 is the interpolation mode
int interpolation = args[3]->IntegerValue(); int interpolation = info[3]->IntegerValue();
// Args 4, 5 border settings, skipping for now // Args 4, 5 border settings, skipping for now
@ -145,15 +145,15 @@ NAN_METHOD(ImgProc::Remap) {
cv::remap(inputImage, outputImage, map1, map2, interpolation); cv::remap(inputImage, outputImage, map1, map2, interpolation);
// Wrap the output image // Wrap the output image
Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> outMatrixWrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap); Matrix *outMatrix = Nan::ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
outMatrix->mat = outputImage; outMatrix->mat = outputImage;
// Return the image // Return the image
NanReturnValue(outMatrixWrap); info.GetReturnValue().Set(outMatrixWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }

4
src/ImgProc.h
View File

@ -6,9 +6,9 @@
/** /**
* Implementation of imgproc.hpp functions * Implementation of imgproc.hpp functions
*/ */
class ImgProc: public node::ObjectWrap { class ImgProc: public Nan::ObjectWrap {
public: public:
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(Undistort); static NAN_METHOD(Undistort);
static NAN_METHOD(InitUndistortRectifyMap); static NAN_METHOD(InitUndistortRectifyMap);
static NAN_METHOD(Remap); static NAN_METHOD(Remap);

1430
src/Matrix.cc
View File

File diff suppressed because it is too large Load Diff

60
src/Matrix.h
View File

@ -1,11 +1,11 @@
#include "OpenCV.h" #include "OpenCV.h"
class Matrix: public node::ObjectWrap { class Matrix: public Nan::ObjectWrap {
public: public:
cv::Mat mat; cv::Mat mat;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
Matrix(); Matrix();
Matrix(cv::Mat other, cv::Rect roi); Matrix(cv::Mat other, cv::Rect roi);
@ -119,34 +119,34 @@ public:
JSFUNC(Release) JSFUNC(Release)
/* /*
static Handle<Value> Val(const Arguments& args); static Handle<Value> Val(const Arguments& info);
static Handle<Value> RowRange(const Arguments& args); static Handle<Value> RowRange(const Arguments& info);
static Handle<Value> ColRange(const Arguments& args); static Handle<Value> ColRange(const Arguments& info);
static Handle<Value> Diag(const Arguments& args); static Handle<Value> Diag(const Arguments& info);
static Handle<Value> Clone(const Arguments& args); static Handle<Value> Clone(const Arguments& info);
static Handle<Value> CopyTo(const Arguments& args); static Handle<Value> CopyTo(const Arguments& info);
static Handle<Value> ConvertTo(const Arguments& args); static Handle<Value> ConvertTo(const Arguments& info);
static Handle<Value> AssignTo(const Arguments& args); static Handle<Value> AssignTo(const Arguments& info);
static Handle<Value> SetTo(const Arguments& args); static Handle<Value> SetTo(const Arguments& info);
static Handle<Value> Reshape(const Arguments& args); static Handle<Value> Reshape(const Arguments& info);
static Handle<Value> Transpose(const Arguments& args); static Handle<Value> Transpose(const Arguments& info);
static Handle<Value> Invert(const Arguments& args); static Handle<Value> Invert(const Arguments& info);
static Handle<Value> Multiply(const Arguments& args); static Handle<Value> Multiply(const Arguments& info);
static Handle<Value> Cross(const Arguments& args); static Handle<Value> Cross(const Arguments& info);
static Handle<Value> Dot(const Arguments& args); static Handle<Value> Dot(const Arguments& info);
static Handle<Value> Zeroes(const Arguments& args); static Handle<Value> Zeroes(const Arguments& info);
static Handle<Value> Ones(const Arguments& args); static Handle<Value> Ones(const Arguments& info);
// create, increment, release // create, increment, release
static Handle<Value> PushBack(const Arguments& args); static Handle<Value> PushBack(const Arguments& info);
static Handle<Value> PopBack(const Arguments& args); static Handle<Value> PopBack(const Arguments& info);
static Handle<Value> Total(const Arguments& args); static Handle<Value> Total(const Arguments& info);
static Handle<Value> IsContinous(const Arguments& args); static Handle<Value> IsContinous(const Arguments& info);
static Handle<Value> Type(const Arguments& args); static Handle<Value> Type(const Arguments& info);
static Handle<Value> Depth(const Arguments& args); static Handle<Value> Depth(const Arguments& info);
static Handle<Value> Channels(const Arguments& args); static Handle<Value> Channels(const Arguments& info);
static Handle<Value> StepOne(const Arguments& args); static Handle<Value> StepOne(const Arguments& info);
static Handle<Value> GetPerspectiveTransform(const Arguments& args); static Handle<Value> GetPerspectiveTransform(const Arguments& info);
static Handle<Value> WarpPerspective(const Arguments& args); static Handle<Value> WarpPerspective(const Arguments& info);
*/ */
}; };

46
src/OpenCV.cc
View File

@ -2,67 +2,67 @@
#include "Matrix.h" #include "Matrix.h"
#include <nan.h> #include <nan.h>
void OpenCV::Init(Handle<Object> target) { void OpenCV::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Version string. // Version string.
char out [21]; char out [21];
int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION); int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION);
target->Set(NanNew<String>("version"), NanNew<String>(out, n)); target->Set(Nan::New<String>("version").ToLocalChecked(), Nan::New<String>(out, n).ToLocalChecked());
NODE_SET_METHOD(target, "readImage", ReadImage); Nan::SetMethod(target, "readImage", ReadImage);
} }
NAN_METHOD(OpenCV::ReadImage) { NAN_METHOD(OpenCV::ReadImage) {
NanEscapableScope(); Nan::EscapableHandleScope scope;
REQ_FUN_ARG(1, cb); REQ_FUN_ARG(1, cb);
Local<Value> argv[2]; Local<Value> argv[2];
argv[0] = NanNull(); argv[0] = Nan::Null();
Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im_h = Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h); Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_h);
argv[1] = im_h; argv[1] = im_h;
try { try {
cv::Mat mat; cv::Mat mat;
if (args[0]->IsNumber() && args[1]->IsNumber()) { if (info[0]->IsNumber() && info[1]->IsNumber()) {
int width, height; int width, height;
width = args[0]->Uint32Value(); width = info[0]->Uint32Value();
height = args[1]->Uint32Value(); height = info[1]->Uint32Value();
mat = *(new cv::Mat(width, height, CV_64FC1)); mat = *(new cv::Mat(width, height, CV_64FC1));
} else if (args[0]->IsString()) { } else if (info[0]->IsString()) {
std::string filename = std::string(*NanUtf8String(args[0]->ToString())); std::string filename = std::string(*Nan::Utf8String(info[0]->ToString()));
mat = cv::imread(filename); mat = cv::imread(filename);
} else if (Buffer::HasInstance(args[0])) { } else if (Buffer::HasInstance(info[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject()); uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject());
unsigned len = Buffer::Length(args[0]->ToObject()); unsigned len = Buffer::Length(info[0]->ToObject());
cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf); cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf);
mat = cv::imdecode(*mbuf, -1); mat = cv::imdecode(*mbuf, -1);
if (mat.empty()) { if (mat.empty()) {
argv[0] = NanError("Error loading file"); argv[0] = Nan::Error("Error loading file");
} }
} }
img->mat = mat; img->mat = mat;
} catch (cv::Exception& e) { } catch (cv::Exception& e) {
argv[0] = NanError(e.what()); argv[0] = Nan::Error(e.what());
argv[1] = NanNull(); argv[1] = Nan::Null();
} }
TryCatch try_catch; Nan::TryCatch try_catch;
cb->Call(NanGetCurrentContext()->Global(), 2, argv); cb->Call(Nan::GetCurrentContext()->Global(), 2, argv);
if (try_catch.HasCaught()) { if (try_catch.HasCaught()) {
FatalException(try_catch); Nan::FatalException(try_catch);
} }
NanReturnUndefined(); return;
} }

26
src/OpenCV.h
View File

@ -15,36 +15,36 @@ using namespace v8;
using namespace node; using namespace node;
#define REQ_FUN_ARG(I, VAR) \ #define REQ_FUN_ARG(I, VAR) \
if (args.Length() <= (I) || !args[I]->IsFunction()) \ if (info.Length() <= (I) || !info[I]->IsFunction()) \
return NanThrowTypeError("Argument " #I " must be a function"); \ return Nan::ThrowTypeError("Argument " #I " must be a function"); \
Local<Function> VAR = Local<Function>::Cast(args[I]); Local<Function> VAR = Local<Function>::Cast(info[I]);
#define SETUP_FUNCTION(TYP) \ #define SETUP_FUNCTION(TYP) \
NanScope(); \ Nan::HandleScope scope; \
TYP *self = ObjectWrap::Unwrap<TYP>(args.This()); TYP *self = Nan::ObjectWrap::Unwrap<TYP>(info.This());
#define JSFUNC(NAME) \ #define JSFUNC(NAME) \
static NAN_METHOD(NAME); static NAN_METHOD(NAME);
#define JSTHROW_TYPE(ERR) \ #define JSTHROW_TYPE(ERR) \
NanThrowTypeError( ERR ); Nan::ThrowTypeError( ERR );
#define JSTHROW(ERR) \ #define JSTHROW(ERR) \
NanThrowError( ERR ); Nan::ThrowError( ERR );
#define INT_FROM_ARGS(NAME, IND) \ #define INT_FROM_ARGS(NAME, IND) \
if (args[IND]->IsInt32()){ \ if (info[IND]->IsInt32()){ \
NAME = args[IND]->Uint32Value(); \ NAME = info[IND]->Uint32Value(); \
} }
#define DOUBLE_FROM_ARGS(NAME, IND) \ #define DOUBLE_FROM_ARGS(NAME, IND) \
if (args[IND]->IsInt32()){ \ if (info[IND]->IsInt32()){ \
NAME = args[IND]->NumberValue(); \ NAME = info[IND]->NumberValue(); \
} }
class OpenCV: public node::ObjectWrap { class OpenCV: public Nan::ObjectWrap {
public: public:
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(ReadImage); static NAN_METHOD(ReadImage);
}; };

62
src/Point.cc
View File

@ -1,72 +1,72 @@
#include "Point.h" #include "Point.h"
#include "OpenCV.h" #include "OpenCV.h"
v8::Persistent<FunctionTemplate> Point::constructor; Nan::Persistent<FunctionTemplate> Point::constructor;
void Point::Init(Handle<Object> target) { void Point::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
// Constructor // Constructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Point::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(Point::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("Point")); ctor->SetClassName(Nan::New("Point").ToLocalChecked());
// Prototype // Prototype
Local<ObjectTemplate> proto = ctor->PrototypeTemplate(); Local<ObjectTemplate> proto = ctor->PrototypeTemplate();
proto->SetAccessor(NanNew("x"), GetX, RaiseImmutable); Nan::SetAccessor(proto, Nan::New("x").ToLocalChecked(), GetX, RaiseImmutable);
proto->SetAccessor(NanNew("y"), GetY, RaiseImmutable); Nan::SetAccessor(proto, Nan::New("y").ToLocalChecked(), GetY, RaiseImmutable);
NODE_SET_PROTOTYPE_METHOD(ctor, "dot", Dot); Nan::SetPrototypeMethod(ctor, "dot", Dot);
target->Set(NanNew("Point"), ctor->GetFunction()); target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction());
}; };
NAN_METHOD(Point::New) { NAN_METHOD(Point::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
return NanThrowTypeError("Cannot Instantiate without new"); return Nan::ThrowTypeError("Cannot Instantiate without new");
} }
double x = 0, y = 0; double x = 0, y = 0;
if (args[0]->IsNumber()) { if (info[0]->IsNumber()) {
x = args[0]->NumberValue(); x = info[0]->NumberValue();
} }
if (args[1]->IsNumber()) { if (info[1]->IsNumber()) {
y = args[1]->NumberValue(); y = info[1]->NumberValue();
} }
Point *pt = new Point(x, y); Point *pt = new Point(x, y);
pt->Wrap(args.This()); pt->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
NAN_GETTER(Point::GetX) { NAN_GETTER(Point::GetX) {
NanScope(); Nan::HandleScope scope;
Point *pt = ObjectWrap::Unwrap<Point>(args.This()); Point *pt = Nan::ObjectWrap::Unwrap<Point>(info.This());
NanReturnValue(NanNew<Number>(pt->point.x)); info.GetReturnValue().Set(Nan::New<Number>(pt->point.x));
} }
NAN_GETTER(Point::GetY) { NAN_GETTER(Point::GetY) {
NanScope(); Nan::HandleScope scope;
Point *pt = ObjectWrap::Unwrap<Point>(args.This()); Point *pt = Nan::ObjectWrap::Unwrap<Point>(info.This());
NanReturnValue(NanNew<Number>(pt->point.y)); info.GetReturnValue().Set(Nan::New<Number>(pt->point.y));
} }
NAN_SETTER(Point::RaiseImmutable) { NAN_SETTER(Point::RaiseImmutable) {
NanThrowTypeError("Point is immutable"); Nan::ThrowTypeError("Point is immutable");
} }
NAN_METHOD(Point::Dot) { NAN_METHOD(Point::Dot) {
NanScope(); Nan::HandleScope scope;
Point *p1 = ObjectWrap::Unwrap<Point>(args.This()); Point *p1 = Nan::ObjectWrap::Unwrap<Point>(info.This());
Point *p2 = ObjectWrap::Unwrap<Point>(args[0]->ToObject()); Point *p2 = Nan::ObjectWrap::Unwrap<Point>(info[0]->ToObject());
// Since V 2.3 Native Dot no longer supported // Since V 2.3 Native Dot no longer supported
NanReturnValue(NanNew<Number>(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); info.GetReturnValue().Set(Nan::New<Number>(p1->point.x * p2->point.x + p1->point.y * p2->point.y));
} }
Point::Point(double x, double y) : Point::Point(double x, double y) :
ObjectWrap() { Nan::ObjectWrap() {
point = cvPoint2D32f(x, y); point = cvPoint2D32f(x, y);
} }

6
src/Point.h
View File

@ -2,11 +2,11 @@
#include "OpenCV.h" #include "OpenCV.h"
class Point: public node::ObjectWrap { class Point: public Nan::ObjectWrap {
public: public:
CvPoint2D32f point; CvPoint2D32f point;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
Point(double x, double y); Point(double x, double y);

224
src/Stereo.cc
View File

@ -4,54 +4,54 @@
// Block matching // Block matching
v8::Persistent<FunctionTemplate> StereoBM::constructor; Nan::Persistent<FunctionTemplate> StereoBM::constructor;
void StereoBM::Init(Handle<Object> target) { void StereoBM::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoBM::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoBM::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("StereoBM")); ctor->SetClassName(Nan::New("StereoBM").ToLocalChecked());
NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); Nan::SetPrototypeMethod(ctor, "compute", Compute);
ctor->Set(NanNew<String>("BASIC_PRESET"), NanNew<Integer>((int)cv::StereoBM::BASIC_PRESET)); ctor->Set(Nan::New<String>("BASIC_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::BASIC_PRESET));
ctor->Set(NanNew<String>("FISH_EYE_PRESET"), NanNew<Integer>((int)cv::StereoBM::FISH_EYE_PRESET)); ctor->Set(Nan::New<String>("FISH_EYE_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::FISH_EYE_PRESET));
ctor->Set(NanNew<String>("NARROW_PRESET"), NanNew<Integer>((int)cv::StereoBM::NARROW_PRESET)); ctor->Set(Nan::New<String>("NARROW_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::NARROW_PRESET));
target->Set(NanNew("StereoBM"), ctor->GetFunction()); target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(StereoBM::New) { NAN_METHOD(StereoBM::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new"); Nan::ThrowTypeError("Cannot instantiate without new");
} }
StereoBM *stereo; StereoBM *stereo;
if (args.Length() == 0) { if (info.Length() == 0) {
stereo = new StereoBM(); stereo = new StereoBM();
} else if (args.Length() == 1) { } else if (info.Length() == 1) {
// preset // preset
stereo = new StereoBM(args[0]->IntegerValue()); stereo = new StereoBM(info[0]->IntegerValue());
} else if (args.Length() == 2) { } else if (info.Length() == 2) {
// preset, disparity search range // preset, disparity search range
stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue()); stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue());
} else { } else {
stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
// preset, disparity search range, sum of absolute differences window size // preset, disparity search range, sum of absolute differences window size
args[2]->IntegerValue()); info[2]->IntegerValue());
} }
stereo->Wrap(args.Holder()); stereo->Wrap(info.Holder());
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) : StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) :
ObjectWrap(), Nan::ObjectWrap(),
stereo(preset, ndisparities, SADWindowSize) { stereo(preset, ndisparities, SADWindowSize) {
} }
@ -63,17 +63,17 @@ NAN_METHOD(StereoBM::Compute) {
// Get the arguments // Get the arguments
// Arg 0, the 'left' image // Arg 0, the 'left' image
Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Mat left = m0->mat; cv::Mat left = m0->mat;
// Arg 1, the 'right' image // Arg 1, the 'right' image
Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject()); Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
cv::Mat right = m1->mat; cv::Mat right = m1->mat;
// Optional 3rd arg, the disparty depth // Optional 3rd arg, the disparty depth
int type = CV_16S; int type = CV_16S;
if (args.Length() > 2) { if (info.Length() > 2) {
type = args[2]->IntegerValue(); type = info[2]->IntegerValue();
} }
// Compute stereo using the block matching algorithm // Compute stereo using the block matching algorithm
@ -82,108 +82,108 @@ NAN_METHOD(StereoBM::Compute) {
// Wrap the returned disparity map // Wrap the returned disparity map
Local < Object > disparityWrap = Local < Object > disparityWrap =
NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap); Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap);
disp->mat = disparity; disp->mat = disparity;
NanReturnValue(disparityWrap); info.GetReturnValue().Set(disparityWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// Semi-Global Block matching // Semi-Global Block matching
v8::Persistent<FunctionTemplate> StereoSGBM::constructor; Nan::Persistent<FunctionTemplate> StereoSGBM::constructor;
void StereoSGBM::Init(Handle<Object> target) { void StereoSGBM::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoSGBM::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoSGBM::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("StereoSGBM")); ctor->SetClassName(Nan::New("StereoSGBM").ToLocalChecked());
NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); Nan::SetPrototypeMethod(ctor, "compute", Compute);
target->Set(NanNew("StereoSGBM"), ctor->GetFunction()); target->Set(Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(StereoSGBM::New) { NAN_METHOD(StereoSGBM::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) { if (info.This()->InternalFieldCount() == 0) {
NanThrowTypeError("Cannot instantiate without new"); Nan::ThrowTypeError("Cannot instantiate without new");
} }
StereoSGBM *stereo; StereoSGBM *stereo;
if (args.Length() == 0) { if (info.Length() == 0) {
stereo = new StereoSGBM(); stereo = new StereoSGBM();
} else { } else {
// If passing arguments, must pass the first 3 at least // If passing arguments, must pass the first 3 at least
if (args.Length() >= 3) { if (info.Length() >= 3) {
switch (args.Length()) { switch (info.Length()) {
case 3: case 3:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue()); info[2]->IntegerValue());
break; break;
case 4: case 4:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue()); info[2]->IntegerValue(), info[3]->IntegerValue());
break; break;
case 5: case 5:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue()); info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue());
break; break;
case 6: case 6:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
args[5]->IntegerValue()); info[5]->IntegerValue());
break; break;
case 7: case 7:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue()); info[5]->IntegerValue(), info[6]->IntegerValue());
break; break;
case 8: case 8:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue()); info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue());
break; break;
case 9: case 9:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(), info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(),
args[8]->IntegerValue()); info[8]->IntegerValue());
break; break;
case 10: case 10:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(), info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(),
args[8]->IntegerValue(), args[9]->IntegerValue()); info[8]->IntegerValue(), info[9]->IntegerValue());
break; break;
default: default:
stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(),
args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(),
args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(), info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(),
args[8]->IntegerValue(), args[9]->IntegerValue(), args[10]->ToBoolean()->Value()); info[8]->IntegerValue(), info[9]->IntegerValue(), info[10]->ToBoolean()->Value());
break; break;
} }
} else { } else {
NanThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize"); Nan::ThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize");
NanReturnUndefined(); return;
} }
} }
stereo->Wrap(args.Holder()); stereo->Wrap(info.Holder());
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
StereoSGBM::StereoSGBM() : StereoSGBM::StereoSGBM() :
ObjectWrap(), Nan::ObjectWrap(),
stereo() { stereo() {
} }
@ -191,7 +191,7 @@ StereoSGBM::StereoSGBM() :
StereoSGBM::StereoSGBM(int minDisparity, int ndisparities, int SADWindowSize, StereoSGBM::StereoSGBM(int minDisparity, int ndisparities, int SADWindowSize,
int p1, int p2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int p1, int p2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio,
int speckleWindowSize, int speckleRange, bool fullDP) : int speckleWindowSize, int speckleRange, bool fullDP) :
ObjectWrap(), Nan::ObjectWrap(),
stereo(minDisparity, ndisparities, SADWindowSize, p1, p2, disp12MaxDiff, stereo(minDisparity, ndisparities, SADWindowSize, p1, p2, disp12MaxDiff,
preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP) { preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP) {
} }
@ -204,11 +204,11 @@ NAN_METHOD(StereoSGBM::Compute) {
// Get the arguments // Get the arguments
// Arg 0, the 'left' image // Arg 0, the 'left' image
Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Mat left = m0->mat; cv::Mat left = m0->mat;
// Arg 1, the 'right' image // Arg 1, the 'right' image
Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject()); Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
cv::Mat right = m1->mat; cv::Mat right = m1->mat;
// Compute stereo using the block matching algorithm // Compute stereo using the block matching algorithm
@ -217,59 +217,59 @@ NAN_METHOD(StereoSGBM::Compute) {
// Wrap the returned disparity map // Wrap the returned disparity map
Local < Object > disparityWrap = Local < Object > disparityWrap =
NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap); Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap);
disp->mat = disparity; disp->mat = disparity;
NanReturnValue(disparityWrap); info.GetReturnValue().Set(disparityWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }
// Graph cut // Graph cut
v8::Persistent<FunctionTemplate> StereoGC::constructor; Nan::Persistent<FunctionTemplate> StereoGC::constructor;
void StereoGC::Init(Handle<Object> target) { void StereoGC::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoGC::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoGC::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("StereoGC")); ctor->SetClassName(Nan::New("StereoGC").ToLocalChecked());
NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); Nan::SetPrototypeMethod(ctor, "compute", Compute);
target->Set(NanNew("StereoGC"), ctor->GetFunction()); target->Set(Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(StereoGC::New) { NAN_METHOD(StereoGC::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) if (info.This()->InternalFieldCount() == 0)
NanThrowTypeError("Cannot instantiate without new"); Nan::ThrowTypeError("Cannot instantiate without new");
StereoGC *stereo; StereoGC *stereo;
if (args.Length() == 0) { if (info.Length() == 0) {
stereo = new StereoGC(); stereo = new StereoGC();
} else if (args.Length() == 1) { } else if (info.Length() == 1) {
// numberOfDisparities // numberOfDisparities
stereo = new StereoGC(args[0]->IntegerValue()); stereo = new StereoGC(info[0]->IntegerValue());
} else { } else {
// max iterations // max iterations
stereo = new StereoGC(args[0]->IntegerValue(), args[1]->IntegerValue()); stereo = new StereoGC(info[0]->IntegerValue(), info[1]->IntegerValue());
} }
stereo->Wrap(args.Holder()); stereo->Wrap(info.Holder());
NanReturnValue(args.Holder()); info.GetReturnValue().Set(info.Holder());
} }
StereoGC::StereoGC(int numberOfDisparities, int maxIters) : StereoGC::StereoGC(int numberOfDisparities, int maxIters) :
ObjectWrap() { Nan::ObjectWrap() {
stereo = cvCreateStereoGCState(numberOfDisparities, maxIters); stereo = cvCreateStereoGCState(numberOfDisparities, maxIters);
} }
@ -281,11 +281,11 @@ NAN_METHOD(StereoGC::Compute) {
// Get the arguments // Get the arguments
// Arg 0, the 'left' image // Arg 0, the 'left' image
Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject()); Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject());
cv::Mat left = m0->mat; cv::Mat left = m0->mat;
// Arg 1, the 'right' image // Arg 1, the 'right' image
Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject()); Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject());
cv::Mat right = m1->mat; cv::Mat right = m1->mat;
// Compute stereo using the block matching algorithm // Compute stereo using the block matching algorithm
@ -301,14 +301,14 @@ NAN_METHOD(StereoGC::Compute) {
// Wrap the returned disparity map // Wrap the returned disparity map
Local < Object > disparityWrap = Local < Object > disparityWrap =
NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap); Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap);
disp->mat = disparity; disp->mat = disparity;
NanReturnValue(disparityWrap); info.GetReturnValue().Set(disparityWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
NanThrowError(err_msg); Nan::ThrowError(err_msg);
NanReturnUndefined(); return;
} }
} }

18
src/Stereo.h
View File

@ -3,12 +3,12 @@
#include "OpenCV.h" #include "OpenCV.h"
class StereoBM: public node::ObjectWrap { class StereoBM: public Nan::ObjectWrap {
public: public:
cv::StereoBM stereo; cv::StereoBM stereo;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
StereoBM(int preset = cv::StereoBM::BASIC_PRESET, int ndisparities = 0, StereoBM(int preset = cv::StereoBM::BASIC_PRESET, int ndisparities = 0,
@ -18,12 +18,12 @@ public:
; ;
}; };
class StereoSGBM: public node::ObjectWrap { class StereoSGBM: public Nan::ObjectWrap {
public: public:
cv::StereoSGBM stereo; cv::StereoSGBM stereo;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
StereoSGBM(); StereoSGBM();
@ -37,12 +37,12 @@ public:
struct CvStereoGCState; struct CvStereoGCState;
class StereoGC: public node::ObjectWrap { class StereoGC: public Nan::ObjectWrap {
public: public:
CvStereoGCState *stereo; CvStereoGCState *stereo;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
StereoGC(int numberOfDisparities = 16, int maxIterations = 2); StereoGC(int numberOfDisparities = 16, int maxIterations = 2);

162
src/VideoCaptureWrap.cc
View File

@ -5,136 +5,136 @@
#include <iostream> #include <iostream>
using namespace std; using namespace std;
v8::Persistent<FunctionTemplate> VideoCaptureWrap::constructor; Nan::Persistent<FunctionTemplate> VideoCaptureWrap::constructor;
struct videocapture_baton { struct videocapture_baton {
Persistent<Function> cb; Nan::Persistent<Function> cb;
VideoCaptureWrap *vc; VideoCaptureWrap *vc;
Matrix *im; Matrix *im;
uv_work_t request; uv_work_t request;
}; };
void VideoCaptureWrap::Init(Handle<Object> target) { void VideoCaptureWrap::Init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
//Class //Class
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(VideoCaptureWrap::New); Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(VideoCaptureWrap::New);
NanAssignPersistent(constructor, ctor); constructor.Reset(ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("VideoCapture")); ctor->SetClassName(Nan::New("VideoCapture").ToLocalChecked());
// Prototype // Prototype
//Local<ObjectTemplate> proto = constructor->PrototypeTemplate(); //Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
NODE_SET_PROTOTYPE_METHOD(ctor, "read", Read); Nan::SetPrototypeMethod(ctor, "read", Read);
NODE_SET_PROTOTYPE_METHOD(ctor, "setWidth", SetWidth); Nan::SetPrototypeMethod(ctor, "setWidth", SetWidth);
NODE_SET_PROTOTYPE_METHOD(ctor, "setHeight", SetHeight); Nan::SetPrototypeMethod(ctor, "setHeight", SetHeight);
NODE_SET_PROTOTYPE_METHOD(ctor, "setPosition", SetPosition); Nan::SetPrototypeMethod(ctor, "setPosition", SetPosition);
NODE_SET_PROTOTYPE_METHOD(ctor, "close", Close); Nan::SetPrototypeMethod(ctor, "close", Close);
NODE_SET_PROTOTYPE_METHOD(ctor, "ReadSync", ReadSync); Nan::SetPrototypeMethod(ctor, "ReadSync", ReadSync);
NODE_SET_PROTOTYPE_METHOD(ctor, "grab", Grab); Nan::SetPrototypeMethod(ctor, "grab", Grab);
NODE_SET_PROTOTYPE_METHOD(ctor, "retrieve", Retrieve); Nan::SetPrototypeMethod(ctor, "retrieve", Retrieve);
target->Set(NanNew("VideoCapture"), ctor->GetFunction()); target->Set(Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction());
} }
NAN_METHOD(VideoCaptureWrap::New) { NAN_METHOD(VideoCaptureWrap::New) {
NanScope(); Nan::HandleScope scope;
if (args.This()->InternalFieldCount() == 0) if (info.This()->InternalFieldCount() == 0)
return NanThrowTypeError("Cannot Instantiate without new"); return Nan::ThrowTypeError("Cannot Instantiate without new");
VideoCaptureWrap *v; VideoCaptureWrap *v;
if (args[0]->IsNumber()) { if (info[0]->IsNumber()) {
v = new VideoCaptureWrap(args[0]->NumberValue()); v = new VideoCaptureWrap(info[0]->NumberValue());
} else { } else {
//TODO - assumes that we have string, verify //TODO - assumes that we have string, verify
v = new VideoCaptureWrap(std::string(*NanAsciiString(args[0]->ToString()))); v = new VideoCaptureWrap(std::string(*Nan::Utf8String(info[0]->ToString())));
} }
v->Wrap(args.This()); v->Wrap(info.This());
NanReturnValue(args.This()); info.GetReturnValue().Set(info.This());
} }
VideoCaptureWrap::VideoCaptureWrap(int device) { VideoCaptureWrap::VideoCaptureWrap(int device) {
NanScope(); Nan::HandleScope scope;
cap.open(device); cap.open(device);
if(!cap.isOpened()) { if(!cap.isOpened()) {
NanThrowError("Camera could not be opened"); Nan::ThrowError("Camera could not be opened");
} }
} }
VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) { VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) {
NanScope(); Nan::HandleScope scope;
cap.open(filename); cap.open(filename);
// TODO! At the moment this only takes a full path - do relative too. // TODO! At the moment this only takes a full path - do relative too.
if(!cap.isOpened()) { if(!cap.isOpened()) {
NanThrowError("Video file could not be opened (opencv reqs. non relative paths)"); Nan::ThrowError("Video file could not be opened (opencv reqs. non relative paths)");
} }
} }
NAN_METHOD(VideoCaptureWrap::SetWidth) { NAN_METHOD(VideoCaptureWrap::SetWidth) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
if(args.Length() != 1) if(info.Length() != 1)
NanReturnUndefined(); return;
int w = args[0]->IntegerValue(); int w = info[0]->IntegerValue();
if(v->cap.isOpened()) if(v->cap.isOpened())
v->cap.set(CV_CAP_PROP_FRAME_WIDTH, w); v->cap.set(CV_CAP_PROP_FRAME_WIDTH, w);
NanReturnUndefined(); return;
} }
NAN_METHOD(VideoCaptureWrap::SetHeight) { NAN_METHOD(VideoCaptureWrap::SetHeight) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
if(args.Length() != 1) if(info.Length() != 1)
NanReturnUndefined(); return;
int h = args[0]->IntegerValue(); int h = info[0]->IntegerValue();
v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h); v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h);
NanReturnUndefined(); return;
} }
NAN_METHOD(VideoCaptureWrap::SetPosition) { NAN_METHOD(VideoCaptureWrap::SetPosition) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
if(args.Length() != 1) if(info.Length() != 1)
NanReturnUndefined(); return;
int pos = args[0]->IntegerValue(); int pos = info[0]->IntegerValue();
v->cap.set(CV_CAP_PROP_POS_FRAMES, pos); v->cap.set(CV_CAP_PROP_POS_FRAMES, pos);
NanReturnUndefined(); return;
} }
NAN_METHOD(VideoCaptureWrap::Close) { NAN_METHOD(VideoCaptureWrap::Close) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
v->cap.release(); v->cap.release();
NanReturnUndefined(); return;
} }
class AsyncVCWorker: public NanAsyncWorker { class AsyncVCWorker: public Nan::AsyncWorker {
public: public:
AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc, AsyncVCWorker(Nan::Callback *callback, VideoCaptureWrap* vc,
bool retrieve = false, int channel = 0) : bool retrieve = false, int channel = 0) :
NanAsyncWorker(callback), Nan::AsyncWorker(callback),
vc(vc), vc(vc),
retrieve(retrieve), retrieve(retrieve),
channel(channel) { channel(channel) {
@ -161,21 +161,21 @@ public:
// this function will be run inside the main event loop // this function will be run inside the main event loop
// so it is safe to use V8 again // so it is safe to use V8 again
void HandleOKCallback() { void HandleOKCallback() {
NanScope(); Nan::HandleScope scope;
Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return); Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_to_return);
img->mat = mat; img->mat = mat;
Local<Value> argv[] = { Local<Value> argv[] = {
NanNull() Nan::Null()
, im_to_return , im_to_return
}; };
TryCatch try_catch; Nan::TryCatch try_catch;
callback->Call(2, argv); callback->Call(2, argv);
if (try_catch.HasCaught()) { if (try_catch.HasCaught()) {
FatalException(try_catch); Nan::FatalException(try_catch);
} }
} }
@ -187,33 +187,33 @@ private:
}; };
NAN_METHOD(VideoCaptureWrap::Read) { NAN_METHOD(VideoCaptureWrap::Read) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
REQ_FUN_ARG(0, cb); REQ_FUN_ARG(0, cb);
NanCallback *callback = new NanCallback(cb.As<Function>()); Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncVCWorker(callback, v)); Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v));
NanReturnUndefined(); return;
} }
NAN_METHOD(VideoCaptureWrap::ReadSync) { NAN_METHOD(VideoCaptureWrap::ReadSync) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return); Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_to_return);
v->cap.read(img->mat); v->cap.read(img->mat);
NanReturnValue(im_to_return); info.GetReturnValue().Set(im_to_return);
} }
class AsyncGrabWorker: public NanAsyncWorker { class AsyncGrabWorker: public Nan::AsyncWorker {
public: public:
AsyncGrabWorker(NanCallback *callback, VideoCaptureWrap* vc) : AsyncGrabWorker(Nan::Callback *callback, VideoCaptureWrap* vc) :
NanAsyncWorker(callback), Nan::AsyncWorker(callback),
vc(vc) { vc(vc) {
} }
@ -231,27 +231,27 @@ private:
}; };
NAN_METHOD(VideoCaptureWrap::Grab) { NAN_METHOD(VideoCaptureWrap::Grab) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
REQ_FUN_ARG(0, cb); REQ_FUN_ARG(0, cb);
NanCallback *callback = new NanCallback(cb.As<Function>()); Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncGrabWorker(callback, v)); Nan::AsyncQueueWorker(new AsyncGrabWorker(callback, v));
NanReturnUndefined(); return;
} }
NAN_METHOD(VideoCaptureWrap::Retrieve) { NAN_METHOD(VideoCaptureWrap::Retrieve) {
NanScope(); Nan::HandleScope scope;
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This()); VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This());
int channel = 0; int channel = 0;
REQ_FUN_ARG(0, cb); REQ_FUN_ARG(0, cb);
INT_FROM_ARGS(channel, 1); INT_FROM_ARGS(channel, 1);
NanCallback *callback = new NanCallback(cb.As<Function>()); Nan::Callback *callback = new Nan::Callback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel));
NanReturnUndefined(); return;
} }

6
src/VideoCaptureWrap.h
View File

@ -1,11 +1,11 @@
#include "OpenCV.h" #include "OpenCV.h"
class VideoCaptureWrap: public node::ObjectWrap { class VideoCaptureWrap: public Nan::ObjectWrap {
public: public:
cv::VideoCapture cap; cv::VideoCapture cap;
static Persistent<FunctionTemplate> constructor; static Nan::Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Local<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
VideoCaptureWrap(const std::string& filename); VideoCaptureWrap(const std::string& filename);

4
src/init.cc
View File

@ -15,8 +15,8 @@
#include "Stereo.h" #include "Stereo.h"
#include "BackgroundSubtractor.h" #include "BackgroundSubtractor.h"
extern "C" void init(Handle<Object> target) { extern "C" void init(Local<Object> target) {
NanScope(); Nan::HandleScope scope;
OpenCV::Init(target); OpenCV::Init(target);
Point::Init(target); Point::Init(target);

5333
upgrade-log.html Normal file
View File

File diff suppressed because it is too large Load Diff

31
vagrant/Vagrantfile vendored Normal file
View File

@ -0,0 +1,31 @@
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
# Using Ubuntu Trusty (14.04) for now
config.vm.box = "ubuntu/trusty64"
# Give Box it's own IP
config.vm.network "private_network", ip: "192.168.35.111"
# Would you rather use port forwarding? comment out that last line and add these:
# config.vm.network :forwarded_port, guest: 80, host: 8888
# config.vm.network :forwarded_port, guest: 3000, host: 3000 #common port for node, etc
# Sync parent folder. Clone this repo into project folder.
# I Like to work this way so I don't have vagrant files running all over my code.
# Parent folder will have the name of your app
config.vm.synced_folder "../", "/home/vagrant/"+File.basename(File.expand_path('..'))
# EDIT THE SCRIPT REFERENCED BELOW TO
config.vm.provision "shell", path: "setup.sh"
config.vm.provider "virtualbox" do |v|
#NAME THE VM -- You'll probably want to rename this box on a per-project basis.
#For now, it should inherit the name of the parent folder
v.name = "VDK - " + File.basename(File.expand_path('..'))
# 512 is pretty tight to run Node.js on, if you're in to that sort of thing. I've boosted this.
v.memory = 1024
end
end

13
vagrant/scripts/setup-node.sh Executable file
View File

@ -0,0 +1,13 @@
apt-get install gcc make build-essential -y
apt-get install -y curl
apt-get install -y git
# curl --silent --location https://deb.nodesource.com/setup_4.x | sudo bash -
# apt-get install -y nodejs
su vagrant
wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.27.1/install.sh | bash
nvm install v0.10
nvm install v0.12
nvm install v4.1

24
vagrant/setup.sh Executable file
View File

@ -0,0 +1,24 @@
#!/bin/bash
apt-get update
apt-get upgrade -y
#INSTALL BASE
chmod +x "/vagrant/scripts/base.sh"
$include "/vagrant/scripts/base.sh"
#COMMENT OUT OR IN LINES AS APPROPRIATE
INCLUDED_TECH=()
INCLUDED_TECH+=("node")
SCRIPT_LOCATION="/vagrant/scripts/setup-"
for i in ${INCLUDED_TECH[@]}; do
chmod +x "${SCRIPT_LOCATION}${i}.sh"
$include "${SCRIPT_LOCATION}${i}.sh"
done
echo "Base Setup Done!"
ls
#INSTALL USER
chmod +x "/vagrant/user.sh"
$include "/vagrant/user.sh"

26
vagrant/user.sh Executable file
View File

@ -0,0 +1,26 @@
export REPO_FOLDER="node-opencv"
cd /home/vagrant/$REPO_FOLDER
apt-get install -y cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev
mkdir opencv_lib
cd /home/vagrant/$REPO_FOLDER/opencv_lib/
[ ! -f /home/vagrant/$REPO_FOLDER/opencv_lib/2.4.11.tar.gz ] && wget https://github.com/Itseez/opencv/archive/2.4.11.tar.gz && tar -zxvf2.4.11.tar.gz
cd opencv-2.4.11
mkdir release
cd release
echo "Removing any pre-installed ffmpeg and x264"
apt-get -y remove ffmpeg x264 libx264-dev
echo "Installing Dependenices"
apt-get -y install libopencv-dev
apt-get -y install build-essential checkinstall cmake pkg-config yasm
apt-get -y install libtiff4-dev libjpeg-dev libjasper-dev
apt-get -y install libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev libdc1394-22 libdc1394-utils libxine-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev
apt-get -y install python-dev python-numpy
apt-get -y install libtbb-dev
apt-get -y install libqt4-dev libgtk2.0-dev
apt-get -y install libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev
apt-get -y install x264 v4l-utils ffmpeg libx264-dev
apt-get -y install libgtk2.0-dev
cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON ..
make install
cd /home/vagrant/$REPO_FOLDER/