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

Revert "conversion + build + test passed... so far"

Browse Source 
This reverts commit ea69fcc10b73a191e1d3dc6c9decdc1ebc8bc714.
This commit is contained in:
Keegan Brown 2015-10-01 11:03:08 -05:00
parent ad99fa17f2
commit 1974fd6d00
32 changed files with 1555 additions and 1557 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
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))
Nan::Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor; Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor;
void BackgroundSubtractorWrap::Init(Handle<Object> target) { void BackgroundSubtractorWrap::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
// Constructor // Constructor
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(BackgroundSubtractorWrap::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(BackgroundSubtractorWrap::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("BackgroundSubtractor").ToLocalChecked()); ctor->SetClassName(NanNew("BackgroundSubtractor"));
Nan::SetMethod(ctor, "createMOG", CreateMOG); NODE_SET_METHOD(ctor, "createMOG", CreateMOG);
Nan::SetPrototypeMethod(ctor, "applyMOG", ApplyMOG); NODE_SET_PROTOTYPE_METHOD(ctor, "applyMOG", ApplyMOG);
target->Set(Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("BackgroundSubtractor"), ctor->GetFunction());
} }
NAN_METHOD(BackgroundSubtractorWrap::New) { NAN_METHOD(BackgroundSubtractorWrap::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) { if (args.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(info.This()); pt->Wrap(args.This());
info.GetReturnValue().Set(info.This()); NanReturnValue(args.This());
} }
NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) { NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) {
Nan::HandleScope scope; NanScope();
// 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(info.Length() > 1){ // if(args.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 = Nan::New(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = NanNew(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);
info.GetReturnValue().Set( n ); NanReturnValue( 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 (info.Length() == 0) { if (args.Length() == 0) {
argv[0] = Nan::New("Input image missing").ToLocalChecked(); argv[0] = NanNew("Input image missing");
argv[1] = Nan::Null(); argv[1] = NanNull();
cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); cb->Call(NanGetCurrentContext()->Global(), 2, argv);
return; NanReturnUndefined();
} }
try { try {
Local<Object> fgMask = Local<Object> fgMask =
Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(fgMask); Matrix *img = ObjectWrap::Unwrap<Matrix>(fgMask);
cv::Mat mat; cv::Mat mat;
if (Buffer::HasInstance(info[0])) { if (Buffer::HasInstance(args[0])) {
uint8_t *buf = (uint8_t *) Buffer::Data(info[0]->ToObject()); uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject());
unsigned len = Buffer::Length(info[0]->ToObject()); unsigned len = Buffer::Length(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix *_img = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
mat = (_img->mat).clone(); mat = (_img->mat).clone();
} }
if (mat.empty()) { if (mat.empty()) {
return Nan::ThrowTypeError("Error loading file"); return NanThrowTypeError("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] = Nan::Null(); argv[0] = NanNull();
argv[1] = fgMask; argv[1] = fgMask;
TryCatch try_catch; TryCatch try_catch;
cb->Call(Nan::GetCurrentContext()->Global(), 2, argv); cb->Call(NanGetCurrentContext()->Global(), 2, argv);
if (try_catch.HasCaught()) { if (try_catch.HasCaught()) {
FatalException(try_catch); FatalException(try_catch);
} }
return; NanReturnUndefined();
} catch (cv::Exception& e) { } catch (cv::Exception& e) {
const char* err_msg = e.what(); const char* err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }

4
src/BackgroundSubtractor.h
View File

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

264
src/Calib3D.cc
View File

@ -3,15 +3,15 @@
inline Local<Object> matrixFromMat(cv::Mat &input) { inline Local<Object> matrixFromMat(cv::Mat &input) {
Local<Object> matrixWrap = Local<Object> matrixWrap =
Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *matrix = Nan::ObjectWrap::Unwrap<Matrix>(matrixWrap); Matrix *matrix = 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(Handle<Value> matrix) {
Matrix* m = Nan::ObjectWrap::Unwrap<Matrix>(matrix->ToObject()); Matrix* m = ObjectWrap::Unwrap<Matrix>(matrix->ToObject());
return m->mat; return m->mat;
} }
@ -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(Nan::New<String>("x").ToLocalChecked())->ToNumber()->Value(), cv::Point2f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
pt->Get(Nan::New<String>("y").ToLocalChecked())->ToNumber()->Value())); pt->Get(NanNew<String>("y"))->ToNumber()->Value()));
} }
} else { } else {
JSTHROW_TYPE("Points not a valid array"); JSTHROW_TYPE("Points not a valid array");
@ -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(Nan::New<String>("x").ToLocalChecked())->ToNumber()->Value(), cv::Point3f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
pt->Get(Nan::New<String>("y").ToLocalChecked())->ToNumber()->Value(), pt->Get(NanNew<String>("y"))->ToNumber()->Value(),
pt->Get(Nan::New<String>("z").ToLocalChecked())->ToNumber()->Value())); pt->Get(NanNew<String>("z"))->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")
@ -100,35 +100,35 @@ inline std::vector<std::vector<cv::Point3f> > points3fFromArrayOfArrays(
} }
void Calib3D::Init(Handle<Object> target) { void Calib3D::Init(Handle<Object> target) {
Nan::Persistent<Object> inner; Persistent<Object> inner;
Local<Object> obj = Nan::New<Object>(); Local<Object> obj = NanNew<Object>();
inner.Reset(obj); NanAssignPersistent(inner, obj);
Nan::SetMethod(obj, "findChessboardCorners", FindChessboardCorners); NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners);
Nan::SetMethod(obj, "drawChessboardCorners", DrawChessboardCorners); NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners);
Nan::SetMethod(obj, "calibrateCamera", CalibrateCamera); NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera);
Nan::SetMethod(obj, "solvePnP", SolvePnP); NODE_SET_METHOD(obj, "solvePnP", SolvePnP);
Nan::SetMethod(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix); NODE_SET_METHOD(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix);
Nan::SetMethod(obj, "stereoCalibrate", StereoCalibrate); NODE_SET_METHOD(obj, "stereoCalibrate", StereoCalibrate);
Nan::SetMethod(obj, "stereoRectify", StereoRectify); NODE_SET_METHOD(obj, "stereoRectify", StereoRectify);
Nan::SetMethod(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines); NODE_SET_METHOD(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines);
Nan::SetMethod(obj, "reprojectImageTo3d", ReprojectImageTo3D); NODE_SET_METHOD(obj, "reprojectImageTo3d", ReprojectImageTo3D);
target->Set(Nan::New("calib3d").ToLocalChecked(), obj); target->Set(NanNew("calib3d"), obj);
} }
// cv::findChessboardCorners // cv::findChessboardCorners
NAN_METHOD(Calib3D::FindChessboardCorners) { NAN_METHOD(Calib3D::FindChessboardCorners) {
Nan::EscapableHandleScope scope; NanEscapableScope();
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(info[0]); cv::Mat mat = matFromMatrix(args[0]);
// Arg 1 is the pattern size // Arg 1 is the pattern size
cv::Size patternSize = sizeFromArray(info[1]); cv::Size patternSize = sizeFromArray(args[1]);
// Arg 2 would normally be the flags, ignoring this for now and using the // 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 = Nan::New<Object>(); Local<Object> ret = NanNew<Object>();
ret->Set(Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found)); ret->Set(NanNew<String>("found"), NanNew<Boolean>(found));
Local<Array> cornersArray = Nan::New<Array>(corners.size()); Local<Array> cornersArray = NanNew<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 = Nan::New<Object>(); Local<Object> point_data = NanNew<Object>();
point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x)); point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y)); point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
cornersArray->Set(Nan::New<Number>(i), point_data); cornersArray->Set(NanNew<Number>(i), point_data);
} }
ret->Set(Nan::New<String>("corners").ToLocalChecked(), cornersArray); ret->Set(NanNew<String>("corners"), cornersArray);
info.GetReturnValue().Set(ret); NanReturnValue(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::drawChessboardCorners // cv::drawChessboardCorners
NAN_METHOD(Calib3D::DrawChessboardCorners) { NAN_METHOD(Calib3D::DrawChessboardCorners) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the image // Arg 0 is the image
cv::Mat mat = matFromMatrix(info[0]); cv::Mat mat = matFromMatrix(args[0]);
// Arg 1 is the pattern size // Arg 1 is the pattern size
cv::Size patternSize = sizeFromArray(info[1]); cv::Size patternSize = sizeFromArray(args[1]);
// Arg 2 is the corners array // Arg 2 is the corners array
std::vector<cv::Point2f> corners = points2fFromArray(info[2]); std::vector<cv::Point2f> corners = points2fFromArray(args[2]);
// Arg 3, pattern found boolean // Arg 3, pattern found boolean
bool patternWasFound = info[3]->ToBoolean()->Value(); bool patternWasFound = args[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
info.GetReturnValue().Set(info[0]); NanReturnValue(args[0]);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::calibrateCamera // cv::calibrateCamera
NAN_METHOD(Calib3D::CalibrateCamera) { NAN_METHOD(Calib3D::CalibrateCamera) {
Nan::EscapableHandleScope scope; NanEscapableScope();
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(info[0]); points3fFromArrayOfArrays(args[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(info[1]); points2fFromArrayOfArrays(args[1]);
// Arg 2, the image size // Arg 2, the image size
cv::Size imageSize = sizeFromArray(info[2]); cv::Size imageSize = sizeFromArray(args[2]);
// Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, // 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 = Nan::New<Object>(); Local<Object> ret = NanNew<Object>();
// Reprojection error // Reprojection error
ret->Set(Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error)); ret->Set(NanNew<String>("reprojectionError"), NanNew<Number>(error));
// K // K
Local<Object> KMatrixWrap = matrixFromMat(K); Local<Object> KMatrixWrap = matrixFromMat(K);
ret->Set(Nan::New<String>("K").ToLocalChecked(), KMatrixWrap); ret->Set(NanNew<String>("K"), KMatrixWrap);
// dist // dist
Local<Object> distMatrixWrap = matrixFromMat(dist); Local<Object> distMatrixWrap = matrixFromMat(dist);
ret->Set(Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap); ret->Set(NanNew<String>("distortion"), distMatrixWrap);
// Per frame R and t, skiping for now // Per frame R and t, skiping for now
// Return // Return
info.GetReturnValue().Set(ret); NanReturnValue(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::solvePnP // cv::solvePnP
NAN_METHOD(Calib3D::SolvePnP) { NAN_METHOD(Calib3D::SolvePnP) {
Nan::EscapableHandleScope scope; NanEscapableScope();
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(info[0]); std::vector<cv::Point3f> objectPoints = points3fFromArray(args[0]);
// Arg 1, the image points // Arg 1, the image points
std::vector<cv::Point2f> imagePoints = points2fFromArray(info[1]); std::vector<cv::Point2f> imagePoints = points2fFromArray(args[1]);
// Arg 2, the camera matrix // Arg 2, the camera matrix
cv::Mat K = matFromMatrix(info[2]); cv::Mat K = matFromMatrix(args[2]);
// Arg 3, the distortion coefficients // Arg 3, the distortion coefficients
cv::Mat dist = matFromMatrix(info[3]); cv::Mat dist = matFromMatrix(args[3]);
// Arg 4, use extrinsic guess, skipped for now // 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 = Nan::New<Object>(); Local<Object> ret = NanNew<Object>();
// rvec // rvec
Local<Object> rMatrixWrap = matrixFromMat(rvec); Local<Object> rMatrixWrap = matrixFromMat(rvec);
ret->Set(Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap); ret->Set(NanNew<String>("rvec"), rMatrixWrap);
// tvec // tvec
Local<Object> tMatrixWrap = matrixFromMat(tvec); Local<Object> tMatrixWrap = matrixFromMat(tvec);
ret->Set(Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap); ret->Set(NanNew<String>("tvec"), tMatrixWrap);
// Return // Return
info.GetReturnValue().Set(ret); NanReturnValue(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::getOptimalNewCameraMAtrix // cv::getOptimalNewCameraMAtrix
NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) {
Nan::EscapableHandleScope scope; NanEscapableScope();
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(info[0]); cv::Mat Kin = matFromMatrix(args[0]);
// Arg 1 is the distortion coefficients // Arg 1 is the distortion coefficients
cv::Mat dist = matFromMatrix(info[1]); cv::Mat dist = matFromMatrix(args[1]);
// Arg 2, the image size // Arg 2, the image size
cv::Size imageSize = sizeFromArray(info[2]); cv::Size imageSize = sizeFromArray(args[2]);
// Arg 3 is the alpha free scaling parameter // Arg 3 is the alpha free scaling parameter
double alpha = info[3]->ToNumber()->Value(); double alpha = args[3]->ToNumber()->Value();
// Arg 4, the new image size // Arg 4, the new image size
cv::Size newImageSize = sizeFromArray(info[4]); cv::Size newImageSize = sizeFromArray(args[4]);
// Arg 5, valid ROI, skip for now // Arg 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
info.GetReturnValue().Set(KMatrixWrap); NanReturnValue(KMatrixWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::stereoCalibrate // cv::stereoCalibrate
NAN_METHOD(Calib3D::StereoCalibrate) { NAN_METHOD(Calib3D::StereoCalibrate) {
Nan::EscapableHandleScope scope; NanEscapableScope();
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(info[0]); points3fFromArrayOfArrays(args[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(info[1]); points2fFromArrayOfArrays(args[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(info[2]); points2fFromArrayOfArrays(args[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(info[3]); cv::Size imageSize = sizeFromArray(args[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 (info.Length() >= 8) { if (args.Length() >= 8) {
k1 = matFromMatrix(info[4]); k1 = matFromMatrix(args[4]);
d1 = matFromMatrix(info[5]); d1 = matFromMatrix(args[5]);
k2 = matFromMatrix(info[6]); k2 = matFromMatrix(args[6]);
d2 = matFromMatrix(info[7]); d2 = matFromMatrix(args[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 = Nan::New<Object>(); Local<Object> ret = NanNew<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(Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap); ret->Set(NanNew<String>("K1"), K1MatrixWrap);
ret->Set(Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap); ret->Set(NanNew<String>("distortion1"), d1MatrixWrap);
ret->Set(Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap); ret->Set(NanNew<String>("K2"), K2MatrixWrap);
ret->Set(Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap); ret->Set(NanNew<String>("distortion2"), d2MatrixWrap);
ret->Set(Nan::New<String>("R").ToLocalChecked(), RMatrixWrap); ret->Set(NanNew<String>("R"), RMatrixWrap);
ret->Set(Nan::New<String>("t").ToLocalChecked(), tMatrixWrap); ret->Set(NanNew<String>("t"), tMatrixWrap);
ret->Set(Nan::New<String>("E").ToLocalChecked(), EMatrixWrap); ret->Set(NanNew<String>("E"), EMatrixWrap);
ret->Set(Nan::New<String>("F").ToLocalChecked(), FMatrixWrap); ret->Set(NanNew<String>("F"), FMatrixWrap);
// Return // Return
info.GetReturnValue().Set(ret); NanReturnValue(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::stereoRectify // cv::stereoRectify
NAN_METHOD(Calib3D::StereoRectify) { NAN_METHOD(Calib3D::StereoRectify) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Get the arguments // Get the arguments
// Arg0, the first camera matrix // Arg0, the first camera matrix
cv::Mat K1 = matFromMatrix(info[0]); cv::Mat K1 = matFromMatrix(args[0]);
// Arg1, the first distortion coefficients // Arg1, the first distortion coefficients
cv::Mat d1 = matFromMatrix(info[1]); cv::Mat d1 = matFromMatrix(args[1]);
// Arg2, the second camera matrix // Arg2, the second camera matrix
cv::Mat K2 = matFromMatrix(info[2]); cv::Mat K2 = matFromMatrix(args[2]);
// Arg3, the second distortion coefficients // Arg3, the second distortion coefficients
cv::Mat d2 = matFromMatrix(info[3]); cv::Mat d2 = matFromMatrix(args[3]);
// Arg4, the image size // Arg4, the image size
cv::Size imageSize = sizeFromArray(info[4]); cv::Size imageSize = sizeFromArray(args[4]);
// arg5, the intercamera rotation matrix // arg5, the intercamera rotation matrix
cv::Mat R = matFromMatrix(info[5]); cv::Mat R = matFromMatrix(args[5]);
// Arg6, the intercamera translation vector // Arg6, the intercamera translation vector
cv::Mat t = matFromMatrix(info[6]); cv::Mat t = matFromMatrix(args[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 = Nan::New<Object>(); Local<Object> ret = NanNew<Object>();
ret->Set(Nan::New<String>("R1").ToLocalChecked(), matrixFromMat(R1)); ret->Set(NanNew<String>("R1"), matrixFromMat(R1));
ret->Set(Nan::New<String>("R2").ToLocalChecked(), matrixFromMat(R2)); ret->Set(NanNew<String>("R2"), matrixFromMat(R2));
ret->Set(Nan::New<String>("P1").ToLocalChecked(), matrixFromMat(P1)); ret->Set(NanNew<String>("P1"), matrixFromMat(P1));
ret->Set(Nan::New<String>("P2").ToLocalChecked(), matrixFromMat(P2)); ret->Set(NanNew<String>("P2"), matrixFromMat(P2));
ret->Set(Nan::New<String>("Q").ToLocalChecked(), matrixFromMat(Q)); ret->Set(NanNew<String>("Q"), matrixFromMat(Q));
// Return the rectification parameters // Return the rectification parameters
info.GetReturnValue().Set(ret); NanReturnValue(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::computeCorrespondEpilines // cv::computeCorrespondEpilines
NAN_METHOD(Calib3D::ComputeCorrespondEpilines) { NAN_METHOD(Calib3D::ComputeCorrespondEpilines) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Get the arguments // Get the arguments
// Arg0, the image points // Arg0, the image points
std::vector<cv::Point2f> points = points2fFromArray(info[0]); std::vector<cv::Point2f> points = points2fFromArray(args[0]);
// Arg1, the image index (1 or 2) // Arg1, the image index (1 or 2)
int whichImage = int(info[1]->ToNumber()->Value()); int whichImage = int(args[1]->ToNumber()->Value());
// Arg2, the fundamental matrix // Arg2, the fundamental matrix
cv::Mat F = matFromMatrix(info[2]); cv::Mat F = matFromMatrix(args[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 = Nan::New<Array>(lines.size()); Local<Array> linesArray = NanNew<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 = Nan::New<Object>(); Local<Object> line_data = NanNew<Object>();
line_data->Set(Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0])); line_data->Set(NanNew<String>("a"), NanNew<Number>(lines[i][0]));
line_data->Set(Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1])); line_data->Set(NanNew<String>("b"), NanNew<Number>(lines[i][1]));
line_data->Set(Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2])); line_data->Set(NanNew<String>("c"), NanNew<Number>(lines[i][2]));
linesArray->Set(Nan::New<Number>(i), line_data); linesArray->Set(NanNew<Number>(i), line_data);
} }
// Return the lines // Return the lines
info.GetReturnValue().Set(linesArray); NanReturnValue(linesArray);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::reprojectImageTo3D // cv::reprojectImageTo3D
NAN_METHOD(Calib3D::ReprojectImageTo3D) { NAN_METHOD(Calib3D::ReprojectImageTo3D) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Get the arguments // Get the arguments
// Arg0, the disparity image // Arg0, the disparity image
cv::Mat disparity = matFromMatrix(info[0]); cv::Mat disparity = matFromMatrix(args[0]);
// Arg1, the depth-to-disparity transformation Q // Arg1, the depth-to-disparity transformation Q
cv::Mat Q = matFromMatrix(info[1]); cv::Mat Q = matFromMatrix(args[1]);
// Arg 2, handle missing values, skipped for now // 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);
info.GetReturnValue().Set(depthImageMatrix); NanReturnValue(depthImageMatrix);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }

2
src/Calib3D.h
View File

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

62
src/CamShift.cc
View File

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

4
src/CamShift.h
View File

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

82
src/CascadeClassifierWrap.cc Normal file → Executable file
View File

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

4
src/CascadeClassifierWrap.h Normal file → Executable file
View File

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

12
src/Constants.cc
View File

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

2
src/Constants.h
View File

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

316
src/Contours.cc Normal file → Executable file
View File

@ -4,337 +4,337 @@
#include <iostream> #include <iostream>
Nan::Persistent<FunctionTemplate> Contour::constructor; v8::Persistent<FunctionTemplate> Contour::constructor;
void Contour::Init(Handle<Object> target) { void Contour::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
// Class/contructor // Class/contructor
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(Contour::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Contour::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("Contours").ToLocalChecked()); ctor->SetClassName(NanNew("Contours"));
// Prototype // Prototype
// Local<ObjectTemplate> proto = constructor->PrototypeTemplate(); // Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
Nan::SetPrototypeMethod(ctor, "point", Point); NODE_SET_PROTOTYPE_METHOD(ctor, "point", Point);
Nan::SetPrototypeMethod(ctor, "size", Size); NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size);
Nan::SetPrototypeMethod(ctor, "cornerCount", CornerCount); NODE_SET_PROTOTYPE_METHOD(ctor, "cornerCount", CornerCount);
Nan::SetPrototypeMethod(ctor, "area", Area); NODE_SET_PROTOTYPE_METHOD(ctor, "area", Area);
Nan::SetPrototypeMethod(ctor, "arcLength", ArcLength); NODE_SET_PROTOTYPE_METHOD(ctor, "arcLength", ArcLength);
Nan::SetPrototypeMethod(ctor, "approxPolyDP", ApproxPolyDP); NODE_SET_PROTOTYPE_METHOD(ctor, "approxPolyDP", ApproxPolyDP);
Nan::SetPrototypeMethod(ctor, "convexHull", ConvexHull); NODE_SET_PROTOTYPE_METHOD(ctor, "convexHull", ConvexHull);
Nan::SetPrototypeMethod(ctor, "boundingRect", BoundingRect); NODE_SET_PROTOTYPE_METHOD(ctor, "boundingRect", BoundingRect);
Nan::SetPrototypeMethod(ctor, "minAreaRect", MinAreaRect); NODE_SET_PROTOTYPE_METHOD(ctor, "minAreaRect", MinAreaRect);
Nan::SetPrototypeMethod(ctor, "fitEllipse", FitEllipse); NODE_SET_PROTOTYPE_METHOD(ctor, "fitEllipse", FitEllipse);
Nan::SetPrototypeMethod(ctor, "isConvex", IsConvex); NODE_SET_PROTOTYPE_METHOD(ctor, "isConvex", IsConvex);
Nan::SetPrototypeMethod(ctor, "moments", Moments); NODE_SET_PROTOTYPE_METHOD(ctor, "moments", Moments);
Nan::SetPrototypeMethod(ctor, "hierarchy", Hierarchy); NODE_SET_PROTOTYPE_METHOD(ctor, "hierarchy", Hierarchy);
Nan::SetPrototypeMethod(ctor, "serialize", Serialize); NODE_SET_PROTOTYPE_METHOD(ctor, "serialize", Serialize);
Nan::SetPrototypeMethod(ctor, "deserialize", Deserialize); NODE_SET_PROTOTYPE_METHOD(ctor, "deserialize", Deserialize);
target->Set(Nan::New("Contours").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("Contours"), ctor->GetFunction());
}; };
NAN_METHOD(Contour::New) { NAN_METHOD(Contour::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) { if (args.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new"); NanThrowTypeError("Cannot instantiate without new");
} }
Contour *contours; Contour *contours;
contours = new Contour; contours = new Contour;
contours->Wrap(info.Holder()); contours->Wrap(args.Holder());
info.GetReturnValue().Set(info.Holder()); NanReturnValue(args.Holder());
} }
Contour::Contour() : Contour::Contour() :
Nan::ObjectWrap() { ObjectWrap() {
} }
NAN_METHOD(Contour::Point) { NAN_METHOD(Contour::Point) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
int index = info[1]->NumberValue(); int index = args[1]->NumberValue();
cv::Point point = self->contours[pos][index]; cv::Point point = self->contours[pos][index];
Local<Object> data = Nan::New<Object>(); Local<Object> data = NanNew<Object>();
data->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x)); data->Set(NanNew("x"), NanNew<Number>(point.x));
data->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y)); data->Set(NanNew("y"), NanNew<Number>(point.y));
info.GetReturnValue().Set(data); NanReturnValue(data);
} }
NAN_METHOD(Contour::Points) { NAN_METHOD(Contour::Points) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
vector<cv::Point> points = self->contours[pos]; vector<cv::Point> points = self->contours[pos];
Local<Array> data = Nan::New<Array>(points.size()); Local<Array> data = NanNew<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 = Nan::New<Object>(); Local<Object> point_data = NanNew<Object>();
point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x)); point_data->Set(NanNew<String>("x"), NanNew<Number>(points[i].x));
point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y)); point_data->Set(NanNew<String>("y"), NanNew<Number>(points[i].y));
data->Set(i, point_data); data->Set(i, point_data);
} }
info.GetReturnValue().Set(data); NanReturnValue(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) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
info.GetReturnValue().Set(Nan::New<Number>(self->contours.size())); NanReturnValue(NanNew<Number>(self->contours.size()));
} }
NAN_METHOD(Contour::CornerCount) { NAN_METHOD(Contour::CornerCount) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
info.GetReturnValue().Set(Nan::New<Number>(self->contours[pos].size())); NanReturnValue(NanNew<Number>(self->contours[pos].size()));
} }
NAN_METHOD(Contour::Area) { NAN_METHOD(Contour::Area) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
// info.GetReturnValue().Set(Nan::New<Number>(contourArea(self->contours))); // NanReturnValue(NanNew<Number>(contourArea(self->contours)));
info.GetReturnValue().Set(Nan::New<Number>(contourArea(cv::Mat(self->contours[pos])))); NanReturnValue(NanNew<Number>(contourArea(cv::Mat(self->contours[pos]))));
} }
NAN_METHOD(Contour::ArcLength) { NAN_METHOD(Contour::ArcLength) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
bool isClosed = info[1]->BooleanValue(); bool isClosed = args[1]->BooleanValue();
info.GetReturnValue().Set(Nan::New<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed))); NanReturnValue(NanNew<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
} }
NAN_METHOD(Contour::ApproxPolyDP) { NAN_METHOD(Contour::ApproxPolyDP) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
double epsilon = info[1]->NumberValue(); double epsilon = args[1]->NumberValue();
bool isClosed = info[2]->BooleanValue(); bool isClosed = args[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]);
info.GetReturnValue().Set(Nan::Null()); NanReturnNull();
} }
NAN_METHOD(Contour::ConvexHull) { NAN_METHOD(Contour::ConvexHull) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
bool clockwise = info[1]->BooleanValue(); bool clockwise = args[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]);
info.GetReturnValue().Set(Nan::Null()); NanReturnNull();
} }
NAN_METHOD(Contour::BoundingRect) { NAN_METHOD(Contour::BoundingRect) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[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 = Nan::New<Object>(); Local<Object> rect = NanNew<Object>();
rect->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x)); rect->Set(NanNew("x"), NanNew<Number>(bounding.x));
rect->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y)); rect->Set(NanNew("y"), NanNew<Number>(bounding.y));
rect->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width)); rect->Set(NanNew("width"), NanNew<Number>(bounding.width));
rect->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height)); rect->Set(NanNew("height"), NanNew<Number>(bounding.height));
info.GetReturnValue().Set(rect); NanReturnValue(rect);
} }
NAN_METHOD(Contour::MinAreaRect) { NAN_METHOD(Contour::MinAreaRect) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[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 = Nan::New<Object>(); Local<Object> rect = NanNew<Object>();
rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle)); rect->Set(NanNew("angle"), NanNew<Number>(minimum.angle));
Local<Object> size = Nan::New<Object>(); Local<Object> size = NanNew<Object>();
size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height)); size->Set(NanNew("height"), NanNew<Number>(minimum.size.height));
size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width)); size->Set(NanNew("width"), NanNew<Number>(minimum.size.width));
rect->Set(Nan::New("size").ToLocalChecked(), size); rect->Set(NanNew("size"), size);
Local<Object> center = Nan::New<Object>(); Local<Object> center = NanNew<Object>();
center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x)); center->Set(NanNew("x"), NanNew<Number>(minimum.center.x));
center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y)); center->Set(NanNew("y"), NanNew<Number>(minimum.center.y));
v8::Local<v8::Array> points = Nan::New<Array>(4); v8::Local<v8::Array> points = NanNew<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 = Nan::New<Object>(); Local<Object> point = NanNew<Object>();
point->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x)); point->Set(NanNew("x"), NanNew<Number>(rect_points[i].x));
point->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y)); point->Set(NanNew("y"), NanNew<Number>(rect_points[i].y));
points->Set(i, point); points->Set(i, point);
} }
rect->Set(Nan::New("points").ToLocalChecked(), points); rect->Set(NanNew("points"), points);
info.GetReturnValue().Set(rect); NanReturnValue(rect);
} }
NAN_METHOD(Contour::FitEllipse) { NAN_METHOD(Contour::FitEllipse) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[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 = Nan::New<Object>(); Local<Object> jsEllipse = NanNew<Object>();
jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle)); jsEllipse->Set(NanNew("angle"), NanNew<Number>(ellipse.angle));
Local<Object> size = Nan::New<Object>(); Local<Object> size = NanNew<Object>();
size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height)); size->Set(NanNew("height"), NanNew<Number>(ellipse.size.height));
size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width)); size->Set(NanNew("width"), NanNew<Number>(ellipse.size.width));
jsEllipse->Set(Nan::New("size").ToLocalChecked(), size); jsEllipse->Set(NanNew("size"), size);
Local<Object> center = Nan::New<Object>(); Local<Object> center = NanNew<Object>();
center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x)); center->Set(NanNew("x"), NanNew<Number>(ellipse.center.x));
center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y)); center->Set(NanNew("y"), NanNew<Number>(ellipse.center.y));
jsEllipse->Set(Nan::New("center").ToLocalChecked(), center); jsEllipse->Set(NanNew("center"), center);
info.GetReturnValue().Set(jsEllipse); NanReturnValue(jsEllipse);
} }
info.GetReturnValue().Set(Nan::Null()); NanReturnNull();
} }
NAN_METHOD(Contour::IsConvex) { NAN_METHOD(Contour::IsConvex) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[0]->NumberValue();
info.GetReturnValue().Set(Nan::New<Boolean>(isContourConvex(cv::Mat(self->contours[pos])))); NanReturnValue(NanNew<Boolean>(isContourConvex(cv::Mat(self->contours[pos]))));
} }
NAN_METHOD(Contour::Moments) { NAN_METHOD(Contour::Moments) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->NumberValue(); int pos = args[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 = Nan::New<Object>(); Local<Object> res = NanNew<Object>();
res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00)); res->Set(NanNew("m00"), NanNew<Number>(mu.m00));
res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10)); res->Set(NanNew("m10"), NanNew<Number>(mu.m10));
res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01)); res->Set(NanNew("m01"), NanNew<Number>(mu.m01));
res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11)); res->Set(NanNew("m11"), NanNew<Number>(mu.m11));
info.GetReturnValue().Set(res); NanReturnValue(res);
} }
NAN_METHOD(Contour::Hierarchy) { NAN_METHOD(Contour::Hierarchy) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = info[0]->IntegerValue(); int pos = args[0]->IntegerValue();
cv::Vec4i hierarchy = self->hierarchy[pos]; cv::Vec4i hierarchy = self->hierarchy[pos];
Local<Array> res = Nan::New<Array>(4); Local<Array> res = NanNew<Array>(4);
res->Set(0, Nan::New<Number>(hierarchy[0])); res->Set(0, NanNew<Number>(hierarchy[0]));
res->Set(1, Nan::New<Number>(hierarchy[1])); res->Set(1, NanNew<Number>(hierarchy[1]));
res->Set(2, Nan::New<Number>(hierarchy[2])); res->Set(2, NanNew<Number>(hierarchy[2]));
res->Set(3, Nan::New<Number>(hierarchy[3])); res->Set(3, NanNew<Number>(hierarchy[3]));
info.GetReturnValue().Set(res); NanReturnValue(res);
} }
NAN_METHOD(Contour::Serialize) { NAN_METHOD(Contour::Serialize) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
Local<Array> contours_data = Nan::New<Array>(self->contours.size()); Local<Array> contours_data = NanNew<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 = Nan::New<Array>(points.size()); Local<Array> contour_data = NanNew<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 = Nan::New<Array>(2); Local<Array> point_data = NanNew<Array>(2);
point_data->Set(0, Nan::New<Number>(points[j].x)); point_data->Set(0, NanNew<Number>(points[j].x));
point_data->Set(1, Nan::New<Number>(points[j].y)); point_data->Set(1, NanNew<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 = Nan::New<Array>(self->hierarchy.size()); Local<Array> hierarchy_data = NanNew<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 = Nan::New<Array>(4); Local<Array> contour_data = NanNew<Array>(4);
contour_data->Set(0, Nan::New<Number>(self->hierarchy[i][0])); contour_data->Set(0, NanNew<Number>(self->hierarchy[i][0]));
contour_data->Set(1, Nan::New<Number>(self->hierarchy[i][1])); contour_data->Set(1, NanNew<Number>(self->hierarchy[i][1]));
contour_data->Set(2, Nan::New<Number>(self->hierarchy[i][2])); contour_data->Set(2, NanNew<Number>(self->hierarchy[i][2]));
contour_data->Set(3, Nan::New<Number>(self->hierarchy[i][3])); contour_data->Set(3, NanNew<Number>(self->hierarchy[i][3]));
hierarchy_data->Set(i, contour_data); hierarchy_data->Set(i, contour_data);
} }
Local<Object> data = Nan::New<Object>(); Local<Object> data = NanNew<Object>();
data->Set(Nan::New<String>("contours").ToLocalChecked(), contours_data); data->Set(NanNew<String>("contours"), contours_data);
data->Set(Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data); data->Set(NanNew<String>("hierarchy"), hierarchy_data);
info.GetReturnValue().Set(data); NanReturnValue(data);
} }
NAN_METHOD(Contour::Deserialize) { NAN_METHOD(Contour::Deserialize) {
Nan::HandleScope scope; NanScope();
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This()); Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
Handle<Object> data = Handle<Object>::Cast(info[0]); Handle<Object> data = Handle<Object>::Cast(args[0]);
Handle<Array> contours_data = Handle<Array>::Cast(data->Get(Nan::New<String>("contours").ToLocalChecked())); Handle<Array> contours_data = Handle<Array>::Cast(data->Get(NanNew<String>("contours")));
Handle<Array> hierarchy_data = Handle<Array>::Cast(data->Get(Nan::New<String>("hierarchy").ToLocalChecked())); Handle<Array> hierarchy_data = Handle<Array>::Cast(data->Get(NanNew<String>("hierarchy")));
vector<vector<cv::Point> > contours_res; vector<vector<cv::Point> > contours_res;
int contours_length = contours_data->Length(); int contours_length = contours_data->Length();
@ -369,5 +369,5 @@ NAN_METHOD(Contour::Deserialize) {
self->contours = contours_res; self->contours = contours_res;
self->hierarchy = hierarchy_res; self->hierarchy = hierarchy_res;
info.GetReturnValue().Set(Nan::Null()); NanReturnNull();
} }

4
src/Contours.h Normal file → Executable file
View File

@ -2,13 +2,13 @@
using namespace std; using namespace std;
class Contour: public Nan::ObjectWrap { class Contour: public node::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 Nan::Persistent<FunctionTemplate> constructor; static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Handle<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);

112
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(*Nan::Utf8String(v->ToString())); std::string filename = std::string(*NanAsciiString(v->ToString()));
im = cv::imread(filename); im = cv::imread(filename);
// std::cout<< im.size(); // std::cout<< im.size();
} else { } else {
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(v->ToObject()); Matrix *img = 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);
Nan::Persistent<FunctionTemplate> FaceRecognizerWrap::constructor; Persistent<FunctionTemplate> FaceRecognizerWrap::constructor;
void FaceRecognizerWrap::Init(Handle<Object> target) { void FaceRecognizerWrap::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
// Constructor // Constructor
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(FaceRecognizerWrap::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(FaceRecognizerWrap::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("FaceRecognizer").ToLocalChecked()); ctor->SetClassName(NanNew("FaceRecognizer"));
Nan::SetMethod(ctor, "createLBPHFaceRecognizer", CreateLBPH); NODE_SET_METHOD(ctor, "createLBPHFaceRecognizer", CreateLBPH);
Nan::SetMethod(ctor, "createEigenFaceRecognizer", CreateEigen); NODE_SET_METHOD(ctor, "createEigenFaceRecognizer", CreateEigen);
Nan::SetMethod(ctor, "createFisherFaceRecognizer", CreateFisher); NODE_SET_METHOD(ctor, "createFisherFaceRecognizer", CreateFisher);
Nan::SetPrototypeMethod(ctor, "trainSync", TrainSync); NODE_SET_PROTOTYPE_METHOD(ctor, "trainSync", TrainSync);
Nan::SetPrototypeMethod(ctor, "updateSync", UpdateSync); NODE_SET_PROTOTYPE_METHOD(ctor, "updateSync", UpdateSync);
Nan::SetPrototypeMethod(ctor, "predictSync", PredictSync); NODE_SET_PROTOTYPE_METHOD(ctor, "predictSync", PredictSync);
Nan::SetPrototypeMethod(ctor, "saveSync", SaveSync); NODE_SET_PROTOTYPE_METHOD(ctor, "saveSync", SaveSync);
Nan::SetPrototypeMethod(ctor, "loadSync", LoadSync); NODE_SET_PROTOTYPE_METHOD(ctor, "loadSync", LoadSync);
Nan::SetPrototypeMethod(ctor, "getMat", GetMat); NODE_SET_PROTOTYPE_METHOD(ctor, "getMat", GetMat);
target->Set(Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("FaceRecognizer"), ctor->GetFunction());
}; };
NAN_METHOD(FaceRecognizerWrap::New) { NAN_METHOD(FaceRecognizerWrap::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) { if (args.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(info.This()); pt->Wrap(args.This());
info.GetReturnValue().Set(info.This()); NanReturnValue(args.This());
} }
NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { NAN_METHOD(FaceRecognizerWrap::CreateLBPH) {
Nan::HandleScope scope; NanScope();
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 = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = NanNew(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);
info.GetReturnValue().Set( n ); NanReturnValue( n );
} }
NAN_METHOD(FaceRecognizerWrap::CreateEigen) { NAN_METHOD(FaceRecognizerWrap::CreateEigen) {
Nan::HandleScope scope; NanScope();
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 = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = NanNew(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);
info.GetReturnValue().Set( n ); NanReturnValue( n );
} }
NAN_METHOD(FaceRecognizerWrap::CreateFisher) { NAN_METHOD(FaceRecognizerWrap::CreateFisher) {
Nan::HandleScope scope; NanScope();
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 = Nan::New(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); Local<Object> n = NanNew(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);
info.GetReturnValue().Set( n ); NanReturnValue( 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::NAN_METHOD_ARGS_TYPE info, Handle<Value> UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args,
cv::vector<cv::Mat>* images, cv::vector<int>* labels) { cv::vector<cv::Mat>* images, cv::vector<int>* labels) {
if (info.Length() < 1 || !info[0]->IsArray()) { if (args.Length() < 1 || !args[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(*info[0]); // const Local<Array> tuples = v8::Array::Cast(*args[0]);
const Local<Array> tuples = Local<Array>::Cast(info[0]); const Local<Array> tuples = Local<Array>::Cast(args[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::NAN_METHOD_ARGS_TYPE info,
labels->push_back(label); labels->push_back(label);
images->push_back(im); images->push_back(im);
} }
return Nan::Undefined(); return NanUndefined();
} }
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(info, &images, &labels); Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
if (!exception->IsUndefined()) { if (!exception->IsUndefined()) {
info.GetReturnValue().Set(exception); // FIXME: not too sure about returning exceptions like this NanReturnValue(exception); // FIXME: not too sure about returning exceptions like this
} }
self->rec->train(images, labels); self->rec->train(images, labels);
return; NanReturnUndefined();
} }
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(info, &images, &labels); Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
if (!exception->IsUndefined()) { if (!exception->IsUndefined()) {
JSTHROW(exception); JSTHROW(exception);
} }
self->rec->update(images, labels); self->rec->update(images, labels);
return; NanReturnUndefined();
} }
NAN_METHOD(FaceRecognizerWrap::PredictSync) { NAN_METHOD(FaceRecognizerWrap::PredictSync) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
cv::Mat im = fromMatrixOrFilename(info[0]); // TODO CHECK! cv::Mat im = fromMatrixOrFilename(args[0]); // TODO CHECK!
cv::cvtColor(im, im, CV_RGB2GRAY); 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 = Nan::New<Object>(); v8::Local<v8::Object> res = NanNew<Object>();
res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel)); res->Set(NanNew("id"), NanNew<Number>(predictedLabel));
res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence)); res->Set(NanNew("confidence"), NanNew<Number>(confidence));
info.GetReturnValue().Set(res); NanReturnValue(res);
} }
NAN_METHOD(FaceRecognizerWrap::SaveSync) { NAN_METHOD(FaceRecognizerWrap::SaveSync) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
if (!info[0]->IsString()) { if (!args[0]->IsString()) {
JSTHROW("Save takes a filename") JSTHROW("Save takes a filename")
} }
std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); std::string filename = std::string(*NanAsciiString(args[0]->ToString()));
self->rec->save(filename); self->rec->save(filename);
return; NanReturnUndefined();
} }
NAN_METHOD(FaceRecognizerWrap::LoadSync) { NAN_METHOD(FaceRecognizerWrap::LoadSync) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
if (!info[0]->IsString()) { if (!args[0]->IsString()) {
JSTHROW("Load takes a filename") JSTHROW("Load takes a filename")
} }
std::string filename = std::string(*Nan::Utf8String(info[0]->ToString())); std::string filename = std::string(*NanAsciiString(args[0]->ToString()));
self->rec->load(filename); self->rec->load(filename);
return; NanReturnUndefined();
} }
NAN_METHOD(FaceRecognizerWrap::GetMat) { NAN_METHOD(FaceRecognizerWrap::GetMat) {
SETUP_FUNCTION(FaceRecognizerWrap) SETUP_FUNCTION(FaceRecognizerWrap)
if (!info[0]->IsString()) { if (!args[0]->IsString()) {
JSTHROW("getMat takes a key") JSTHROW("getMat takes a key")
} }
std::string key = std::string(*Nan::Utf8String(info[0]->ToString())); std::string key = std::string(*NanAsciiString(args[0]->ToString()));
cv::Mat m = self->rec->getMat(key); cv::Mat m = self->rec->getMat(key);
Local<Object> im = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im); Matrix *img = ObjectWrap::Unwrap<Matrix>(im);
img->mat = m; img->mat = m;
info.GetReturnValue().Set(im); NanReturnValue(im);
} }
#endif // End version > 2.4 #endif // End version > 2.4

4
src/FaceRecognizer.h
View File

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

28
src/Features2d.cc
View File

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

4
src/Features2d.h
View File

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

54
src/HighGUI.cc
View File

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

4
src/HighGUI.h
View File

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

88
src/ImgProc.cc
View File

@ -2,34 +2,34 @@
#include "Matrix.h" #include "Matrix.h"
void ImgProc::Init(Handle<Object> target) { void ImgProc::Init(Handle<Object> target) {
Nan::Persistent<Object> inner; Persistent<Object> inner;
Local<Object> obj = Nan::New<Object>(); Local<Object> obj = NanNew<Object>();
inner.Reset(obj); NanAssignPersistent(inner, obj);
Nan::SetMethod(obj, "undistort", Undistort); NODE_SET_METHOD(obj, "undistort", Undistort);
Nan::SetMethod(obj, "initUndistortRectifyMap", InitUndistortRectifyMap); NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
Nan::SetMethod(obj, "remap", Remap); NODE_SET_METHOD(obj, "remap", Remap);
target->Set(Nan::New("imgproc").ToLocalChecked(), obj); target->Set(NanNew("imgproc"), obj);
} }
// cv::undistort // cv::undistort
NAN_METHOD(ImgProc::Undistort) { NAN_METHOD(ImgProc::Undistort) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the image // Arg 0 is the image
Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject()); Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject()); Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = Nan::ObjectWrap::Unwrap<Matrix>(outMatrixWrap); Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
outMatrix->mat = outputImage; outMatrix->mat = outputImage;
// Return the output image // Return the output image
info.GetReturnValue().Set(outMatrixWrap); NanReturnValue(outMatrixWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::initUndistortRectifyMap // cv::initUndistortRectifyMap
NAN_METHOD(ImgProc::InitUndistortRectifyMap) { NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Arg 0 is the camera matrix // Arg 0 is the camera matrix
Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject()); Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject()); Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[3]->ToObject()); Matrix* m3 = ObjectWrap::Unwrap<Matrix>(args[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 (info[4]->IsArray()) { if (args[4]->IsArray()) {
Local<Object> v8sz = info[4]->ToObject(); Local<Object> v8sz = args[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 = info[5]->IntegerValue(); int m1type = args[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 = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map1Matrix = Nan::ObjectWrap::Unwrap<Matrix>(map1Wrap); Matrix *map1Matrix = ObjectWrap::Unwrap<Matrix>(map1Wrap);
map1Matrix->mat = map1; map1Matrix->mat = map1;
Local<Object> map2Wrap = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *map2Matrix = Nan::ObjectWrap::Unwrap<Matrix>(map2Wrap); Matrix *map2Matrix = 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 = Nan::New<Object>(); Local<Object> ret = NanNew<Object>();
ret->Set(Nan::New<String>("map1").ToLocalChecked(), map1Wrap); ret->Set(NanNew<String>("map1"), map1Wrap);
ret->Set(Nan::New<String>("map2").ToLocalChecked(), map2Wrap); ret->Set(NanNew<String>("map2"), map2Wrap);
// Return the maps // Return the maps
info.GetReturnValue().Set(ret); NanReturnValue(ret);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// cv::remap // cv::remap
NAN_METHOD(ImgProc::Remap) { NAN_METHOD(ImgProc::Remap) {
Nan::EscapableHandleScope scope; NanEscapableScope();
try { try {
// Get the arguments // Get the arguments
// Arg 0 is the image // Arg 0 is the image
Matrix* m0 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject()); Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[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 = Nan::ObjectWrap::Unwrap<Matrix>(info[2]->ToObject()); Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[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 = info[3]->IntegerValue(); int interpolation = args[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 = Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *outMatrix = Nan::ObjectWrap::Unwrap<Matrix>(outMatrixWrap); Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
outMatrix->mat = outputImage; outMatrix->mat = outputImage;
// Return the image // Return the image
info.GetReturnValue().Set(outMatrixWrap); NanReturnValue(outMatrixWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }

2
src/ImgProc.h
View File

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

1414
src/Matrix.cc Normal file → Executable file
View File

File diff suppressed because it is too large Load Diff

58
src/Matrix.h Normal file → Executable file
View File

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

40
src/OpenCV.cc Normal file → Executable file
View File

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

24
src/OpenCV.h Normal file → Executable file
View File

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

60
src/Point.cc Normal file → Executable file
View File

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

4
src/Point.h Normal file → Executable file
View File

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

218
src/Stereo.cc
View File

@ -4,54 +4,54 @@
// Block matching // Block matching
Nan::Persistent<FunctionTemplate> StereoBM::constructor; v8::Persistent<FunctionTemplate> StereoBM::constructor;
void StereoBM::Init(Handle<Object> target) { void StereoBM::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoBM::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoBM::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("StereoBM").ToLocalChecked()); ctor->SetClassName(NanNew("StereoBM"));
Nan::SetPrototypeMethod(ctor, "compute", Compute); NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute);
ctor->Set(Nan::New<String>("BASIC_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::BASIC_PRESET)); ctor->Set(NanNew<String>("BASIC_PRESET"), NanNew<Integer>((int)cv::StereoBM::BASIC_PRESET));
ctor->Set(Nan::New<String>("FISH_EYE_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::FISH_EYE_PRESET)); ctor->Set(NanNew<String>("FISH_EYE_PRESET"), NanNew<Integer>((int)cv::StereoBM::FISH_EYE_PRESET));
ctor->Set(Nan::New<String>("NARROW_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::NARROW_PRESET)); ctor->Set(NanNew<String>("NARROW_PRESET"), NanNew<Integer>((int)cv::StereoBM::NARROW_PRESET));
target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("StereoBM"), ctor->GetFunction());
} }
NAN_METHOD(StereoBM::New) { NAN_METHOD(StereoBM::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) { if (args.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new"); NanThrowTypeError("Cannot instantiate without new");
} }
StereoBM *stereo; StereoBM *stereo;
if (info.Length() == 0) { if (args.Length() == 0) {
stereo = new StereoBM(); stereo = new StereoBM();
} else if (info.Length() == 1) { } else if (args.Length() == 1) {
// preset // preset
stereo = new StereoBM(info[0]->IntegerValue()); stereo = new StereoBM(args[0]->IntegerValue());
} else if (info.Length() == 2) { } else if (args.Length() == 2) {
// preset, disparity search range // preset, disparity search range
stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue()); stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue());
} else { } else {
stereo = new StereoBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
// preset, disparity search range, sum of absolute differences window size // preset, disparity search range, sum of absolute differences window size
info[2]->IntegerValue()); args[2]->IntegerValue());
} }
stereo->Wrap(info.Holder()); stereo->Wrap(args.Holder());
info.GetReturnValue().Set(info.Holder()); NanReturnValue(args.Holder());
} }
StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) : StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) :
Nan::ObjectWrap(), 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 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
cv::Mat left = m0->mat; cv::Mat left = m0->mat;
// Arg 1, the 'right' image // Arg 1, the 'right' image
Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject()); Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[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 (info.Length() > 2) { if (args.Length() > 2) {
type = info[2]->IntegerValue(); type = args[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 =
Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap); Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap);
disp->mat = disparity; disp->mat = disparity;
info.GetReturnValue().Set(disparityWrap); NanReturnValue(disparityWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// Semi-Global Block matching // Semi-Global Block matching
Nan::Persistent<FunctionTemplate> StereoSGBM::constructor; v8::Persistent<FunctionTemplate> StereoSGBM::constructor;
void StereoSGBM::Init(Handle<Object> target) { void StereoSGBM::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoSGBM::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoSGBM::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("StereoSGBM").ToLocalChecked()); ctor->SetClassName(NanNew("StereoSGBM"));
Nan::SetPrototypeMethod(ctor, "compute", Compute); NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute);
target->Set(Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("StereoSGBM"), ctor->GetFunction());
} }
NAN_METHOD(StereoSGBM::New) { NAN_METHOD(StereoSGBM::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) { if (args.This()->InternalFieldCount() == 0) {
Nan::ThrowTypeError("Cannot instantiate without new"); NanThrowTypeError("Cannot instantiate without new");
} }
StereoSGBM *stereo; StereoSGBM *stereo;
if (info.Length() == 0) { if (args.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 (info.Length() >= 3) { if (args.Length() >= 3) {
switch (info.Length()) { switch (args.Length()) {
case 3: case 3:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue()); args[2]->IntegerValue());
break; break;
case 4: case 4:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue()); args[2]->IntegerValue(), args[3]->IntegerValue());
break; break;
case 5: case 5:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue()); args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue());
break; break;
case 6: case 6:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
info[5]->IntegerValue()); args[5]->IntegerValue());
break; break;
case 7: case 7:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue()); args[5]->IntegerValue(), args[6]->IntegerValue());
break; break;
case 8: case 8:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue()); args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue());
break; break;
case 9: case 9:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(),
info[8]->IntegerValue()); args[8]->IntegerValue());
break; break;
case 10: case 10:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(),
info[8]->IntegerValue(), info[9]->IntegerValue()); args[8]->IntegerValue(), args[9]->IntegerValue());
break; break;
default: default:
stereo = new StereoSGBM(info[0]->IntegerValue(), info[1]->IntegerValue(), stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(),
info[2]->IntegerValue(), info[3]->IntegerValue(), info[4]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(),
info[5]->IntegerValue(), info[6]->IntegerValue(), info[7]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(),
info[8]->IntegerValue(), info[9]->IntegerValue(), info[10]->ToBoolean()->Value()); args[8]->IntegerValue(), args[9]->IntegerValue(), args[10]->ToBoolean()->Value());
break; break;
} }
} else { } else {
Nan::ThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize"); NanThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize");
return; NanReturnUndefined();
} }
} }
stereo->Wrap(info.Holder()); stereo->Wrap(args.Holder());
info.GetReturnValue().Set(info.Holder()); NanReturnValue(args.Holder());
} }
StereoSGBM::StereoSGBM() : StereoSGBM::StereoSGBM() :
Nan::ObjectWrap(), 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) :
Nan::ObjectWrap(), 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 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
cv::Mat left = m0->mat; cv::Mat left = m0->mat;
// Arg 1, the 'right' image // Arg 1, the 'right' image
Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject()); Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[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 =
Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap); Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap);
disp->mat = disparity; disp->mat = disparity;
info.GetReturnValue().Set(disparityWrap); NanReturnValue(disparityWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }
// Graph cut // Graph cut
Nan::Persistent<FunctionTemplate> StereoGC::constructor; v8::Persistent<FunctionTemplate> StereoGC::constructor;
void StereoGC::Init(Handle<Object> target) { void StereoGC::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(StereoGC::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(StereoGC::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("StereoGC").ToLocalChecked()); ctor->SetClassName(NanNew("StereoGC"));
Nan::SetPrototypeMethod(ctor, "compute", Compute); NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute);
target->Set(Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("StereoGC"), ctor->GetFunction());
} }
NAN_METHOD(StereoGC::New) { NAN_METHOD(StereoGC::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) if (args.This()->InternalFieldCount() == 0)
Nan::ThrowTypeError("Cannot instantiate without new"); NanThrowTypeError("Cannot instantiate without new");
StereoGC *stereo; StereoGC *stereo;
if (info.Length() == 0) { if (args.Length() == 0) {
stereo = new StereoGC(); stereo = new StereoGC();
} else if (info.Length() == 1) { } else if (args.Length() == 1) {
// numberOfDisparities // numberOfDisparities
stereo = new StereoGC(info[0]->IntegerValue()); stereo = new StereoGC(args[0]->IntegerValue());
} else { } else {
// max iterations // max iterations
stereo = new StereoGC(info[0]->IntegerValue(), info[1]->IntegerValue()); stereo = new StereoGC(args[0]->IntegerValue(), args[1]->IntegerValue());
} }
stereo->Wrap(info.Holder()); stereo->Wrap(args.Holder());
info.GetReturnValue().Set(info.Holder()); NanReturnValue(args.Holder());
} }
StereoGC::StereoGC(int numberOfDisparities, int maxIters) : StereoGC::StereoGC(int numberOfDisparities, int maxIters) :
Nan::ObjectWrap() { 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 = Nan::ObjectWrap::Unwrap<Matrix>(info[0]->ToObject()); Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
cv::Mat left = m0->mat; cv::Mat left = m0->mat;
// Arg 1, the 'right' image // Arg 1, the 'right' image
Matrix* m1 = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject()); Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[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 =
Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *disp = Nan::ObjectWrap::Unwrap<Matrix>(disparityWrap); Matrix *disp = ObjectWrap::Unwrap<Matrix>(disparityWrap);
disp->mat = disparity; disp->mat = disparity;
info.GetReturnValue().Set(disparityWrap); NanReturnValue(disparityWrap);
} catch (cv::Exception &e) { } catch (cv::Exception &e) {
const char *err_msg = e.what(); const char *err_msg = e.what();
Nan::ThrowError(err_msg); NanThrowError(err_msg);
return; NanReturnUndefined();
} }
} }

12
src/Stereo.h
View File

@ -3,11 +3,11 @@
#include "OpenCV.h" #include "OpenCV.h"
class StereoBM: public Nan::ObjectWrap { class StereoBM: public node::ObjectWrap {
public: public:
cv::StereoBM stereo; cv::StereoBM stereo;
static Nan::Persistent<FunctionTemplate> constructor; static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Handle<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
@ -18,11 +18,11 @@ public:
; ;
}; };
class StereoSGBM: public Nan::ObjectWrap { class StereoSGBM: public node::ObjectWrap {
public: public:
cv::StereoSGBM stereo; cv::StereoSGBM stereo;
static Nan::Persistent<FunctionTemplate> constructor; static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Handle<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);
@ -37,11 +37,11 @@ public:
struct CvStereoGCState; struct CvStereoGCState;
class StereoGC: public Nan::ObjectWrap { class StereoGC: public node::ObjectWrap {
public: public:
CvStereoGCState *stereo; CvStereoGCState *stereo;
static Nan::Persistent<FunctionTemplate> constructor; static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target); static void Init(Handle<Object> target);
static NAN_METHOD(New); static NAN_METHOD(New);

156
src/VideoCaptureWrap.cc Normal file → Executable file
View File

@ -5,11 +5,11 @@
#include <iostream> #include <iostream>
using namespace std; using namespace std;
Nan::Persistent<FunctionTemplate> VideoCaptureWrap::constructor; v8::Persistent<FunctionTemplate> VideoCaptureWrap::constructor;
struct videocapture_baton { struct videocapture_baton {
Nan::Persistent<Function> cb; Persistent<Function> cb;
VideoCaptureWrap *vc; VideoCaptureWrap *vc;
Matrix *im; Matrix *im;
@ -17,124 +17,124 @@ struct videocapture_baton {
}; };
void VideoCaptureWrap::Init(Handle<Object> target) { void VideoCaptureWrap::Init(Handle<Object> target) {
Nan::HandleScope scope; NanScope();
//Class //Class
Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(VideoCaptureWrap::New); Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(VideoCaptureWrap::New);
constructor.Reset(ctor); NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(Nan::New("VideoCapture").ToLocalChecked()); ctor->SetClassName(NanNew("VideoCapture"));
// Prototype // Prototype
//Local<ObjectTemplate> proto = constructor->PrototypeTemplate(); //Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
Nan::SetPrototypeMethod(ctor, "read", Read); NODE_SET_PROTOTYPE_METHOD(ctor, "read", Read);
Nan::SetPrototypeMethod(ctor, "setWidth", SetWidth); NODE_SET_PROTOTYPE_METHOD(ctor, "setWidth", SetWidth);
Nan::SetPrototypeMethod(ctor, "setHeight", SetHeight); NODE_SET_PROTOTYPE_METHOD(ctor, "setHeight", SetHeight);
Nan::SetPrototypeMethod(ctor, "setPosition", SetPosition); NODE_SET_PROTOTYPE_METHOD(ctor, "setPosition", SetPosition);
Nan::SetPrototypeMethod(ctor, "close", Close); NODE_SET_PROTOTYPE_METHOD(ctor, "close", Close);
Nan::SetPrototypeMethod(ctor, "ReadSync", ReadSync); NODE_SET_PROTOTYPE_METHOD(ctor, "ReadSync", ReadSync);
Nan::SetPrototypeMethod(ctor, "grab", Grab); NODE_SET_PROTOTYPE_METHOD(ctor, "grab", Grab);
Nan::SetPrototypeMethod(ctor, "retrieve", Retrieve); NODE_SET_PROTOTYPE_METHOD(ctor, "retrieve", Retrieve);
target->Set(Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction()); target->Set(NanNew("VideoCapture"), ctor->GetFunction());
} }
NAN_METHOD(VideoCaptureWrap::New) { NAN_METHOD(VideoCaptureWrap::New) {
Nan::HandleScope scope; NanScope();
if (info.This()->InternalFieldCount() == 0) if (args.This()->InternalFieldCount() == 0)
return Nan::ThrowTypeError("Cannot Instantiate without new"); return NanThrowTypeError("Cannot Instantiate without new");
VideoCaptureWrap *v; VideoCaptureWrap *v;
if (info[0]->IsNumber()) { if (args[0]->IsNumber()) {
v = new VideoCaptureWrap(info[0]->NumberValue()); v = new VideoCaptureWrap(args[0]->NumberValue());
} else { } else {
//TODO - assumes that we have string, verify //TODO - assumes that we have string, verify
v = new VideoCaptureWrap(std::string(*Nan::Utf8String(info[0]->ToString()))); v = new VideoCaptureWrap(std::string(*NanAsciiString(args[0]->ToString())));
} }
v->Wrap(info.This()); v->Wrap(args.This());
info.GetReturnValue().Set(info.This()); NanReturnValue(args.This());
} }
VideoCaptureWrap::VideoCaptureWrap(int device) { VideoCaptureWrap::VideoCaptureWrap(int device) {
Nan::HandleScope scope; NanScope();
cap.open(device); cap.open(device);
if(!cap.isOpened()) { if(!cap.isOpened()) {
Nan::ThrowError("Camera could not be opened"); NanThrowError("Camera could not be opened");
} }
} }
VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) { VideoCaptureWrap::VideoCaptureWrap(const std::string& filename) {
Nan::HandleScope scope; NanScope();
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()) {
Nan::ThrowError("Video file could not be opened (opencv reqs. non relative paths)"); NanThrowError("Video file could not be opened (opencv reqs. non relative paths)");
} }
} }
NAN_METHOD(VideoCaptureWrap::SetWidth) { NAN_METHOD(VideoCaptureWrap::SetWidth) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
if(info.Length() != 1) if(args.Length() != 1)
return; NanReturnUndefined();
int w = info[0]->IntegerValue(); int w = args[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);
return; NanReturnUndefined();
} }
NAN_METHOD(VideoCaptureWrap::SetHeight) { NAN_METHOD(VideoCaptureWrap::SetHeight) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
if(info.Length() != 1) if(args.Length() != 1)
return; NanReturnUndefined();
int h = info[0]->IntegerValue(); int h = args[0]->IntegerValue();
v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h); v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h);
return; NanReturnUndefined();
} }
NAN_METHOD(VideoCaptureWrap::SetPosition) { NAN_METHOD(VideoCaptureWrap::SetPosition) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
if(info.Length() != 1) if(args.Length() != 1)
return; NanReturnUndefined();
int pos = info[0]->IntegerValue(); int pos = args[0]->IntegerValue();
v->cap.set(CV_CAP_PROP_POS_FRAMES, pos); v->cap.set(CV_CAP_PROP_POS_FRAMES, pos);
return; NanReturnUndefined();
} }
NAN_METHOD(VideoCaptureWrap::Close) { NAN_METHOD(VideoCaptureWrap::Close) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
v->cap.release(); v->cap.release();
return; NanReturnUndefined();
} }
class AsyncVCWorker: public Nan::AsyncWorker { class AsyncVCWorker: public NanAsyncWorker {
public: public:
AsyncVCWorker(Nan::Callback *callback, VideoCaptureWrap* vc, AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc,
bool retrieve = false, int channel = 0) : bool retrieve = false, int channel = 0) :
Nan::AsyncWorker(callback), NanAsyncWorker(callback),
vc(vc), vc(vc),
retrieve(retrieve), retrieve(retrieve),
channel(channel) { channel(channel) {
@ -161,14 +161,14 @@ 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() {
Nan::HandleScope scope; NanScope();
Local<Object> im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_to_return); Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
img->mat = mat; img->mat = mat;
Local<Value> argv[] = { Local<Value> argv[] = {
Nan::Null() NanNull()
, im_to_return , im_to_return
}; };
@ -187,33 +187,33 @@ private:
}; };
NAN_METHOD(VideoCaptureWrap::Read) { NAN_METHOD(VideoCaptureWrap::Read) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
REQ_FUN_ARG(0, cb); REQ_FUN_ARG(0, cb);
Nan::Callback *callback = new Nan::Callback(cb.As<Function>()); NanCallback *callback = new NanCallback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v)); NanAsyncQueueWorker(new AsyncVCWorker(callback, v));
return; NanReturnUndefined();
} }
NAN_METHOD(VideoCaptureWrap::ReadSync) { NAN_METHOD(VideoCaptureWrap::ReadSync) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
Local<Object> im_to_return= Nan::New(Matrix::constructor)->GetFunction()->NewInstance(); Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = Nan::ObjectWrap::Unwrap<Matrix>(im_to_return); Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
v->cap.read(img->mat); v->cap.read(img->mat);
info.GetReturnValue().Set(im_to_return); NanReturnValue(im_to_return);
} }
class AsyncGrabWorker: public Nan::AsyncWorker { class AsyncGrabWorker: public NanAsyncWorker {
public: public:
AsyncGrabWorker(Nan::Callback *callback, VideoCaptureWrap* vc) : AsyncGrabWorker(NanCallback *callback, VideoCaptureWrap* vc) :
Nan::AsyncWorker(callback), NanAsyncWorker(callback),
vc(vc) { vc(vc) {
} }
@ -231,27 +231,27 @@ private:
}; };
NAN_METHOD(VideoCaptureWrap::Grab) { NAN_METHOD(VideoCaptureWrap::Grab) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
REQ_FUN_ARG(0, cb); REQ_FUN_ARG(0, cb);
Nan::Callback *callback = new Nan::Callback(cb.As<Function>()); NanCallback *callback = new NanCallback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncGrabWorker(callback, v)); NanAsyncQueueWorker(new AsyncGrabWorker(callback, v));
return; NanReturnUndefined();
} }
NAN_METHOD(VideoCaptureWrap::Retrieve) { NAN_METHOD(VideoCaptureWrap::Retrieve) {
Nan::HandleScope scope; NanScope();
VideoCaptureWrap *v = Nan::ObjectWrap::Unwrap<VideoCaptureWrap>(info.This()); VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.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);
Nan::Callback *callback = new Nan::Callback(cb.As<Function>()); NanCallback *callback = new NanCallback(cb.As<Function>());
Nan::AsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel)); NanAsyncQueueWorker(new AsyncVCWorker(callback, v, true, channel));
return; NanReturnUndefined();
} }

4
src/VideoCaptureWrap.h Normal file → Executable file
View File

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

2
src/init.cc Normal file → Executable file
View File

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

2
vagrant/user.sh
View File

@ -24,5 +24,3 @@ apt-get -y install libgtk2.0-dev
cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON .. cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_PYTHON_SUPPORT=ON ..
make install make install
cd /home/vagrant/$REPO_FOLDER/ cd /home/vagrant/$REPO_FOLDER/
npm install node-gyp -g