From 668c21dc441486a51d81acbe9ee617254b1a0e2f Mon Sep 17 00:00:00 2001 From: Mark kaosat-dev Moissette Date: Fri, 5 Sep 2014 16:07:47 +0200 Subject: [PATCH 01/12] - added close() method to VideoCapture base on opencv capture's "release" method - added experimental ReadSync method : this serves two purposes: * usefull when not using callbacks * a possible workaround for huge memoryleaks in videocapture --- src/VideoCaptureWrap.cc | 30 ++++++++++++++++++++++++++++++ src/VideoCaptureWrap.h | 5 +++++ 2 files changed, 35 insertions(+) diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index fb8a796..22308ab 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -37,6 +37,8 @@ VideoCaptureWrap::Init(Handle target) { NODE_SET_PROTOTYPE_METHOD(constructor, "setWidth", SetWidth); NODE_SET_PROTOTYPE_METHOD(constructor, "setHeight", SetHeight); NODE_SET_PROTOTYPE_METHOD(constructor, "setPosition", SetPosition); + NODE_SET_PROTOTYPE_METHOD(constructor, "close", Close); + NODE_SET_PROTOTYPE_METHOD(constructor, "ReadSync", ReadSync); target->Set(String::NewSymbol("VideoCapture"), constructor->GetFunction()); }; @@ -132,6 +134,17 @@ VideoCaptureWrap::SetPosition(const Arguments &args){ return Undefined(); } +Handle +VideoCaptureWrap::Close(const Arguments &args){ + + HandleScope scope; + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + + v->cap.release(); + + return Undefined(); +} + Handle VideoCaptureWrap::Read(const Arguments &args) { @@ -181,3 +194,20 @@ void AfterAsyncRead(uv_work_t *req) { delete baton; } + + + +Handle +VideoCaptureWrap::ReadSync(const Arguments &args) { + + HandleScope scope; + VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); + + Local im_to_return= Matrix::constructor->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_to_return); + + v->cap.read(img->mat); + + return scope.Close(im_to_return); + +} diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h index b239273..7955406 100755 --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -23,5 +23,10 @@ class VideoCaptureWrap: public node::ObjectWrap { static Handle GetFrameAt(const v8::Arguments&); + //close the stream + static Handle Close(const v8::Arguments&); + + //experimental + static Handle ReadSync(const v8::Arguments&); }; From 8db4e0ed2d39379e91ba8e775d9eef48a24667c6 Mon Sep 17 00:00:00 2001 From: Mark kaosat-dev Moissette Date: Wed, 10 Sep 2014 13:41:09 +0200 Subject: [PATCH 02/12] - added nan dependency - updated binding.gyp - ported all header files to the nan api --- binding.gyp | 4 ++-- package.json | 3 ++- src/CamShift.h | 3 ++- src/CascadeClassifierWrap.h | 7 +++++-- src/Contours.h | 20 ++++++++++++++++---- src/FaceRecognizer.h | 3 ++- src/HighGUI.h | 3 ++- src/Matrix.h | 3 ++- src/OpenCV.h | 9 ++++++--- src/Point.h | 17 +++++++++++------ src/VideoCaptureWrap.h | 26 +++++++++++++++++--------- src/init.cc | 3 ++- 12 files changed, 69 insertions(+), 32 deletions(-) diff --git a/binding.gyp b/binding.gyp index 72df9f3..f8b73fa 100755 --- a/binding.gyp +++ b/binding.gyp @@ -20,7 +20,8 @@ # For windows ,'include_dirs': [ - '", "dependencies": { - "buffers": "0.1.1" + "buffers": "0.1.1", + "nan": "^1.3.0" }, "version": "0.5.0", "devDependencies": { diff --git a/src/CamShift.h b/src/CamShift.h index 649a65f..c79b090 100644 --- a/src/CamShift.h +++ b/src/CamShift.h @@ -14,7 +14,8 @@ class TrackedObject: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); TrackedObject(cv::Mat image, cv::Rect rect, int channel); diff --git a/src/CascadeClassifierWrap.h b/src/CascadeClassifierWrap.h index fa42309..fb3c033 100755 --- a/src/CascadeClassifierWrap.h +++ b/src/CascadeClassifierWrap.h @@ -6,13 +6,16 @@ class CascadeClassifierWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); CascadeClassifierWrap(v8::Value* fileName); //static Handle LoadHaarClassifierCascade(const v8::Arguments&); - static Handle DetectMultiScale(const v8::Arguments&); + //static Handle DetectMultiScale(const v8::Arguments&); + static NAN_METHOD(DetectMultiScale); + static void EIO_DetectMultiScale(uv_work_t *req); static int EIO_AfterDetectMultiScale(uv_work_t *req); diff --git a/src/Contours.h b/src/Contours.h index e84c005..e67c37b 100755 --- a/src/Contours.h +++ b/src/Contours.h @@ -9,12 +9,24 @@ class Contour: public node::ObjectWrap { vector > contours; static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); Contour(); - //JSFUNC(Size) - static Handle Point(const v8::Arguments&); + JSFUNC(Point) + JSFUNC(Size) + JSFUNC(CornerCount) + JSFUNC(Area) + JSFUNC(ArcLength) + JSFUNC(ApproxPolyDP) + JSFUNC(ConvexHull) + JSFUNC(BoundingRect) + JSFUNC(MinAreaRect) + JSFUNC(IsConvex) + JSFUNC(Moments) + + /*static Handle Point(const v8::Arguments&); static Handle Size(const v8::Arguments&); static Handle CornerCount(const v8::Arguments&); static Handle Area(const v8::Arguments&); @@ -24,6 +36,6 @@ class Contour: public node::ObjectWrap { static Handle BoundingRect(const v8::Arguments&); static Handle MinAreaRect(const v8::Arguments&); static Handle IsConvex(const v8::Arguments&); - static Handle Moments(const v8::Arguments&); + static Handle Moments(const v8::Arguments&);*/ }; diff --git a/src/FaceRecognizer.h b/src/FaceRecognizer.h index 55404b7..274d691 100644 --- a/src/FaceRecognizer.h +++ b/src/FaceRecognizer.h @@ -11,7 +11,8 @@ class FaceRecognizerWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); FaceRecognizerWrap(cv::Ptr f, int type); diff --git a/src/HighGUI.h b/src/HighGUI.h index 61b5033..faf4ab0 100644 --- a/src/HighGUI.h +++ b/src/HighGUI.h @@ -9,7 +9,8 @@ class NamedWindow: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); NamedWindow(const std::string& winname, int flags); diff --git a/src/Matrix.h b/src/Matrix.h index 3331e44..4ccde47 100755 --- a/src/Matrix.h +++ b/src/Matrix.h @@ -6,7 +6,8 @@ class Matrix: public node::ObjectWrap { cv::Mat mat; static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); Matrix(); Matrix(cv::Mat other, cv::Rect roi); Matrix(int rows, int cols); diff --git a/src/OpenCV.h b/src/OpenCV.h index 83a3cc7..b6d3e33 100755 --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -9,6 +9,7 @@ #include #include #include +#include using namespace v8; using namespace node; @@ -25,7 +26,8 @@ using namespace node; TYP *self = ObjectWrap::Unwrap(args.This()); #define JSFUNC(NAME) \ - static Handle NAME(const Arguments& args); + NAN_METHOD(NAME); + //static Handle NAME(const Arguments& args); #define JSTHROW_TYPE(ERR) \ return v8::ThrowException(v8::Exception::TypeError(v8::String::New(ERR))); @@ -48,10 +50,11 @@ class OpenCV: public node::ObjectWrap{ public: static void Init(Handle target); - static Handle ReadImage(const v8::Arguments&); - + static NAN_METHOD(ReadImage); + //static Handle ReadImage(const v8::Arguments&); }; + #endif diff --git a/src/Point.h b/src/Point.h index 988c66f..fd5bc84 100755 --- a/src/Point.h +++ b/src/Point.h @@ -7,13 +7,18 @@ class Point: public node::ObjectWrap { CvPoint2D32f point; static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); Point(double x, double y); - - static Handle GetX(Local prop, const AccessorInfo &info); - static Handle GetY(Local prop, const AccessorInfo &info); - static void RaiseImmutable(Local property, Local value, const AccessorInfo& info); - static Handle Dot(const v8::Arguments&); + + //static Handle GetX(Local prop, const AccessorInfo &info); + static NAN_GETTER(GetX); + //static Handle GetY(Local prop, const AccessorInfo &info); + static NAN_GETTER(GetY); + //static void RaiseImmutable(Local property, Local value, const AccessorInfo& info); + static NAN_METHOD(RaiseImmutable); + //static Handle Dot(const v8::Arguments&); + static NAN_METHOD(Dot); }; diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h index 7955406..1118cec 100755 --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -6,27 +6,35 @@ class VideoCaptureWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + //static Handle New(const Arguments &args); + static NAN_METHOD(New); VideoCaptureWrap(const std::string& filename); VideoCaptureWrap(int device); - static Handle Read(const v8::Arguments&); + //static Handle Read(const v8::Arguments&); + static NAN_METHOD(Read); //(Optional) For setting width and height of the input video stream - static Handle SetWidth(const v8::Arguments&); - static Handle SetHeight(const v8::Arguments&); + //static Handle SetWidth(const v8::Arguments&); + static NAN_METHOD(SetWidth); + + //static Handle SetHeight(const v8::Arguments&); + static NAN_METHOD(SetHeight); // to set frame position - static Handle SetPosition(const v8::Arguments&); + //static Handle SetPosition(const v8::Arguments&); + static NAN_METHOD(SetPosition); - - static Handle GetFrameAt(const v8::Arguments&); + //static Handle GetFrameAt(const v8::Arguments&); + static NAN_METHOD(GetFrameAt); //close the stream - static Handle Close(const v8::Arguments&); + //static Handle Close(const v8::Arguments&); + static NAN_METHOD(Close); //experimental - static Handle ReadSync(const v8::Arguments&); + //static Handle ReadSync(const v8::Arguments&); + static NAN_METHOD(ReadSync); }; diff --git a/src/init.cc b/src/init.cc index 1610800..08df48f 100755 --- a/src/init.cc +++ b/src/init.cc @@ -11,7 +11,8 @@ extern "C" void init(Handle target) { - HandleScope scope; + //HandleScope scope; + NanScope(); OpenCV::Init(target); Point::Init(target); Matrix::Init(target); From cd303829dee2665dc4ae35b9a51a7294afd82cfd Mon Sep 17 00:00:00 2001 From: Mark kaosat-dev Moissette Date: Wed, 10 Sep 2014 15:23:57 +0200 Subject: [PATCH 03/12] - continued work migrating api to nan --- src/BackgroundSubtractor.cc | 11 +- src/CamShift.cc | 6 +- src/CascadeClassifierWrap.cc | 6 +- src/Contours.cc | 36 +-- src/FaceRecognizer.cc | 30 +- src/HighGUI.cc | 12 +- src/Matrix.cc | 570 ++++++++++++++++------------------- src/OpenCV.cc | 2 +- src/OpenCV.h | 4 +- src/Point.cc | 12 +- src/VideoCaptureWrap.cc | 21 +- 11 files changed, 309 insertions(+), 401 deletions(-) diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index a982416..aed68d5 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -21,8 +21,7 @@ BackgroundSubtractorWrap::Init(Handle target) { target->Set(String::NewSymbol("BackgroundSubtractor"), constructor->GetFunction()); }; -Handle -BackgroundSubtractorWrap::New(const Arguments &args) { +NAN_METHOD(BackgroundSubtractorWrap::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0) @@ -37,8 +36,7 @@ BackgroundSubtractorWrap::New(const Arguments &args) { return args.This(); } -Handle -BackgroundSubtractorWrap::CreateMOG(const Arguments &args) { +NAN_METHOD(BackgroundSubtractorWrap::CreateMOG() { HandleScope scope; int history = 200; @@ -63,8 +61,7 @@ BackgroundSubtractorWrap::CreateMOG(const Arguments &args) { }; //Fetch foreground mask -Handle -BackgroundSubtractorWrap::ApplyMOG(const Arguments &args) { +NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG() { SETUP_FUNCTION(BackgroundSubtractorWrap) @@ -134,4 +131,4 @@ BackgroundSubtractorWrap::BackgroundSubtractorWrap(cv::Ptr target) { }; -Handle -TrackedObject::New(const Arguments &args) { +NAN_METHOD(TrackedObject::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0){ @@ -120,8 +119,7 @@ TrackedObject::TrackedObject(cv::Mat image, cv::Rect rect, int chan){ -Handle -TrackedObject::Track(const v8::Arguments& args){ +NAN_METHOD(TrackedObject::Track(const v8::Arguments& args){ SETUP_FUNCTION(TrackedObject) if (args.Length() != 1){ diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index 0fc8d28..964971a 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -27,8 +27,7 @@ CascadeClassifierWrap::Init(Handle target) { target->Set(String::NewSymbol("CascadeClassifier"), constructor->GetFunction()); }; -Handle -CascadeClassifierWrap::New(const Arguments &args) { +NAN_METHOD(CascadeClassifierWrap::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0) @@ -65,8 +64,7 @@ struct classifier_baton_t { }; -Handle -CascadeClassifierWrap::DetectMultiScale(const v8::Arguments& args){ +NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ HandleScope scope; CascadeClassifierWrap *self = ObjectWrap::Unwrap(args.This()); diff --git a/src/Contours.cc b/src/Contours.cc index b2f8d04..2fa4ad9 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -38,8 +38,7 @@ Contour::Init(Handle target) { }; -Handle -Contour::New(const Arguments &args) { +NAN_METHOD(Contour::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0) @@ -57,8 +56,7 @@ Contour::Contour(): ObjectWrap() { } -Handle -Contour::Point(const Arguments &args) { +NAN_METHOD(Contour::Point() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -77,8 +75,7 @@ Contour::Point(const Arguments &args) { // FIXME: this sould better be called "Length" as ``Contours`` is an Array like structure // also, this would allow to use ``Size`` for the function returning the number of corners // in the contour for better consistency with OpenCV. -Handle -Contour::Size(const Arguments &args) { +NAN_METHOD(Contour::Size() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -86,8 +83,7 @@ Contour::Size(const Arguments &args) { return scope.Close(Number::New(self->contours.size())); } -Handle -Contour::CornerCount(const Arguments &args) { +NAN_METHOD(Contour::CornerCount() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -96,8 +92,7 @@ Contour::CornerCount(const Arguments &args) { return scope.Close(Number::New(self->contours[pos].size())); } -Handle -Contour::Area(const Arguments &args) { +NAN_METHOD(Contour::Area() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -108,8 +103,7 @@ Contour::Area(const Arguments &args) { } -Handle -Contour::ArcLength(const Arguments &args) { +NAN_METHOD(Contour::ArcLength() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -120,8 +114,7 @@ Contour::ArcLength(const Arguments &args) { } -Handle -Contour::ApproxPolyDP(const Arguments &args) { +NAN_METHOD(Contour::ApproxPolyDP() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -137,8 +130,7 @@ Contour::ApproxPolyDP(const Arguments &args) { } -Handle -Contour::ConvexHull(const Arguments &args) { +NAN_METHOD(Contour::ConvexHull() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -154,8 +146,7 @@ Contour::ConvexHull(const Arguments &args) { } -Handle -Contour::BoundingRect(const Arguments &args) { +NAN_METHOD(Contour::BoundingRect() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -173,8 +164,7 @@ Contour::BoundingRect(const Arguments &args) { } -Handle -Contour::MinAreaRect(const Arguments &args) { +NAN_METHOD(Contour::MinAreaRect() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -212,8 +202,7 @@ Contour::MinAreaRect(const Arguments &args) { } -Handle -Contour::IsConvex(const Arguments &args) { +NAN_METHOD(Contour::IsConvex() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); @@ -222,8 +211,7 @@ Contour::IsConvex(const Arguments &args) { return scope.Close(Boolean::New(isContourConvex(cv::Mat(self->contours[pos])))); } -Handle -Contour::Moments(const Arguments &args) { +NAN_METHOD(Contour::Moments() { HandleScope scope; Contour *self = ObjectWrap::Unwrap(args.This()); diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc index 44a954d..d7531a7 100644 --- a/src/FaceRecognizer.cc +++ b/src/FaceRecognizer.cc @@ -53,8 +53,7 @@ FaceRecognizerWrap::Init(Handle target) { target->Set(String::NewSymbol("FaceRecognizer"), constructor->GetFunction()); }; -Handle -FaceRecognizerWrap::New(const Arguments &args) { +NAN_METHOD(FaceRecognizerWrap::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0) @@ -68,8 +67,7 @@ FaceRecognizerWrap::New(const Arguments &args) { return args.This(); } -Handle -FaceRecognizerWrap::CreateLBPH(const Arguments &args) { +NAN_METHOD(FaceRecognizerWrap::CreateLBPH() { HandleScope scope; int radius = 1; @@ -95,8 +93,7 @@ FaceRecognizerWrap::CreateLBPH(const Arguments &args) { return n; } -Handle -FaceRecognizerWrap::CreateEigen(const Arguments &args) { +NAN_METHOD(FaceRecognizerWrap::CreateEigen() { HandleScope scope; int components = 0; @@ -116,8 +113,7 @@ FaceRecognizerWrap::CreateEigen(const Arguments &args) { return n; } -Handle -FaceRecognizerWrap::CreateFisher(const Arguments &args) { +NAN_METHOD(FaceRecognizerWrap::CreateFisher() { HandleScope scope; int components = 0; @@ -177,8 +173,7 @@ Handle UnwrapTrainingData(const Arguments& args, cv::vector* ima return v8::Undefined(); } -Handle -FaceRecognizerWrap::TrainSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::TrainSync(const Arguments& args){ SETUP_FUNCTION(FaceRecognizerWrap) cv::vector images; @@ -194,8 +189,7 @@ FaceRecognizerWrap::TrainSync(const Arguments& args){ return scope.Close(v8::Undefined()); } -Handle -FaceRecognizerWrap::UpdateSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::UpdateSync(const Arguments& args){ SETUP_FUNCTION(FaceRecognizerWrap) @@ -221,8 +215,7 @@ FaceRecognizerWrap::UpdateSync(const Arguments& args){ } -Handle -FaceRecognizerWrap::PredictSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::PredictSync(const Arguments& args){ SETUP_FUNCTION(FaceRecognizerWrap) cv::Mat im = fromMatrixOrFilename(args[0]);//TODO CHECK! @@ -241,8 +234,7 @@ FaceRecognizerWrap::PredictSync(const Arguments& args){ } -Handle -FaceRecognizerWrap::SaveSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::SaveSync(const Arguments& args){ SETUP_FUNCTION(FaceRecognizerWrap) if (!args[0]->IsString()){ JSTHROW("Save takes a filename") @@ -252,8 +244,7 @@ FaceRecognizerWrap::SaveSync(const Arguments& args){ return v8::Undefined(); } -Handle -FaceRecognizerWrap::LoadSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::LoadSync(const Arguments& args){ SETUP_FUNCTION(FaceRecognizerWrap) if (!args[0]->IsString()){ JSTHROW("Load takes a filename") @@ -263,8 +254,7 @@ FaceRecognizerWrap::LoadSync(const Arguments& args){ return v8::Undefined(); } -Handle -FaceRecognizerWrap::GetMat(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::GetMat(const Arguments& args){ SETUP_FUNCTION(FaceRecognizerWrap) if (!args[0]->IsString()){ JSTHROW("getMat takes a key") diff --git a/src/HighGUI.cc b/src/HighGUI.cc index 9c057fd..771efea 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -24,8 +24,7 @@ NamedWindow::Init(Handle target) { }; -Handle -NamedWindow::New(const Arguments &args) { +NAN_METHOD(NamedWindow::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0){ @@ -51,8 +50,7 @@ NamedWindow::NamedWindow(const std::string& name, int f){ } -Handle -NamedWindow::Show(const v8::Arguments& args){ +NAN_METHOD(NamedWindow::Show(const v8::Arguments& args){ SETUP_FUNCTION(NamedWindow) Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); cv::imshow(self->winname, im->mat); @@ -60,16 +58,14 @@ NamedWindow::Show(const v8::Arguments& args){ return scope.Close(args.Holder()); } -Handle -NamedWindow::Destroy(const v8::Arguments& args){ +NAN_METHOD(NamedWindow::Destroy(const v8::Arguments& args){ SETUP_FUNCTION(NamedWindow) cv::destroyWindow(self->winname); return scope.Close(args.Holder()); } -Handle -NamedWindow::BlockingWaitKey(const v8::Arguments& args){ +NAN_METHOD(NamedWindow::BlockingWaitKey(const v8::Arguments& args){ HandleScope scope; //SETUP_FUNCTION(NamedWindow) int time = 0; diff --git a/src/Matrix.cc b/src/Matrix.cc index c94064f..8a374dd 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -1,6 +1,7 @@ #include "Contours.h" #include "Matrix.h" #include "OpenCV.h" +#include v8::Persistent Matrix::constructor; @@ -12,118 +13,131 @@ cv::Rect* setRect(Local objRect); void Matrix::Init(Handle target) { - HandleScope scope; + //HandleScope scope; + //NanScope(); //Class - v8::Local m = v8::FunctionTemplate::New(New); - m->SetClassName(v8::String::NewSymbol("Matrix")); + /*//v8::Local m = v8::FunctionTemplate::New(New); + v8::Local m = NanNew(Matrix::New); + + //m->SetClassName(v8::String::NewSymbol("Matrix")); + m->SetClassName(NanNew("Matrix")); // Constructor - constructor = Persistent::New(m); + constructor = Persistent:NanNew((m); + NanAssignPersistent(Matrix::constructor, constructor); constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("Matrix")); + //constructor->SetClassName(String::NewSymbol("Matrix"));*/ + v8::Local tpl = NanNew(Matrix::New); + //Local tpl = FunctionTemplate::New( New ); + tpl->SetClassName(NanNew("Matrix")); + tpl->InstanceTemplate()->SetInternalFieldCount(1); + + //target->Set( NanNew("Matrix"), tpl->GetFunction()); + + //contructor // Prototype //Local proto = constructor->PrototypeTemplate(); + //constructor = tpl; + NanAssignPersistent(Matrix::constructor, tpl); - NODE_SET_PROTOTYPE_METHOD(constructor, "row", Row); - NODE_SET_PROTOTYPE_METHOD(constructor, "col", Col); + NODE_SET_PROTOTYPE_METHOD(tpl, "row", Row); + NODE_SET_PROTOTYPE_METHOD(tpl, "col", Col); - NODE_SET_PROTOTYPE_METHOD(constructor, "pixelRow", PixelRow); - NODE_SET_PROTOTYPE_METHOD(constructor, "pixelCol", PixelCol); + NODE_SET_PROTOTYPE_METHOD(tpl, "pixelRow", PixelRow); + NODE_SET_PROTOTYPE_METHOD(tpl, "pixelCol", PixelCol); - NODE_SET_PROTOTYPE_METHOD(constructor, "empty", Empty); - NODE_SET_PROTOTYPE_METHOD(constructor, "get", Get); - NODE_SET_PROTOTYPE_METHOD(constructor, "set", Set); - NODE_SET_PROTOTYPE_METHOD(constructor, "pixel", Pixel); - NODE_SET_PROTOTYPE_METHOD(constructor, "width", Width); - NODE_SET_PROTOTYPE_METHOD(constructor, "height", Height); - NODE_SET_PROTOTYPE_METHOD(constructor, "size", Size); - NODE_SET_PROTOTYPE_METHOD(constructor, "clone", Clone); - NODE_SET_PROTOTYPE_METHOD(constructor, "toBuffer", ToBuffer); - NODE_SET_PROTOTYPE_METHOD(constructor, "toBufferAsync", ToBufferAsync); - NODE_SET_PROTOTYPE_METHOD(constructor, "ellipse", Ellipse); - NODE_SET_PROTOTYPE_METHOD(constructor, "rectangle", Rectangle); - NODE_SET_PROTOTYPE_METHOD(constructor, "line", Line); - NODE_SET_PROTOTYPE_METHOD(constructor, "save", Save); - NODE_SET_PROTOTYPE_METHOD(constructor, "saveAsync", SaveAsync); - NODE_SET_PROTOTYPE_METHOD(constructor, "resize", Resize); - NODE_SET_PROTOTYPE_METHOD(constructor, "rotate", Rotate); - NODE_SET_PROTOTYPE_METHOD(constructor, "copyTo", CopyTo); - NODE_SET_PROTOTYPE_METHOD(constructor, "pyrDown", PyrDown); - NODE_SET_PROTOTYPE_METHOD(constructor, "pyrUp", PyrUp); - NODE_SET_PROTOTYPE_METHOD(constructor, "channels", Channels); + NODE_SET_PROTOTYPE_METHOD(tpl, "empty", Empty); + NODE_SET_PROTOTYPE_METHOD(tpl, "get", Get); + NODE_SET_PROTOTYPE_METHOD(tpl, "set", Set); + NODE_SET_PROTOTYPE_METHOD(tpl, "pixel", Pixel); + NODE_SET_PROTOTYPE_METHOD(tpl, "width", Width); + NODE_SET_PROTOTYPE_METHOD(tpl, "height", Height); + NODE_SET_PROTOTYPE_METHOD(tpl, "size", Size); + NODE_SET_PROTOTYPE_METHOD(tpl, "clone", Clone); + NODE_SET_PROTOTYPE_METHOD(tpl, "toBuffer", ToBuffer); + NODE_SET_PROTOTYPE_METHOD(tpl, "toBufferAsync", ToBufferAsync); + NODE_SET_PROTOTYPE_METHOD(tpl, "ellipse", Ellipse); + NODE_SET_PROTOTYPE_METHOD(tpl, "rectangle", Rectangle); + NODE_SET_PROTOTYPE_METHOD(tpl, "line", Line); + NODE_SET_PROTOTYPE_METHOD(tpl, "save", Save); + NODE_SET_PROTOTYPE_METHOD(tpl, "saveAsync", SaveAsync); + NODE_SET_PROTOTYPE_METHOD(tpl, "resize", Resize); + NODE_SET_PROTOTYPE_METHOD(tpl, "rotate", Rotate); + NODE_SET_PROTOTYPE_METHOD(tpl, "copyTo", CopyTo); + NODE_SET_PROTOTYPE_METHOD(tpl, "pyrDown", PyrDown); + NODE_SET_PROTOTYPE_METHOD(tpl, "pyrUp", PyrUp); + NODE_SET_PROTOTYPE_METHOD(tpl, "channels", Channels); - NODE_SET_PROTOTYPE_METHOD(constructor, "convertGrayscale", ConvertGrayscale); - NODE_SET_PROTOTYPE_METHOD(constructor, "convertHSVscale", ConvertHSVscale); - NODE_SET_PROTOTYPE_METHOD(constructor, "gaussianBlur", GaussianBlur); - NODE_SET_PROTOTYPE_METHOD(constructor, "medianBlur", MedianBlur); - NODE_SET_PROTOTYPE_METHOD(constructor, "bilateralFilter", BilateralFilter); - NODE_SET_PROTOTYPE_METHOD(constructor, "copy", Copy); - NODE_SET_PROTOTYPE_METHOD(constructor, "flip", Flip); - NODE_SET_PROTOTYPE_METHOD(constructor, "roi", ROI); - NODE_SET_PROTOTYPE_METHOD(constructor, "ptr", Ptr); - NODE_SET_PROTOTYPE_METHOD(constructor, "absDiff", AbsDiff); - NODE_SET_PROTOTYPE_METHOD(constructor, "addWeighted", AddWeighted); - NODE_SET_PROTOTYPE_METHOD(constructor, "bitwiseXor", BitwiseXor); - NODE_SET_PROTOTYPE_METHOD(constructor, "bitwiseNot", BitwiseNot); - NODE_SET_PROTOTYPE_METHOD(constructor, "bitwiseAnd", BitwiseAnd); - NODE_SET_PROTOTYPE_METHOD(constructor, "countNonZero", CountNonZero); - NODE_SET_PROTOTYPE_METHOD(constructor, "canny", Canny); - NODE_SET_PROTOTYPE_METHOD(constructor, "dilate", Dilate); - NODE_SET_PROTOTYPE_METHOD(constructor, "erode", Erode); + NODE_SET_PROTOTYPE_METHOD(tpl, "convertGrayscale", ConvertGrayscale); + NODE_SET_PROTOTYPE_METHOD(tpl, "convertHSVscale", ConvertHSVscale); + NODE_SET_PROTOTYPE_METHOD(tpl, "gaussianBlur", GaussianBlur); + NODE_SET_PROTOTYPE_METHOD(tpl, "medianBlur", MedianBlur); + NODE_SET_PROTOTYPE_METHOD(tpl, "bilateralFilter", BilateralFilter); + NODE_SET_PROTOTYPE_METHOD(tpl, "copy", Copy); + NODE_SET_PROTOTYPE_METHOD(tpl, "flip", Flip); + NODE_SET_PROTOTYPE_METHOD(tpl, "roi", ROI); + NODE_SET_PROTOTYPE_METHOD(tpl, "ptr", Ptr); + NODE_SET_PROTOTYPE_METHOD(tpl, "absDiff", AbsDiff); + NODE_SET_PROTOTYPE_METHOD(tpl, "addWeighted", AddWeighted); + NODE_SET_PROTOTYPE_METHOD(tpl, "bitwiseXor", BitwiseXor); + NODE_SET_PROTOTYPE_METHOD(tpl, "bitwiseNot", BitwiseNot); + NODE_SET_PROTOTYPE_METHOD(tpl, "bitwiseAnd", BitwiseAnd); + NODE_SET_PROTOTYPE_METHOD(tpl, "countNonZero", CountNonZero); + NODE_SET_PROTOTYPE_METHOD(tpl, "canny", Canny); + NODE_SET_PROTOTYPE_METHOD(tpl, "dilate", Dilate); + NODE_SET_PROTOTYPE_METHOD(tpl, "erode", Erode); - NODE_SET_PROTOTYPE_METHOD(constructor, "findContours", FindContours); - NODE_SET_PROTOTYPE_METHOD(constructor, "drawContour", DrawContour); - NODE_SET_PROTOTYPE_METHOD(constructor, "drawAllContours", DrawAllContours); + NODE_SET_PROTOTYPE_METHOD(tpl, "findContours", FindContours); + NODE_SET_PROTOTYPE_METHOD(tpl, "drawContour", DrawContour); + NODE_SET_PROTOTYPE_METHOD(tpl, "drawAllContours", DrawAllContours); - NODE_SET_PROTOTYPE_METHOD(constructor, "goodFeaturesToTrack", GoodFeaturesToTrack); - NODE_SET_PROTOTYPE_METHOD(constructor, "houghLinesP", HoughLinesP); + NODE_SET_PROTOTYPE_METHOD(tpl, "goodFeaturesToTrack", GoodFeaturesToTrack); + NODE_SET_PROTOTYPE_METHOD(tpl, "houghLinesP", HoughLinesP); - NODE_SET_PROTOTYPE_METHOD(constructor, "inRange", inRange); - NODE_SET_PROTOTYPE_METHOD(constructor, "adjustROI", AdjustROI); - NODE_SET_PROTOTYPE_METHOD(constructor, "locateROI", LocateROI); + NODE_SET_PROTOTYPE_METHOD(tpl, "inRange", inRange); + NODE_SET_PROTOTYPE_METHOD(tpl, "adjustROI", AdjustROI); + NODE_SET_PROTOTYPE_METHOD(tpl, "locateROI", LocateROI); - NODE_SET_PROTOTYPE_METHOD(constructor, "threshold", Threshold); - NODE_SET_PROTOTYPE_METHOD(constructor, "adaptiveThreshold", AdaptiveThreshold); - NODE_SET_PROTOTYPE_METHOD(constructor, "meanStdDev", MeanStdDev); + NODE_SET_PROTOTYPE_METHOD(tpl, "threshold", Threshold); + NODE_SET_PROTOTYPE_METHOD(tpl, "adaptiveThreshold", AdaptiveThreshold); + NODE_SET_PROTOTYPE_METHOD(tpl, "meanStdDev", MeanStdDev); - NODE_SET_PROTOTYPE_METHOD(constructor, "cvtColor", CvtColor); - NODE_SET_PROTOTYPE_METHOD(constructor, "split", Split); - NODE_SET_PROTOTYPE_METHOD(constructor, "merge", Merge); - NODE_SET_PROTOTYPE_METHOD(constructor, "equalizeHist", EqualizeHist); + NODE_SET_PROTOTYPE_METHOD(tpl, "cvtColor", CvtColor); + NODE_SET_PROTOTYPE_METHOD(tpl, "split", Split); + NODE_SET_PROTOTYPE_METHOD(tpl, "merge", Merge); + NODE_SET_PROTOTYPE_METHOD(tpl, "equalizeHist", EqualizeHist); - NODE_SET_PROTOTYPE_METHOD(constructor, "floodFill", FloodFill); + NODE_SET_PROTOTYPE_METHOD(tpl, "floodFill", FloodFill); - NODE_SET_PROTOTYPE_METHOD(constructor, "matchTemplate", MatchTemplate); - NODE_SET_PROTOTYPE_METHOD(constructor, "minMaxLoc", MinMaxLoc); + NODE_SET_PROTOTYPE_METHOD(tpl, "matchTemplate", MatchTemplate); + NODE_SET_PROTOTYPE_METHOD(tpl, "minMaxLoc", MinMaxLoc); - NODE_SET_PROTOTYPE_METHOD(constructor, "pushBack", PushBack); + NODE_SET_PROTOTYPE_METHOD(tpl, "pushBack", PushBack); - NODE_SET_PROTOTYPE_METHOD(constructor, "putText", PutText); + NODE_SET_PROTOTYPE_METHOD(tpl, "putText", PutText); - NODE_SET_PROTOTYPE_METHOD(constructor, "getPerspectiveTransform", GetPerspectiveTransform); - NODE_SET_PROTOTYPE_METHOD(constructor, "warpPerspective", WarpPerspective); + NODE_SET_PROTOTYPE_METHOD(tpl, "getPerspectiveTransform", GetPerspectiveTransform); + NODE_SET_PROTOTYPE_METHOD(tpl, "warpPerspective", WarpPerspective); - NODE_SET_METHOD(constructor, "Eye", Eye); + NODE_SET_METHOD(tpl, "Eye", Eye); - NODE_SET_PROTOTYPE_METHOD(constructor, "copyWithMask", CopyWithMask); - NODE_SET_PROTOTYPE_METHOD(constructor, "setWithMask", SetWithMask); - NODE_SET_PROTOTYPE_METHOD(constructor, "meanWithMask", MeanWithMask); - NODE_SET_PROTOTYPE_METHOD(constructor, "shift", Shift); + NODE_SET_PROTOTYPE_METHOD(tpl, "copyWithMask", CopyWithMask); + NODE_SET_PROTOTYPE_METHOD(tpl, "setWithMask", SetWithMask); + NODE_SET_PROTOTYPE_METHOD(tpl, "meanWithMask", MeanWithMask); + NODE_SET_PROTOTYPE_METHOD(tpl, "shift", Shift); - - target->Set(String::NewSymbol("Matrix"), m->GetFunction()); + //target->Set(String::NewSymbol("Matrix"), m->GetFunction()); + target->Set( NanNew("Matrix"), tpl->GetFunction() ); }; - -Handle -Matrix::New(const Arguments &args) { - HandleScope scope; - +NAN_METHOD(Matrix::New) { + //HandleScope scope; + NanScope(); if (args.This()->InternalFieldCount() == 0) - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Cannot instantiate without new"))); + return NanThrowTypeError("Cannot instantiate without new"); Matrix *mat; @@ -141,7 +155,8 @@ Matrix::New(const Arguments &args) { } mat->Wrap(args.Holder()); - return scope.Close(args.Holder()); + NanReturnValue(args.Holder()); + //NanReturnValue(args.Holder()); } @@ -159,11 +174,11 @@ Matrix::Matrix(cv::Mat m, cv::Rect roi): ObjectWrap() { } -Handle -Matrix::Empty(const Arguments& args){ - SETUP_FUNCTION(Matrix) - return scope.Close(Boolean::New(self->mat.empty())); +NAN_METHOD(Matrix::Empty){ + SETUP_FUNCTION(Matrix) + NanReturnValue(NanNew(self->mat.empty())); + //NanReturnValue(Boolean::New(self->mat.empty())); } @@ -198,8 +213,8 @@ Matrix::DblGet(cv::Mat mat, int i, int j){ -Handle -Matrix::Pixel(const Arguments& args){ + +NAN_METHOD(Matrix::Pixel){ SETUP_FUNCTION(Matrix) int y = args[0]->IntegerValue(); @@ -215,38 +230,37 @@ Matrix::Pixel(const Arguments& args){ self->mat.at(y, x)[0] = (uchar) objColor->Get(0)->IntegerValue(); self->mat.at(y, x)[1] = (uchar) objColor->Get(1)->IntegerValue(); self->mat.at(y, x)[2] = (uchar) objColor->Get(2)->IntegerValue(); - return scope.Close(args[2]->ToObject()); - }else{ - cv::Vec3b intensity = self->mat.at(y, x); - - v8::Local arr = v8::Array::New(3); - arr->Set(0, Number::New( intensity[0] )); - arr->Set(1, Number::New( intensity[1] )); - arr->Set(2, Number::New( intensity[2] )); - return scope.Close(arr); + NanReturnValue( args[2]->ToObject() ); } + else{ + cv::Vec3b intensity = self->mat.at(y, x); - return scope.Close(Undefined()); + v8::Local arr = NanNew(3); + arr->Set(0, NanNew( intensity[0] )); + arr->Set(1, NanNew( intensity[1] )); + arr->Set(2, NanNew( intensity[2] )); + NanReturnValue( arr ); + } + NanReturnUndefined(); //double val = Matrix::DblGet(t, i, j); - //return scope.Close(Number::New(val)); + //NanReturnValue(Number::New(val)); } -Handle -Matrix::Get(const Arguments& args){ +NAN_METHOD(Matrix::Get){ SETUP_FUNCTION(Matrix) int i = args[0]->IntegerValue(); int j = args[1]->IntegerValue(); double val = Matrix::DblGet(self->mat, i, j); - return scope.Close(Number::New(val)); + NanReturnValue( NanNew(val) ); } -Handle -Matrix::Set(const Arguments& args){ + +NAN_METHOD(Matrix::Set){ SETUP_FUNCTION(Matrix) int i = args[0]->IntegerValue(); @@ -275,39 +289,39 @@ Matrix::Set(const Arguments& args){ } else { - return v8::ThrowException(v8::Exception::TypeError(String::New("Invalid number of arguments"))); + NanTypeError( "Invalid number of arguments" ); + //return v8::ThrowException(v8::Exception::TypeError(String::New("Invalid number of arguments"))); } - - return scope.Close(Undefined()); + + NanReturnUndefined(); } -Handle -Matrix::Size(const Arguments& args){ + +NAN_METHOD(Matrix::Size){ SETUP_FUNCTION(Matrix) v8::Local arr = v8::Array::New(2); arr->Set(0, Number::New(self->mat.size().height)); arr->Set(1, Number::New(self->mat.size().width)); - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::Clone(const Arguments& args){ + +NAN_METHOD(Matrix::Clone){ SETUP_FUNCTION(Matrix) Local im_h = Matrix::constructor->GetFunction()->NewInstance(); Matrix *m = ObjectWrap::Unwrap(im_h); m->mat = self->mat.clone(); - return scope.Close(im_h); + NanReturnValue(im_h); } -Handle -Matrix::Row(const Arguments& args){ +NAN_METHOD(Matrix::Row){ SETUP_FUNCTION(Matrix) int width = self->mat.size().width; @@ -319,12 +333,11 @@ Matrix::Row(const Arguments& args){ arr->Set(x, Number::New(v)); } - return scope.Close(arr); + NanReturnValue(arr); } -Handle - Matrix::PixelRow(const Arguments& args){ +NAN_METHOD(Matrix::PixelRow){ SETUP_FUNCTION(Matrix) int width = self->mat.size().width; @@ -339,11 +352,11 @@ Handle arr->Set(offset + 2, Number::New((double)pixel.val[2])); } - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::Col(const Arguments& args){ + +NAN_METHOD(Matrix::Col){ SETUP_FUNCTION(Matrix) int height = self->mat.size().height; @@ -354,12 +367,11 @@ Matrix::Col(const Arguments& args){ double v = Matrix::DblGet(self->mat, y, x); arr->Set(y, Number::New(v)); } - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::PixelCol(const Arguments& args){ +NAN_METHOD(Matrix::PixelCol){ SETUP_FUNCTION(Matrix) int height = self->mat.size().height; @@ -373,33 +385,30 @@ Matrix::PixelCol(const Arguments& args){ arr->Set(offset + 1, Number::New((double)pixel.val[1])); arr->Set(offset + 2, Number::New((double)pixel.val[2])); } - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::Width(const Arguments& args){ + +NAN_METHOD(Matrix::Width){ SETUP_FUNCTION(Matrix) - return scope.Close(Number::New(self->mat.size().width)); + NanReturnValue(Number::New(self->mat.size().width)); } -Handle -Matrix::Height(const Arguments& args){ +NAN_METHOD(Matrix::Height){ SETUP_FUNCTION(Matrix) - return scope.Close(Number::New(self->mat.size().height)); + NanReturnValue(Number::New(self->mat.size().height)); } -Handle -Matrix::Channels(const Arguments& args){ +NAN_METHOD(Matrix::Channels){ SETUP_FUNCTION(Matrix) - return scope.Close(Number::New(self->mat.channels())); + NanReturnValue(Number::New(self->mat.channels())); } -Handle -Matrix::ToBuffer(const v8::Arguments& args){ +NAN_METHOD(Matrix::ToBuffer){ SETUP_FUNCTION(Matrix) if ((args.Length() > 0) && (args[0]->IsFunction())) { @@ -453,7 +462,7 @@ Matrix::ToBuffer(const v8::Arguments& args){ v8::Handle constructorArgs[3] = {buf->handle_, v8::Integer::New(vec.size()), v8::Integer::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - return scope.Close(actualBuffer); + NanReturnValue(actualBuffer); } @@ -470,8 +479,7 @@ struct matrixToBuffer_baton_t { void AsyncToBufferAsync(uv_work_t *req); void AfterAsyncToBufferAsync(uv_work_t *req); -Handle -Matrix::ToBufferAsync(const v8::Arguments& args){ +NAN_METHOD(Matrix::ToBufferAsync){ SETUP_FUNCTION(Matrix) REQ_FUN_ARG(0, cb); @@ -564,8 +572,7 @@ void AfterAsyncToBufferAsync(uv_work_t *req) { } -Handle -Matrix::Ellipse(const v8::Arguments& args){ +NAN_METHOD(Matrix::Ellipse){ SETUP_FUNCTION(Matrix) int x = 0; @@ -630,13 +637,12 @@ Matrix::Ellipse(const v8::Arguments& args){ } cv::ellipse(self->mat, cv::Point(x, y), cv::Size(width, height), angle, startAngle, endAngle, color, thickness, lineType, shift); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::Rectangle(const Arguments& args) { +NAN_METHOD(Matrix::Rectangle) { SETUP_FUNCTION(Matrix) @@ -665,11 +671,10 @@ Matrix::Rectangle(const Arguments& args) { cv::rectangle(self->mat, cv::Point(x, y), cv::Point(x+width, y+height), color, thickness); } - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::Line(const Arguments& args) { +NAN_METHOD(Matrix::Line) { SETUP_FUNCTION(Matrix) @@ -698,11 +703,10 @@ Matrix::Line(const Arguments& args) { cv::line(self->mat, cv::Point(x1, y1), cv::Point(x2, y2), color, thickness); } - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::Save(const v8::Arguments& args) { +NAN_METHOD(Matrix::Save) { SETUP_FUNCTION(Matrix) if (args.Length() > 1) { @@ -714,7 +718,7 @@ Matrix::Save(const v8::Arguments& args) { String::AsciiValue filename(args[0]); int res = cv::imwrite(*filename, self->mat); - return scope.Close(Number::New(res)); + NanReturnValue(Number::New(res)); } @@ -729,8 +733,7 @@ struct save_baton_t { void DoSaveAsync(uv_work_t *req); void AfterSaveAsync(uv_work_t *req); -Handle -Matrix::SaveAsync(const v8::Arguments& args){ +NAN_METHOD(Matrix::SaveAsync){ SETUP_FUNCTION(Matrix) if (!args[0]->IsString()) @@ -782,8 +785,7 @@ void AfterSaveAsync(uv_work_t *req) { } -Handle -Matrix::Eye(const v8::Arguments& args){ +NAN_METHOD(Matrix::Eye){ HandleScope scope; int w = args[0]->Uint32Value(); @@ -794,12 +796,11 @@ Matrix::Eye(const v8::Arguments& args){ cv::Mat mat = cv::Mat::eye(w, h, CV_64FC1); img->mat = mat; - return scope.Close(im_h); + NanReturnValue(im_h); } -Handle -Matrix::ConvertGrayscale(const v8::Arguments& args) { +NAN_METHOD(Matrix::ConvertGrayscale) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -812,12 +813,11 @@ Matrix::ConvertGrayscale(const v8::Arguments& args) { gray.copyTo(self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::ConvertHSVscale(const v8::Arguments& args) { +NAN_METHOD(Matrix::ConvertHSVscale) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -829,12 +829,11 @@ Matrix::ConvertHSVscale(const v8::Arguments& args) { cv::cvtColor(self->mat, hsv, CV_BGR2HSV); hsv.copyTo(self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::GaussianBlur(const v8::Arguments& args) { +NAN_METHOD(Matrix::GaussianBlur) { HandleScope scope; cv::Size ksize; cv::Mat blurred; @@ -863,12 +862,11 @@ Matrix::GaussianBlur(const v8::Arguments& args) { cv::GaussianBlur(self->mat, blurred, ksize, 0); blurred.copyTo(self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::MedianBlur(const v8::Arguments &args) { +NAN_METHOD(Matrix::MedianBlur(const v8::Arguments &args) { HandleScope scope; cv::Mat blurred; int ksize = 3; @@ -888,12 +886,11 @@ Matrix::MedianBlur(const v8::Arguments &args) { cv::medianBlur(self->mat, blurred, ksize); blurred.copyTo(self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::BilateralFilter(const v8::Arguments &args) { +NAN_METHOD(Matrix::BilateralFilter(const v8::Arguments &args) { HandleScope scope; cv::Mat filtered; int d = 15; @@ -920,12 +917,11 @@ Matrix::BilateralFilter(const v8::Arguments &args) { cv::bilateralFilter(self->mat, filtered, d, sigmaColor, sigmaSpace, borderType); filtered.copyTo(self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::Copy(const v8::Arguments& args) { +NAN_METHOD(Matrix::Copy) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -934,12 +930,11 @@ Matrix::Copy(const v8::Arguments& args) { Matrix *img = ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); - return scope.Close(img_to_return); + NanReturnValue(img_to_return); } -Handle -Matrix::Flip(const v8::Arguments& args) { +NAN_METHOD(Matrix::Flip) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -955,12 +950,11 @@ Matrix::Flip(const v8::Arguments& args) { Matrix *img = ObjectWrap::Unwrap(img_to_return); cv::flip(self->mat, img->mat, flipCode); - return scope.Close(img_to_return); + NanReturnValue(img_to_return); } -Handle -Matrix::ROI(const v8::Arguments& args) { +NAN_METHOD(Matrix::ROI) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -982,12 +976,11 @@ Matrix::ROI(const v8::Arguments& args) { cv::Mat roi(self->mat, cv::Rect(x,y,w,h)); img->mat = roi; - return scope.Close(img_to_return); + NanReturnValue(img_to_return); } -Handle -Matrix::Ptr(const v8::Arguments& args) { +NAN_METHOD(Matrix::Ptr) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); int line = args[0]->Uint32Value(); @@ -1000,13 +993,12 @@ Matrix::Ptr(const v8::Arguments& args) { char *mydata = "Random raw data\0"; */ node::Buffer *return_buffer = Buffer::New((char *)data, self->mat.step); - return scope.Close( return_buffer->handle_ ); + NanReturnValue( return_buffer->handle_ ); // return Undefined(); } -Handle -Matrix::AbsDiff(const v8::Arguments& args) { +NAN_METHOD(Matrix::AbsDiff) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1016,11 +1008,10 @@ Matrix::AbsDiff(const v8::Arguments& args) { cv::absdiff(src1->mat, src2->mat, self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::AddWeighted(const v8::Arguments& args) { +NAN_METHOD(Matrix::AddWeighted) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1035,11 +1026,10 @@ Matrix::AddWeighted(const v8::Arguments& args) { cv::addWeighted(src1->mat, alpha, src2->mat, beta, gamma, self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::BitwiseXor(const v8::Arguments& args) { +NAN_METHOD(Matrix::BitwiseXor) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1049,11 +1039,10 @@ Matrix::BitwiseXor(const v8::Arguments& args) { cv::bitwise_xor(src1->mat, src2->mat, self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::BitwiseNot(const v8::Arguments& args) { +NAN_METHOD(Matrix::BitwiseNot) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1062,11 +1051,10 @@ Matrix::BitwiseNot(const v8::Arguments& args) { cv::bitwise_not(self->mat, dst->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::BitwiseAnd(const v8::Arguments& args) { +NAN_METHOD(Matrix::BitwiseAnd) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1076,31 +1064,28 @@ Matrix::BitwiseAnd(const v8::Arguments& args) { cv::bitwise_and(src1->mat, src2->mat, self->mat); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::CountNonZero(const v8::Arguments& args) { +NAN_METHOD(Matrix::CountNonZero) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); double count = (double)cv::countNonZero(self->mat); - return scope.Close(v8::Number::New(count)); + NanReturnValue(v8::Number::New(count)); } -/*Handle -Matrix::Split(const v8::Arguments& args) { +/*NAN_METHOD(Matrix::Split) { HandleScope scope; //Matrix *self = ObjectWrap::Unwrap(args.This()); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); }*/ -Handle -Matrix::Canny(const v8::Arguments& args) { +NAN_METHOD(Matrix::Canny) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1109,12 +1094,11 @@ Matrix::Canny(const v8::Arguments& args) { cv::Canny(self->mat, self->mat, lowThresh, highThresh); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::Dilate(const v8::Arguments& args) { +NAN_METHOD(Matrix::Dilate) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1122,11 +1106,10 @@ Matrix::Dilate(const v8::Arguments& args) { cv::dilate(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::Erode(const v8::Arguments& args) { +NAN_METHOD(Matrix::Erode) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1134,12 +1117,11 @@ Matrix::Erode(const v8::Arguments& args) { cv::erode(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::FindContours(const v8::Arguments& args) { +NAN_METHOD(Matrix::FindContours) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1149,13 +1131,12 @@ Matrix::FindContours(const v8::Arguments& args) { cv::findContours(self->mat, contours->contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); - return scope.Close(conts_to_return); + NanReturnValue(conts_to_return); } -Handle -Matrix::DrawContour(const v8::Arguments& args) { +NAN_METHOD(Matrix::DrawContour) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1177,8 +1158,7 @@ Matrix::DrawContour(const v8::Arguments& args) { } -Handle -Matrix::DrawAllContours(const v8::Arguments& args) { +NAN_METHOD(Matrix::DrawAllContours) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1199,8 +1179,7 @@ Matrix::DrawAllContours(const v8::Arguments& args) { return Undefined(); } -Handle -Matrix::GoodFeaturesToTrack(const v8::Arguments& args) { +NAN_METHOD(Matrix::GoodFeaturesToTrack) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1223,12 +1202,11 @@ Matrix::GoodFeaturesToTrack(const v8::Arguments& args) { arr->Set(i, pt); } - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::HoughLinesP(const v8::Arguments& args) { +NAN_METHOD(Matrix::HoughLinesP) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1258,7 +1236,7 @@ Matrix::HoughLinesP(const v8::Arguments& args) { arr->Set(i, pt); } - return scope.Close(arr); + NanReturnValue(arr); } @@ -1298,8 +1276,7 @@ cv::Rect* setRect(Local objRect) { } -Handle -Matrix::Resize(const v8::Arguments& args){ +NAN_METHOD(Matrix::Resize){ HandleScope scope; int x = args[0]->Uint32Value(); @@ -1320,12 +1297,11 @@ Matrix::Resize(const v8::Arguments& args){ self->mat = res; - return scope.Close(Undefined()); + NanReturnUndefined(); } -Handle -Matrix::Rotate(const v8::Arguments& args){ +NAN_METHOD(Matrix::Rotate){ HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1342,7 +1318,7 @@ Matrix::Rotate(const v8::Arguments& args){ && (args.Length() == 1); if (rightOrStraight) { int angle2 = ((int)angle) % 360; - if (!angle2) { return scope.Close(Undefined()); } + if (!angle2) { NanReturnUndefined(); } if (angle2 < 0) { angle2 += 360; } // See if we do right angle rotation, we transpose the matrix: if (angle2 % 180) { @@ -1358,7 +1334,7 @@ Matrix::Rotate(const v8::Arguments& args){ if (angle2 == 270) { mode = 1; } cv::flip(self->mat, self->mat, mode); - return scope.Close(Undefined()); + NanReturnUndefined(); } //------------- @@ -1372,27 +1348,24 @@ Matrix::Rotate(const v8::Arguments& args){ ~self->mat; self->mat = res; - return scope.Close(Undefined()); + NanReturnUndefined(); } -Handle -Matrix::PyrDown(const v8::Arguments& args){ +NAN_METHOD(Matrix::PyrDown){ SETUP_FUNCTION(Matrix) cv::pyrDown(self->mat, self->mat); - return scope.Close(v8::Undefined()); + NanReturnValue(v8::Undefined()); } -Handle -Matrix::PyrUp(const v8::Arguments& args){ +NAN_METHOD(Matrix::PyrUp){ SETUP_FUNCTION(Matrix) cv::pyrUp(self->mat, self->mat); - return scope.Close(v8::Undefined()); + NanReturnValue(v8::Undefined()); } -Handle -Matrix::inRange(const v8::Arguments& args) { +NAN_METHOD(Matrix::inRange) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1415,11 +1388,10 @@ Matrix::inRange(const v8::Arguments& args) { } - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::AdjustROI(const v8::Arguments& args) { +NAN_METHOD(Matrix::AdjustROI) { SETUP_FUNCTION(Matrix) int dtop = args[0]->Uint32Value(); int dbottom = args[1]->Uint32Value(); @@ -1428,12 +1400,11 @@ Matrix::AdjustROI(const v8::Arguments& args) { self->mat.adjustROI(dtop, dbottom, dleft, dright); - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::LocateROI(const v8::Arguments& args) { +NAN_METHOD(Matrix::LocateROI) { SETUP_FUNCTION(Matrix) cv::Size wholeSize; @@ -1447,11 +1418,10 @@ Matrix::LocateROI(const v8::Arguments& args) { arr->Set(2, Number::New(ofs.x)); arr->Set(3, Number::New(ofs.y)); - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::Threshold(const v8::Arguments& args) { +NAN_METHOD(Matrix::Threshold) { SETUP_FUNCTION(Matrix) double threshold = args[0]->NumberValue(); @@ -1486,11 +1456,10 @@ Matrix::Threshold(const v8::Arguments& args) { cv::threshold(self->mat, img->mat, threshold, maxVal, typ); - return scope.Close(img_to_return); + NanReturnValue(img_to_return); } -Handle -Matrix::AdaptiveThreshold(const v8::Arguments& args) { +NAN_METHOD(Matrix::AdaptiveThreshold) { SETUP_FUNCTION(Matrix) double maxVal = args[0]->NumberValue(); @@ -1505,11 +1474,10 @@ Matrix::AdaptiveThreshold(const v8::Arguments& args) { cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C); - return scope.Close(img_to_return); + NanReturnValue(img_to_return); } -Handle -Matrix::MeanStdDev(const v8::Arguments& args) { +NAN_METHOD(Matrix::MeanStdDev) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1524,7 +1492,7 @@ Matrix::MeanStdDev(const v8::Arguments& args) { Local data = Object::New(); data->Set(String::NewSymbol("mean"), mean); data->Set(String::NewSymbol("stddev"), stddev); - return scope.Close(data); + NanReturnValue(data); } @@ -1537,8 +1505,7 @@ Matrix::MeanStdDev(const v8::Arguments& args) { // Note, x,y and width and height of our image must be so that // our.width + x <= destination.width (and the same for y and height) // both x and y must be >= 0 -Handle -Matrix::CopyTo(const v8::Arguments& args) { +NAN_METHOD(Matrix::CopyTo) { HandleScope scope; Matrix * self = ObjectWrap::Unwrap(args.This()); @@ -1555,7 +1522,7 @@ Matrix::CopyTo(const v8::Arguments& args) { cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height)); self->mat.copyTo(dstROI); - return scope.Close(Undefined()); + NanReturnUndefined(); } @@ -1563,8 +1530,7 @@ Matrix::CopyTo(const v8::Arguments& args) { // @author SergeMv // Does in-place color transformation // img.cvtColor('CV_BGR2YCrCb'); -Handle -Matrix::CvtColor(const v8::Arguments& args) { +NAN_METHOD(Matrix::CvtColor) { HandleScope scope; Matrix * self = ObjectWrap::Unwrap(args.This()); @@ -1607,14 +1573,13 @@ Matrix::CvtColor(const v8::Arguments& args) { cv::cvtColor(self->mat, self->mat, iTransform); - return scope.Close(Undefined()); + NanReturnUndefined(); } // @author SergeMv // arrChannels = img.split(); -Handle -Matrix::Split(const v8::Arguments& args) { +NAN_METHOD(Matrix::Split) { HandleScope scope; Matrix * self = ObjectWrap::Unwrap(args.This()); @@ -1630,14 +1595,13 @@ Matrix::Split(const v8::Arguments& args) { arrChannels->Set(i, matObject); } - return scope.Close(arrChannels); + NanReturnValue(arrChannels); } // @author SergeMv // img.merge(arrChannels); -Handle -Matrix::Merge(const v8::Arguments& args) { +NAN_METHOD(Matrix::Merge) { HandleScope scope; Matrix * self = ObjectWrap::Unwrap(args.This()); @@ -1656,26 +1620,24 @@ Matrix::Merge(const v8::Arguments& args) { } cv::merge(vChannels, self->mat); - return scope.Close(Undefined()); + NanReturnUndefined(); } // @author SergeMv // Equalizes histogram // img.equalizeHist() -Handle -Matrix::EqualizeHist(const v8::Arguments& args) { +NAN_METHOD(Matrix::EqualizeHist) { HandleScope scope; Matrix * self = ObjectWrap::Unwrap(args.This()); cv::equalizeHist(self->mat, self->mat); - return scope.Close(Undefined()); + NanReturnUndefined(); } -Handle -Matrix::FloodFill(const Arguments& args){ +NAN_METHOD(Matrix::FloodFill(const Arguments& args){ SETUP_FUNCTION(Matrix) //obj->Get(v8::String::NewSymbol("x")) //int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int) @@ -1704,15 +1666,14 @@ Matrix::FloodFill(const Arguments& args){ , 4 ); - return scope.Close(Number::New( ret )); + NanReturnValue(Number::New( ret )); } // @author ytham // Match Template filter // Usage: output = input.matchTemplate("templateFileString", method); -Handle -Matrix::MatchTemplate(const v8::Arguments& args) { +NAN_METHOD(Matrix::MatchTemplate) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1743,14 +1704,13 @@ Matrix::MatchTemplate(const v8::Arguments& args) { double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; cv::minMaxLoc(m_out->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); - return scope.Close(out); + NanReturnValue(out); } // @author ytham // Min/Max location -Handle -Matrix::MinMaxLoc(const v8::Arguments& args) { +NAN_METHOD(Matrix::MinMaxLoc) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1781,14 +1741,13 @@ Matrix::MinMaxLoc(const v8::Arguments& args) { result->Set(String::NewSymbol("minLoc"), o_minLoc); result->Set(String::NewSymbol("maxLoc"), o_maxLoc); - return scope.Close(result); + NanReturnValue(result); } // @author ytham // Pushes some matrix (argument) the back of a matrix (self) -Handle -Matrix::PushBack(const v8::Arguments& args) { +NAN_METHOD(Matrix::PushBack) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1797,11 +1756,10 @@ Matrix::PushBack(const v8::Arguments& args) { self->mat.push_back(m_input->mat); - return scope.Close(args.This()); + NanReturnValue(args.This()); } -Handle -Matrix::PutText(const v8::Arguments& args) { +NAN_METHOD(Matrix::PutText) { HandleScope scope; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1839,11 +1797,10 @@ Matrix::PutText(const v8::Arguments& args) { cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, 2); - return scope.Close(Undefined()); + NanReturnUndefined(); } -Handle -Matrix::GetPerspectiveTransform(const v8::Arguments& args) { +NAN_METHOD(Matrix::GetPerspectiveTransform) { HandleScope scope; // extract quad args @@ -1861,11 +1818,10 @@ Matrix::GetPerspectiveTransform(const v8::Arguments& args) { Matrix *xfrmmat = ObjectWrap::Unwrap(xfrm); xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners); - return scope.Close(xfrm); + NanReturnValue(xfrm); } -Handle -Matrix::WarpPerspective(const v8::Arguments& args) { +NAN_METHOD(Matrix::WarpPerspective) { SETUP_FUNCTION(Matrix) Matrix *xfrm = ObjectWrap::Unwrap(args[0]->ToObject()); @@ -1890,11 +1846,10 @@ Matrix::WarpPerspective(const v8::Arguments& args) { ~self->mat; self->mat = res; - return scope.Close(v8::Null()); + NanReturnValue(v8::Null()); } -Handle -Matrix::CopyWithMask(const v8::Arguments& args) { +NAN_METHOD(Matrix::CopyWithMask) { SETUP_FUNCTION(Matrix) // param 0 - destination image: @@ -1904,12 +1859,11 @@ Matrix::CopyWithMask(const v8::Arguments& args) { self->mat.copyTo(dest->mat,mask->mat); - return scope.Close(Undefined()); + NanReturnUndefined(); } -Handle -Matrix::SetWithMask(const v8::Arguments& args) { +NAN_METHOD(Matrix::SetWithMask) { SETUP_FUNCTION(Matrix) // param 0 - target value: @@ -1924,11 +1878,10 @@ Matrix::SetWithMask(const v8::Arguments& args) { self->mat.setTo(newvals,mask->mat); - return scope.Close(Undefined()); + NanReturnUndefined(); } -Handle -Matrix::MeanWithMask(const v8::Arguments& args) { +NAN_METHOD(Matrix::MeanWithMask) { SETUP_FUNCTION(Matrix) // param 0 - mask. same size as src and dest @@ -1940,11 +1893,10 @@ Matrix::MeanWithMask(const v8::Arguments& args) { arr->Set(1, Number::New( means[1] )); arr->Set(2, Number::New( means[2] )); - return scope.Close(arr); + NanReturnValue(arr); } -Handle -Matrix::Shift(const v8::Arguments& args){ +NAN_METHOD(Matrix::Shift){ SETUP_FUNCTION(Matrix) cv::Mat res; @@ -1974,5 +1926,5 @@ Matrix::Shift(const v8::Arguments& args){ ~self->mat; self->mat = res; - return scope.Close(Undefined()); -} \ No newline at end of file + NanReturnUndefined(); +} diff --git a/src/OpenCV.cc b/src/OpenCV.cc index 37b886f..7dd7fe7 100755 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -18,7 +18,7 @@ OpenCV::Init(Handle target) { Handle -OpenCV::ReadImage(const Arguments &args) { +OpenCV::ReadImage() { HandleScope scope; try{ diff --git a/src/OpenCV.h b/src/OpenCV.h index b6d3e33..d640be1 100755 --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -22,11 +22,11 @@ using namespace node; #define SETUP_FUNCTION(TYP) \ - HandleScope scope; \ + NanScope(); \ TYP *self = ObjectWrap::Unwrap(args.This()); #define JSFUNC(NAME) \ - NAN_METHOD(NAME); + static NAN_METHOD(NAME); //static Handle NAME(const Arguments& args); #define JSTHROW_TYPE(ERR) \ diff --git a/src/Point.cc b/src/Point.cc index 9b5afa6..cbf06a4 100755 --- a/src/Point.cc +++ b/src/Point.cc @@ -23,8 +23,7 @@ Point::Init(Handle target) { target->Set(String::NewSymbol("Point"), constructor->GetFunction()); }; -Handle -Point::New(const Arguments &args) { +NAN_METHOD(Point::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0) @@ -38,15 +37,13 @@ Point::New(const Arguments &args) { return args.This(); } -Handle -Point::GetX(Local prop, const AccessorInfo &info) { +NAN_METHOD(Point::GetX(Local prop, const AccessorInfo &info) { HandleScope scope; Point *pt = ObjectWrap::Unwrap(info.This()); return scope.Close(Number::New(pt->point.x)); } -Handle -Point::GetY(Local prop, const AccessorInfo &info) { +NAN_METHOD(Point::GetY(Local prop, const AccessorInfo &info) { HandleScope scope; Point *pt = ObjectWrap::Unwrap(info.This()); return scope.Close(Number::New(pt->point.y)); @@ -57,8 +54,7 @@ Point::RaiseImmutable(Local property, Local value, const Accessor v8::ThrowException(v8::Exception::TypeError(v8::String::New("Point is immutable"))); } -Handle -Point::Dot(const v8::Arguments& args){ +NAN_METHOD(Point::Dot(const v8::Arguments& args){ HandleScope scope; Point *p1 = ObjectWrap::Unwrap(args.This()); Point *p2 = ObjectWrap::Unwrap(args[0]->ToObject()); diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index 22308ab..bac4e64 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -43,8 +43,7 @@ VideoCaptureWrap::Init(Handle target) { target->Set(String::NewSymbol("VideoCapture"), constructor->GetFunction()); }; -Handle -VideoCaptureWrap::New(const Arguments &args) { +NAN_METHOD(VideoCaptureWrap::New() { HandleScope scope; if (args.This()->InternalFieldCount() == 0) @@ -85,8 +84,7 @@ VideoCaptureWrap::VideoCaptureWrap(const std::string& filename){ } -Handle -VideoCaptureWrap::SetWidth(const Arguments &args){ +NAN_METHOD(VideoCaptureWrap::SetWidth(){ HandleScope scope; VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); @@ -102,8 +100,7 @@ VideoCaptureWrap::SetWidth(const Arguments &args){ return scope.Close(Undefined()); } -Handle -VideoCaptureWrap::SetHeight(const Arguments &args){ +NAN_METHOD(VideoCaptureWrap::SetHeight(){ HandleScope scope; VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); @@ -118,8 +115,7 @@ VideoCaptureWrap::SetHeight(const Arguments &args){ return Undefined(); } -Handle -VideoCaptureWrap::SetPosition(const Arguments &args){ +NAN_METHOD(VideoCaptureWrap::SetPosition(){ HandleScope scope; VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); @@ -134,8 +130,7 @@ VideoCaptureWrap::SetPosition(const Arguments &args){ return Undefined(); } -Handle -VideoCaptureWrap::Close(const Arguments &args){ +NAN_METHOD(VideoCaptureWrap::Close(){ HandleScope scope; VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); @@ -145,8 +140,7 @@ VideoCaptureWrap::Close(const Arguments &args){ return Undefined(); } -Handle -VideoCaptureWrap::Read(const Arguments &args) { +NAN_METHOD(VideoCaptureWrap::Read() { HandleScope scope; VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); @@ -197,8 +191,7 @@ void AfterAsyncRead(uv_work_t *req) { -Handle -VideoCaptureWrap::ReadSync(const Arguments &args) { +NAN_METHOD(VideoCaptureWrap::ReadSync() { HandleScope scope; VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); From d0351f336f0d835c9a990236f072ac1af0bc4ef6 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Sat, 20 Sep 2014 16:00:20 +0200 Subject: [PATCH 04/12] - migration of OpenCV.h/.cc done - migration of init.cc done - migration of Matrix.cc about half done - migration of Contours.cc in progress --- src/Contours.cc | 95 ++-- src/Matrix.cc | 1286 +++++++++-------------------------------------- src/OpenCV.cc | 29 +- src/OpenCV.h | 10 +- src/init.cc | 8 +- 5 files changed, 316 insertions(+), 1112 deletions(-) diff --git a/src/Contours.cc b/src/Contours.cc index 2fa4ad9..3eb6040 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -1,5 +1,6 @@ #include "Contours.h" #include "OpenCV.h" +#include #include @@ -8,56 +9,63 @@ v8::Persistent Contour::constructor; void Contour::Init(Handle target) { - HandleScope scope; + NanScope(); //Class - v8::Local m = v8::FunctionTemplate::New(New); + /*v8::Local m = v8::FunctionTemplate::New(New); m->SetClassName(v8::String::NewSymbol("Contours")); // Constructor constructor = Persistent::New(m); constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("Contours")); + constructor->SetClassName(String::NewSymbol("Contours"));*/ + + Local ctor = NanNew(Contour::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("Contours")); + // Prototype //Local proto = constructor->PrototypeTemplate(); - NODE_SET_PROTOTYPE_METHOD(constructor, "point", Point); - NODE_SET_PROTOTYPE_METHOD(constructor, "size", Size); - NODE_SET_PROTOTYPE_METHOD(constructor, "cornerCount", CornerCount); - NODE_SET_PROTOTYPE_METHOD(constructor, "area", Area); - NODE_SET_PROTOTYPE_METHOD(constructor, "arcLength", ArcLength); - NODE_SET_PROTOTYPE_METHOD(constructor, "approxPolyDP", ApproxPolyDP); - NODE_SET_PROTOTYPE_METHOD(constructor, "convexHull", ConvexHull); - NODE_SET_PROTOTYPE_METHOD(constructor, "boundingRect", BoundingRect); - NODE_SET_PROTOTYPE_METHOD(constructor, "minAreaRect", MinAreaRect); - NODE_SET_PROTOTYPE_METHOD(constructor, "isConvex", IsConvex); - NODE_SET_PROTOTYPE_METHOD(constructor, "moments", Moments); - target->Set(String::NewSymbol("Contours"), m->GetFunction()); + NODE_SET_PROTOTYPE_METHOD(ctor, "point", Point); + NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size); + NODE_SET_PROTOTYPE_METHOD(ctor, "cornerCount", CornerCount); + NODE_SET_PROTOTYPE_METHOD(ctor, "area", Area); + NODE_SET_PROTOTYPE_METHOD(ctor, "arcLength", ArcLength); + NODE_SET_PROTOTYPE_METHOD(ctor, "approxPolyDP", ApproxPolyDP); + NODE_SET_PROTOTYPE_METHOD(ctor, "convexHull", ConvexHull); + NODE_SET_PROTOTYPE_METHOD(ctor, "boundingRect", BoundingRect); + NODE_SET_PROTOTYPE_METHOD(ctor, "minAreaRect", MinAreaRect); + NODE_SET_PROTOTYPE_METHOD(ctor, "isConvex", IsConvex); + NODE_SET_PROTOTYPE_METHOD(ctor, "moments", Moments); + //target->Set(String::NewSymbol("Contours"), m->GetFunction()); + + target->Set(NanNew("Contours"), ctor->GetFunction()); }; -NAN_METHOD(Contour::New() { - HandleScope scope; +NAN_METHOD(Contour::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0) - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Cannot instantiate without new"))); + NanThrowTypeError("Cannot instantiate without new"); Contour *contours; contours = new Contour; contours->Wrap(args.Holder()); - return scope.Close(args.Holder()); + NanReturnValue(args.Holder()); } Contour::Contour(): ObjectWrap() { } - -NAN_METHOD(Contour::Point() { - HandleScope scope; +NAN_METHOD(Contour::Point) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -72,19 +80,20 @@ NAN_METHOD(Contour::Point() { return scope.Close(data); } +/* // FIXME: this sould better be called "Length" as ``Contours`` is an Array like structure // also, this would allow to use ``Size`` for the function returning the number of corners // in the contour for better consistency with OpenCV. -NAN_METHOD(Contour::Size() { - HandleScope scope; +NAN_METHOD(Contour::Size) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); return scope.Close(Number::New(self->contours.size())); } -NAN_METHOD(Contour::CornerCount() { - HandleScope scope; +NAN_METHOD(Contour::CornerCount) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -92,8 +101,8 @@ NAN_METHOD(Contour::CornerCount() { return scope.Close(Number::New(self->contours[pos].size())); } -NAN_METHOD(Contour::Area() { - HandleScope scope; +NAN_METHOD(Contour::Area) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -103,8 +112,8 @@ NAN_METHOD(Contour::Area() { } -NAN_METHOD(Contour::ArcLength() { - HandleScope scope; +NAN_METHOD(Contour::ArcLength) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -114,8 +123,8 @@ NAN_METHOD(Contour::ArcLength() { } -NAN_METHOD(Contour::ApproxPolyDP() { - HandleScope scope; +NAN_METHOD(Contour::ApproxPolyDP) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -130,8 +139,8 @@ NAN_METHOD(Contour::ApproxPolyDP() { } -NAN_METHOD(Contour::ConvexHull() { - HandleScope scope; +NAN_METHOD(Contour::ConvexHull) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); @@ -146,8 +155,8 @@ NAN_METHOD(Contour::ConvexHull() { } -NAN_METHOD(Contour::BoundingRect() { - HandleScope scope; +NAN_METHOD(Contour::BoundingRect) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -164,8 +173,8 @@ NAN_METHOD(Contour::BoundingRect() { } -NAN_METHOD(Contour::MinAreaRect() { - HandleScope scope; +NAN_METHOD(Contour::MinAreaRect) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -202,8 +211,8 @@ NAN_METHOD(Contour::MinAreaRect() { } -NAN_METHOD(Contour::IsConvex() { - HandleScope scope; +NAN_METHOD(Contour::IsConvex) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -211,8 +220,8 @@ NAN_METHOD(Contour::IsConvex() { return scope.Close(Boolean::New(isContourConvex(cv::Mat(self->contours[pos])))); } -NAN_METHOD(Contour::Moments() { - HandleScope scope; +NAN_METHOD(Contour::Moments) { + NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); @@ -229,4 +238,4 @@ NAN_METHOD(Contour::Moments() { return scope.Close(res); } - +*/ diff --git a/src/Matrix.cc b/src/Matrix.cc index 8a374dd..15870ef 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -13,131 +13,111 @@ cv::Rect* setRect(Local objRect); void Matrix::Init(Handle target) { - //HandleScope scope; - //NanScope(); + NanScope(); //Class - /*//v8::Local m = v8::FunctionTemplate::New(New); - v8::Local m = NanNew(Matrix::New); + Local ctor = NanNew(Matrix::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("Matrix")); - //m->SetClassName(v8::String::NewSymbol("Matrix")); - m->SetClassName(NanNew("Matrix")); + // Prototype - // Constructor - constructor = Persistent:NanNew((m); - NanAssignPersistent(Matrix::constructor, constructor); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - //constructor->SetClassName(String::NewSymbol("Matrix"));*/ + NODE_SET_PROTOTYPE_METHOD(ctor, "row", Row); + NODE_SET_PROTOTYPE_METHOD(ctor, "col", Col); - v8::Local tpl = NanNew(Matrix::New); - //Local tpl = FunctionTemplate::New( New ); - tpl->SetClassName(NanNew("Matrix")); - tpl->InstanceTemplate()->SetInternalFieldCount(1); + NODE_SET_PROTOTYPE_METHOD(ctor, "pixelRow", PixelRow); + NODE_SET_PROTOTYPE_METHOD(ctor, "pixelCol", PixelCol); - //target->Set( NanNew("Matrix"), tpl->GetFunction()); + NODE_SET_PROTOTYPE_METHOD(ctor, "empty", Empty); + NODE_SET_PROTOTYPE_METHOD(ctor, "get", Get); + NODE_SET_PROTOTYPE_METHOD(ctor, "set", Set); + NODE_SET_PROTOTYPE_METHOD(ctor, "pixel", Pixel); + NODE_SET_PROTOTYPE_METHOD(ctor, "width", Width); + NODE_SET_PROTOTYPE_METHOD(ctor, "height", Height); + NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size); + NODE_SET_PROTOTYPE_METHOD(ctor, "clone", Clone); + NODE_SET_PROTOTYPE_METHOD(ctor, "toBuffer", ToBuffer); + NODE_SET_PROTOTYPE_METHOD(ctor, "toBufferAsync", ToBufferAsync); + NODE_SET_PROTOTYPE_METHOD(ctor, "ellipse", Ellipse); + NODE_SET_PROTOTYPE_METHOD(ctor, "rectangle", Rectangle); + NODE_SET_PROTOTYPE_METHOD(ctor, "line", Line); + NODE_SET_PROTOTYPE_METHOD(ctor, "save", Save); + NODE_SET_PROTOTYPE_METHOD(ctor, "saveAsync", SaveAsync); + NODE_SET_PROTOTYPE_METHOD(ctor, "resize", Resize); + NODE_SET_PROTOTYPE_METHOD(ctor, "rotate", Rotate); + NODE_SET_PROTOTYPE_METHOD(ctor, "copyTo", CopyTo); + NODE_SET_PROTOTYPE_METHOD(ctor, "pyrDown", PyrDown); + NODE_SET_PROTOTYPE_METHOD(ctor, "pyrUp", PyrUp); + NODE_SET_PROTOTYPE_METHOD(ctor, "channels", Channels); - //contructor - // Prototype - //Local proto = constructor->PrototypeTemplate(); - //constructor = tpl; - NanAssignPersistent(Matrix::constructor, tpl); + NODE_SET_PROTOTYPE_METHOD(ctor, "convertGrayscale", ConvertGrayscale); + NODE_SET_PROTOTYPE_METHOD(ctor, "convertHSVscale", ConvertHSVscale); + NODE_SET_PROTOTYPE_METHOD(ctor, "gaussianBlur", GaussianBlur); + NODE_SET_PROTOTYPE_METHOD(ctor, "medianBlur", MedianBlur); + NODE_SET_PROTOTYPE_METHOD(ctor, "bilateralFilter", BilateralFilter); + NODE_SET_PROTOTYPE_METHOD(ctor, "copy", Copy); + NODE_SET_PROTOTYPE_METHOD(ctor, "flip", Flip); + NODE_SET_PROTOTYPE_METHOD(ctor, "roi", ROI); + NODE_SET_PROTOTYPE_METHOD(ctor, "ptr", Ptr); + NODE_SET_PROTOTYPE_METHOD(ctor, "absDiff", AbsDiff); + NODE_SET_PROTOTYPE_METHOD(ctor, "addWeighted", AddWeighted); + NODE_SET_PROTOTYPE_METHOD(ctor, "bitwiseXor", BitwiseXor); + NODE_SET_PROTOTYPE_METHOD(ctor, "bitwiseNot", BitwiseNot); + NODE_SET_PROTOTYPE_METHOD(ctor, "bitwiseAnd", BitwiseAnd); + NODE_SET_PROTOTYPE_METHOD(ctor, "countNonZero", CountNonZero); + NODE_SET_PROTOTYPE_METHOD(ctor, "canny", Canny); + NODE_SET_PROTOTYPE_METHOD(ctor, "dilate", Dilate); + NODE_SET_PROTOTYPE_METHOD(ctor, "erode", Erode); + NODE_SET_PROTOTYPE_METHOD(ctor, "findContours", FindContours); + NODE_SET_PROTOTYPE_METHOD(ctor, "drawContour", DrawContour); + NODE_SET_PROTOTYPE_METHOD(ctor, "drawAllContours", DrawAllContours); - NODE_SET_PROTOTYPE_METHOD(tpl, "row", Row); - NODE_SET_PROTOTYPE_METHOD(tpl, "col", Col); + NODE_SET_PROTOTYPE_METHOD(ctor, "goodFeaturesToTrack", GoodFeaturesToTrack); + NODE_SET_PROTOTYPE_METHOD(ctor, "houghLinesP", HoughLinesP); - NODE_SET_PROTOTYPE_METHOD(tpl, "pixelRow", PixelRow); - NODE_SET_PROTOTYPE_METHOD(tpl, "pixelCol", PixelCol); + NODE_SET_PROTOTYPE_METHOD(ctor, "inRange", inRange); + NODE_SET_PROTOTYPE_METHOD(ctor, "adjustROI", AdjustROI); + NODE_SET_PROTOTYPE_METHOD(ctor, "locateROI", LocateROI); - NODE_SET_PROTOTYPE_METHOD(tpl, "empty", Empty); - NODE_SET_PROTOTYPE_METHOD(tpl, "get", Get); - NODE_SET_PROTOTYPE_METHOD(tpl, "set", Set); - NODE_SET_PROTOTYPE_METHOD(tpl, "pixel", Pixel); - NODE_SET_PROTOTYPE_METHOD(tpl, "width", Width); - NODE_SET_PROTOTYPE_METHOD(tpl, "height", Height); - NODE_SET_PROTOTYPE_METHOD(tpl, "size", Size); - NODE_SET_PROTOTYPE_METHOD(tpl, "clone", Clone); - NODE_SET_PROTOTYPE_METHOD(tpl, "toBuffer", ToBuffer); - NODE_SET_PROTOTYPE_METHOD(tpl, "toBufferAsync", ToBufferAsync); - NODE_SET_PROTOTYPE_METHOD(tpl, "ellipse", Ellipse); - NODE_SET_PROTOTYPE_METHOD(tpl, "rectangle", Rectangle); - NODE_SET_PROTOTYPE_METHOD(tpl, "line", Line); - NODE_SET_PROTOTYPE_METHOD(tpl, "save", Save); - NODE_SET_PROTOTYPE_METHOD(tpl, "saveAsync", SaveAsync); - NODE_SET_PROTOTYPE_METHOD(tpl, "resize", Resize); - NODE_SET_PROTOTYPE_METHOD(tpl, "rotate", Rotate); - NODE_SET_PROTOTYPE_METHOD(tpl, "copyTo", CopyTo); - NODE_SET_PROTOTYPE_METHOD(tpl, "pyrDown", PyrDown); - NODE_SET_PROTOTYPE_METHOD(tpl, "pyrUp", PyrUp); - NODE_SET_PROTOTYPE_METHOD(tpl, "channels", Channels); + NODE_SET_PROTOTYPE_METHOD(ctor, "threshold", Threshold); + NODE_SET_PROTOTYPE_METHOD(ctor, "adaptiveThreshold", AdaptiveThreshold); + NODE_SET_PROTOTYPE_METHOD(ctor, "meanStdDev", MeanStdDev); - NODE_SET_PROTOTYPE_METHOD(tpl, "convertGrayscale", ConvertGrayscale); - NODE_SET_PROTOTYPE_METHOD(tpl, "convertHSVscale", ConvertHSVscale); - NODE_SET_PROTOTYPE_METHOD(tpl, "gaussianBlur", GaussianBlur); - NODE_SET_PROTOTYPE_METHOD(tpl, "medianBlur", MedianBlur); - NODE_SET_PROTOTYPE_METHOD(tpl, "bilateralFilter", BilateralFilter); - NODE_SET_PROTOTYPE_METHOD(tpl, "copy", Copy); - NODE_SET_PROTOTYPE_METHOD(tpl, "flip", Flip); - NODE_SET_PROTOTYPE_METHOD(tpl, "roi", ROI); - NODE_SET_PROTOTYPE_METHOD(tpl, "ptr", Ptr); - NODE_SET_PROTOTYPE_METHOD(tpl, "absDiff", AbsDiff); - NODE_SET_PROTOTYPE_METHOD(tpl, "addWeighted", AddWeighted); - NODE_SET_PROTOTYPE_METHOD(tpl, "bitwiseXor", BitwiseXor); - NODE_SET_PROTOTYPE_METHOD(tpl, "bitwiseNot", BitwiseNot); - NODE_SET_PROTOTYPE_METHOD(tpl, "bitwiseAnd", BitwiseAnd); - NODE_SET_PROTOTYPE_METHOD(tpl, "countNonZero", CountNonZero); - NODE_SET_PROTOTYPE_METHOD(tpl, "canny", Canny); - NODE_SET_PROTOTYPE_METHOD(tpl, "dilate", Dilate); - NODE_SET_PROTOTYPE_METHOD(tpl, "erode", Erode); + NODE_SET_PROTOTYPE_METHOD(ctor, "cvtColor", CvtColor); + NODE_SET_PROTOTYPE_METHOD(ctor, "split", Split); + NODE_SET_PROTOTYPE_METHOD(ctor, "merge", Merge); + NODE_SET_PROTOTYPE_METHOD(ctor, "equalizeHist", EqualizeHist); - NODE_SET_PROTOTYPE_METHOD(tpl, "findContours", FindContours); - NODE_SET_PROTOTYPE_METHOD(tpl, "drawContour", DrawContour); - NODE_SET_PROTOTYPE_METHOD(tpl, "drawAllContours", DrawAllContours); + NODE_SET_PROTOTYPE_METHOD(ctor, "floodFill", FloodFill); - NODE_SET_PROTOTYPE_METHOD(tpl, "goodFeaturesToTrack", GoodFeaturesToTrack); - NODE_SET_PROTOTYPE_METHOD(tpl, "houghLinesP", HoughLinesP); + NODE_SET_PROTOTYPE_METHOD(ctor, "matchTemplate", MatchTemplate); + NODE_SET_PROTOTYPE_METHOD(ctor, "minMaxLoc", MinMaxLoc); - NODE_SET_PROTOTYPE_METHOD(tpl, "inRange", inRange); - NODE_SET_PROTOTYPE_METHOD(tpl, "adjustROI", AdjustROI); - NODE_SET_PROTOTYPE_METHOD(tpl, "locateROI", LocateROI); + NODE_SET_PROTOTYPE_METHOD(ctor, "pushBack", PushBack); - NODE_SET_PROTOTYPE_METHOD(tpl, "threshold", Threshold); - NODE_SET_PROTOTYPE_METHOD(tpl, "adaptiveThreshold", AdaptiveThreshold); - NODE_SET_PROTOTYPE_METHOD(tpl, "meanStdDev", MeanStdDev); - - NODE_SET_PROTOTYPE_METHOD(tpl, "cvtColor", CvtColor); - NODE_SET_PROTOTYPE_METHOD(tpl, "split", Split); - NODE_SET_PROTOTYPE_METHOD(tpl, "merge", Merge); - NODE_SET_PROTOTYPE_METHOD(tpl, "equalizeHist", EqualizeHist); - - NODE_SET_PROTOTYPE_METHOD(tpl, "floodFill", FloodFill); - - NODE_SET_PROTOTYPE_METHOD(tpl, "matchTemplate", MatchTemplate); - NODE_SET_PROTOTYPE_METHOD(tpl, "minMaxLoc", MinMaxLoc); - - NODE_SET_PROTOTYPE_METHOD(tpl, "pushBack", PushBack); - - NODE_SET_PROTOTYPE_METHOD(tpl, "putText", PutText); + NODE_SET_PROTOTYPE_METHOD(ctor, "putText", PutText); - NODE_SET_PROTOTYPE_METHOD(tpl, "getPerspectiveTransform", GetPerspectiveTransform); - NODE_SET_PROTOTYPE_METHOD(tpl, "warpPerspective", WarpPerspective); + NODE_SET_PROTOTYPE_METHOD(ctor, "getPerspectiveTransform", GetPerspectiveTransform); + NODE_SET_PROTOTYPE_METHOD(ctor, "warpPerspective", WarpPerspective); - NODE_SET_METHOD(tpl, "Eye", Eye); + NODE_SET_METHOD(ctor, "Eye", Eye); - NODE_SET_PROTOTYPE_METHOD(tpl, "copyWithMask", CopyWithMask); - NODE_SET_PROTOTYPE_METHOD(tpl, "setWithMask", SetWithMask); - NODE_SET_PROTOTYPE_METHOD(tpl, "meanWithMask", MeanWithMask); - NODE_SET_PROTOTYPE_METHOD(tpl, "shift", Shift); + NODE_SET_PROTOTYPE_METHOD(ctor, "copyWithMask", CopyWithMask); + NODE_SET_PROTOTYPE_METHOD(ctor, "setWithMask", SetWithMask); + NODE_SET_PROTOTYPE_METHOD(ctor, "meanWithMask", MeanWithMask); + NODE_SET_PROTOTYPE_METHOD(ctor, "shift", Shift); - //target->Set(String::NewSymbol("Matrix"), m->GetFunction()); - target->Set( NanNew("Matrix"), tpl->GetFunction() ); + //target->Set(NanNew("Matrix"), m->GetFunction()); + //target->Set( NanNew("Matrix"), ctor->GetFunction() ); + target->Set(NanNew("Matrix"), ctor->GetFunction()); }; NAN_METHOD(Matrix::New) { - //HandleScope scope; NanScope(); if (args.This()->InternalFieldCount() == 0) - return NanThrowTypeError("Cannot instantiate without new"); + NanThrowTypeError("Cannot instantiate without new"); Matrix *mat; @@ -156,7 +136,6 @@ NAN_METHOD(Matrix::New) { mat->Wrap(args.Holder()); NanReturnValue(args.Holder()); - //NanReturnValue(args.Holder()); } @@ -178,11 +157,8 @@ Matrix::Matrix(cv::Mat m, cv::Rect roi): ObjectWrap() { NAN_METHOD(Matrix::Empty){ SETUP_FUNCTION(Matrix) NanReturnValue(NanNew(self->mat.empty())); - //NanReturnValue(Boolean::New(self->mat.empty())); } - - double Matrix::DblGet(cv::Mat mat, int i, int j){ @@ -212,8 +188,6 @@ Matrix::DblGet(cv::Mat mat, int i, int j){ } - - NAN_METHOD(Matrix::Pixel){ SETUP_FUNCTION(Matrix) @@ -244,10 +218,9 @@ NAN_METHOD(Matrix::Pixel){ } NanReturnUndefined(); //double val = Matrix::DblGet(t, i, j); - //NanReturnValue(Number::New(val)); + //NanReturnValue(NanNew(val)); } - NAN_METHOD(Matrix::Get){ SETUP_FUNCTION(Matrix) @@ -259,7 +232,6 @@ NAN_METHOD(Matrix::Get){ } - NAN_METHOD(Matrix::Set){ SETUP_FUNCTION(Matrix) @@ -289,31 +261,29 @@ NAN_METHOD(Matrix::Set){ } else { - NanTypeError( "Invalid number of arguments" ); - //return v8::ThrowException(v8::Exception::TypeError(String::New("Invalid number of arguments"))); + NanThrowTypeError( "Invalid number of arguments" ); } NanReturnUndefined(); } - - NAN_METHOD(Matrix::Size){ SETUP_FUNCTION(Matrix) - v8::Local arr = v8::Array::New(2); - arr->Set(0, Number::New(self->mat.size().height)); - arr->Set(1, Number::New(self->mat.size().width)); + v8::Local arr = NanNew(2); + arr->Set(0, NanNew(self->mat.size().height)); + arr->Set(1, NanNew(self->mat.size().width)); NanReturnValue(arr); } - NAN_METHOD(Matrix::Clone){ SETUP_FUNCTION(Matrix) - - Local im_h = Matrix::constructor->GetFunction()->NewInstance(); + + //Local constructorHandle = NanNew(Matrix::constructor); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m = ObjectWrap::Unwrap(im_h); m->mat = self->mat.clone(); @@ -326,11 +296,11 @@ NAN_METHOD(Matrix::Row){ int width = self->mat.size().width; int y = args[0]->IntegerValue(); - v8::Local arr = v8::Array::New(width); + v8::Local arr = NanNew(width); for (int x=0; xmat, y, x); - arr->Set(x, Number::New(v)); + arr->Set(x, NanNew(v)); } NanReturnValue(arr); @@ -342,15 +312,15 @@ NAN_METHOD(Matrix::PixelRow){ int width = self->mat.size().width; int y = args[0]->IntegerValue(); - v8::Local arr = v8::Array::New(width * 3); + v8::Local arr = NanNew(width * 3); for (int x=0; xmat.at(y, x); int offset = x * 3; - arr->Set(offset , Number::New((double)pixel.val[0])); - arr->Set(offset + 1, Number::New((double)pixel.val[1])); - arr->Set(offset + 2, Number::New((double)pixel.val[2])); -} + arr->Set(offset , NanNew((double)pixel.val[0])); + arr->Set(offset + 1, NanNew((double)pixel.val[1])); + arr->Set(offset + 2, NanNew((double)pixel.val[2])); + } NanReturnValue(arr); } @@ -361,11 +331,11 @@ NAN_METHOD(Matrix::Col){ int height = self->mat.size().height; int x = args[0]->IntegerValue(); - v8::Local arr = v8::Array::New(height); + v8::Local arr = NanNew(height); for (int y=0; ymat, y, x); - arr->Set(y, Number::New(v)); + arr->Set(y, NanNew(v)); } NanReturnValue(arr); } @@ -376,14 +346,14 @@ NAN_METHOD(Matrix::PixelCol){ int height = self->mat.size().height; int x = args[0]->IntegerValue(); - v8::Local arr = v8::Array::New(height * 3); + v8::Local arr = NanNew(height * 3); for (int y=0; ymat.at(y, x); int offset = y * 3; - arr->Set(offset , Number::New((double)pixel.val[0])); - arr->Set(offset + 1, Number::New((double)pixel.val[1])); - arr->Set(offset + 2, Number::New((double)pixel.val[2])); + arr->Set(offset , NanNew((double)pixel.val[0])); + arr->Set(offset + 1, NanNew((double)pixel.val[1])); + arr->Set(offset + 2, NanNew((double)pixel.val[2])); } NanReturnValue(arr); } @@ -392,19 +362,19 @@ NAN_METHOD(Matrix::PixelCol){ NAN_METHOD(Matrix::Width){ SETUP_FUNCTION(Matrix) - NanReturnValue(Number::New(self->mat.size().width)); + NanReturnValue(NanNew(self->mat.size().width)); } NAN_METHOD(Matrix::Height){ SETUP_FUNCTION(Matrix) - NanReturnValue(Number::New(self->mat.size().height)); + NanReturnValue(NanNew(self->mat.size().height)); } NAN_METHOD(Matrix::Channels){ SETUP_FUNCTION(Matrix) - NanReturnValue(Number::New(self->mat.channels())); + NanReturnValue(NanNew(self->mat.channels())); } @@ -430,18 +400,18 @@ NAN_METHOD(Matrix::ToBuffer){ // Get this options argument v8::Handle options = v8::Handle::Cast(args[0]); // If the extension (image format) is provided - if (options->Has(v8::String::New("ext"))) { - v8::String::Utf8Value str ( options->Get(v8::String::New("ext"))->ToString() ); + if (options->Has(NanNew("ext"))) { + v8::String::Utf8Value str ( options->Get(NanNew("ext"))->ToString() ); std::string str2 = std::string(*str); ext = (const char *) str2.c_str(); } - if (options->Has(v8::String::New("jpegQuality"))) { - int compression = options->Get(v8::String::New("jpegQuality"))->IntegerValue(); + if (options->Has(NanNew("jpegQuality"))) { + int compression = options->Get(NanNew("jpegQuality"))->IntegerValue(); params.push_back(CV_IMWRITE_JPEG_QUALITY); params.push_back(compression); } - if (options->Has(v8::String::New("pngCompression"))) { - int compression = options->Get(v8::String::New("pngCompression"))->IntegerValue(); + if (options->Has(NanNew("pngCompression"))) { + int compression = options->Get(NanNew("pngCompression"))->IntegerValue(); params.push_back(CV_IMWRITE_PNG_COMPRESSION); params.push_back(compression); } @@ -450,23 +420,25 @@ NAN_METHOD(Matrix::ToBuffer){ std::vector vec(0); - // We use operator * before the "ext" variable, because it converts v8::String::AsciiValue to char * + // We use operator * before the "ext" variable, because it converts String to char * cv::imencode(ext, self->mat, vec, params); - node::Buffer *buf = node::Buffer::New(vec.size()); - uchar* data = (uchar*) Buffer::Data(buf); - memcpy(data, &vec[0], vec.size()); + //Local buf = NanNewBufferHandle((char*)closure->data, closure->len); + //memcpy(Buffer::Data(buf), closure->data, closure->len); - v8::Local globalObj = v8::Context::GetCurrent()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(v8::String::New("Buffer"))); - v8::Handle constructorArgs[3] = {buf->handle_, v8::Integer::New(vec.size()), v8::Integer::New(0)}; + Local buf = NanNewBufferHandle(vec.size()); + uchar* data = (uchar*) Buffer::Data(buf); + memcpy(data, &vec[0], vec.size());//dest, source, size + + v8::Local globalObj = NanGetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); + v8::Handle constructorArgs[3] = {buf, NanNew(vec.size()), NanNew(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); NanReturnValue(actualBuffer); } - - +/*FIXME: look into this struct matrixToBuffer_baton_t { Matrix *mm; Persistent cb; @@ -494,18 +466,18 @@ NAN_METHOD(Matrix::ToBufferAsync){ // Get this options argument v8::Handle options = v8::Handle::Cast(args[1]); // If the extension (image format) is provided - if (options->Has(v8::String::New("ext"))) { - v8::String::Utf8Value str ( options->Get(v8::String::New("ext"))->ToString() ); + if (options->Has(NanNew("ext"))) { + v8::String::Utf8Value str ( options->Get(NanNew("ext"))->ToString() ); std::string str2 = std::string(*str); ext = str2; } - if (options->Has(v8::String::New("jpegQuality"))) { - int compression = options->Get(v8::String::New("jpegQuality"))->IntegerValue(); + if (options->Has(NanNew("jpegQuality"))) { + int compression = options->Get(NanNew("jpegQuality"))->IntegerValue(); baton->params.push_back(CV_IMWRITE_JPEG_QUALITY); baton->params.push_back(compression); } - if (options->Has(v8::String::New("pngCompression"))) { - int compression = options->Get(v8::String::New("pngCompression"))->IntegerValue(); + if (options->Has(NanNew("pngCompression"))) { + int compression = options->Get(NanNew("pngCompression"))->IntegerValue(); baton->params.push_back(CV_IMWRITE_PNG_COMPRESSION); baton->params.push_back(compression); } @@ -513,12 +485,15 @@ NAN_METHOD(Matrix::ToBufferAsync){ baton->ext = ext; baton->mm = self; - baton->cb = Persistent::New(cb); + + NanCallback *callback = new NanCallback(cb.As()); + + baton->cb = callback; //NAN_WEAK_CALLBACK(cb);//Persistent::New(cb); baton->request.data = baton; uv_queue_work(uv_default_loop(), &baton->request, AsyncToBufferAsync, (uv_after_work_cb)AfterAsyncToBufferAsync); - return Undefined(); + NanReturnUndefined(); } void AsyncToBufferAsync(uv_work_t *req) { @@ -536,21 +511,23 @@ void AsyncToBufferAsync(uv_work_t *req) { void AfterAsyncToBufferAsync(uv_work_t *req) { - HandleScope scope; - matrixToBuffer_baton_t *baton = static_cast(req->data); + NanScope(); + //FIXME: too many errors here : how to handle integers and node::buffer? + /*matrixToBuffer_baton_t *baton = static_cast(req->data); // ev_unref(EV_DEFAULT_UC); // baton->cc->Unref(); Local argv[2]; - argv[0] = Local::New(Null()); + argv[0] = NanNull(); - node::Buffer *buf = node::Buffer::New(baton->res.size()); + v8::Integer resSize = NanNew(baton->res.size()); + node::Buffer *buf = node::Buffer(resSize); uchar* data = (uchar*) Buffer::Data(buf); - memcpy(data, &baton->res[0], baton->res.size()); + memcpy(data, &baton->res[0], resSize); v8::Local globalObj = v8::Context::GetCurrent()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(v8::String::New("Buffer"))); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); v8::Handle constructorArgs[3] = {buf->handle_, v8::Integer::New(baton->res.size()), v8::Integer::New(0)}; v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); @@ -569,8 +546,7 @@ void AfterAsyncToBufferAsync(uv_work_t *req) { delete baton; // return 0; -} - +}*/ NAN_METHOD(Matrix::Ellipse){ SETUP_FUNCTION(Matrix) @@ -589,36 +565,36 @@ NAN_METHOD(Matrix::Ellipse){ if(args[0]->IsObject()) { v8::Handle options = v8::Handle::Cast(args[0]); - if (options->Has(v8::String::New("center"))) { - Local center = options->Get(v8::String::NewSymbol("center"))->ToObject(); - x = center->Get(v8::String::NewSymbol("x"))->Uint32Value(); - y = center->Get(v8::String::NewSymbol("y"))->Uint32Value(); + if (options->Has(NanNew("center"))) { + Local center = options->Get(NanNew("center"))->ToObject(); + x = center->Get(NanNew("x"))->Uint32Value(); + y = center->Get(NanNew("y"))->Uint32Value(); } - if (options->Has(v8::String::New("axes"))) { - Local axes = options->Get(v8::String::NewSymbol("axes"))->ToObject(); - width = axes->Get(v8::String::NewSymbol("width"))->Uint32Value(); - height = axes->Get(v8::String::NewSymbol("height"))->Uint32Value(); + if (options->Has(NanNew("axes"))) { + Local axes = options->Get(NanNew("axes"))->ToObject(); + width = axes->Get(NanNew("width"))->Uint32Value(); + height = axes->Get(NanNew("height"))->Uint32Value(); } - if (options->Has(v8::String::New("thickness"))) { - thickness = options->Get(v8::String::NewSymbol("thickness"))->Uint32Value(); + if (options->Has(NanNew("thickness"))) { + thickness = options->Get(NanNew("thickness"))->Uint32Value(); } - if (options->Has(v8::String::New("angle"))) { - angle = options->Get(v8::String::NewSymbol("angle"))->NumberValue(); + if (options->Has(NanNew("angle"))) { + angle = options->Get(NanNew("angle"))->NumberValue(); } - if (options->Has(v8::String::New("startAngle"))) { - startAngle = options->Get(v8::String::NewSymbol("startAngle"))->NumberValue(); + if (options->Has(NanNew("startAngle"))) { + startAngle = options->Get(NanNew("startAngle"))->NumberValue(); } - if (options->Has(v8::String::New("endAngle"))) { - endAngle = options->Get(v8::String::NewSymbol("endAngle"))->NumberValue(); + if (options->Has(NanNew("endAngle"))) { + endAngle = options->Get(NanNew("endAngle"))->NumberValue(); } - if (options->Has(v8::String::New("lineType"))) { - lineType = options->Get(v8::String::NewSymbol("lineType"))->Uint32Value(); + if (options->Has(NanNew("lineType"))) { + lineType = options->Get(NanNew("lineType"))->Uint32Value(); } - if (options->Has(v8::String::New("shift"))) { - shift = options->Get(v8::String::NewSymbol("shift"))->Uint32Value(); + if (options->Has(NanNew("shift"))) { + shift = options->Get(NanNew("shift"))->Uint32Value(); } - if (options->Has(v8::String::New("color"))) { - Local objColor = options->Get(v8::String::NewSymbol("color"))->ToObject(); + if (options->Has(NanNew("color"))) { + Local objColor = options->Get(NanNew("color"))->ToObject(); color = setColor(objColor); } } else { @@ -637,7 +613,7 @@ NAN_METHOD(Matrix::Ellipse){ } cv::ellipse(self->mat, cv::Point(x, y), cv::Size(width, height), angle, startAngle, endAngle, color, thickness, lineType, shift); - NanReturnValue(v8::Null()); + NanReturnNull(); } @@ -671,7 +647,7 @@ NAN_METHOD(Matrix::Rectangle) { cv::rectangle(self->mat, cv::Point(x, y), cv::Point(x+width, y+height), color, thickness); } - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Line) { @@ -703,9 +679,10 @@ NAN_METHOD(Matrix::Line) { cv::line(self->mat, cv::Point(x1, y1), cv::Point(x2, y2), color, thickness); } - NanReturnValue(v8::Null()); + NanReturnNull(); } + NAN_METHOD(Matrix::Save) { SETUP_FUNCTION(Matrix) @@ -714,14 +691,16 @@ NAN_METHOD(Matrix::Save) { } if (!args[0]->IsString()) - return v8::ThrowException(v8::Exception::TypeError(String::New("filename required"))); + NanThrowTypeError("filename required"); - String::AsciiValue filename(args[0]); + NanAsciiString filename(args[0]); int res = cv::imwrite(*filename, self->mat); - NanReturnValue(Number::New(res)); + NanReturnValue(NanNew(res)); } +//FIXME:All this is for async save, see here for nan example: https://github.com/rvagg/nan/blob/c579ae858ae3208d7e702e8400042ba9d48fa64b/examples/async_pi_estimate/async.cc +/* struct save_baton_t { Matrix *mm; Persistent cb; @@ -730,6 +709,7 @@ struct save_baton_t { uv_work_t request; }; + void DoSaveAsync(uv_work_t *req); void AfterSaveAsync(uv_work_t *req); @@ -737,21 +717,22 @@ NAN_METHOD(Matrix::SaveAsync){ SETUP_FUNCTION(Matrix) if (!args[0]->IsString()) - return v8::ThrowException(v8::Exception::TypeError(String::New("filename required"))); + NanThrowTypeError("filename required"); - String::AsciiValue filename(args[0]); + NanAsciiString filename(args[0]); REQ_FUN_ARG(1, cb); save_baton_t *baton = new save_baton_t(); baton->mm = self; - baton->cb = Persistent::New(cb); + baton->cb = new NanCallback(cb.As()); //Persistent::New(cb);//NanCallback *callback = baton->filename = *filename; baton->request.data = baton; - uv_queue_work(uv_default_loop(), &baton->request, DoSaveAsync, (uv_after_work_cb)AfterSaveAsync); - - return Undefined(); + //uv_queue_work(uv_default_loop(), &baton->request, DoSaveAsync, (uv_after_work_cb)AfterSaveAsync); + //TODO: swtich to NanAsyncQueueWorker( + + NanReturnUndefined(); } @@ -763,13 +744,13 @@ void DoSaveAsync(uv_work_t *req) { } void AfterSaveAsync(uv_work_t *req) { - HandleScope scope; + NanScope(); save_baton_t *baton = static_cast(req->data); Local argv[2]; // (err, result) - argv[0] = Local::New(Null()); - argv[1] = Number::New(baton->res); + argv[0] = NanNull();//Local::New(Null()); + argv[1] = NanNew(baton->res); TryCatch try_catch; @@ -782,16 +763,15 @@ void AfterSaveAsync(uv_work_t *req) { baton->cb.Dispose(); delete baton; -} - +}*/ NAN_METHOD(Matrix::Eye){ - HandleScope scope; + NanScope(); int w = args[0]->Uint32Value(); int h = args[1]->Uint32Value(); - Local im_h = Matrix::constructor->GetFunction()->NewInstance(); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(im_h); cv::Mat mat = cv::Mat::eye(w, h, CV_64FC1); @@ -801,11 +781,11 @@ NAN_METHOD(Matrix::Eye){ NAN_METHOD(Matrix::ConvertGrayscale) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); if(self->mat.channels() != 3) - return v8::ThrowException(String::New("Image is no 3-channel")); + NanThrowError("Image is no 3-channel"); cv::Mat gray; @@ -813,30 +793,30 @@ NAN_METHOD(Matrix::ConvertGrayscale) { gray.copyTo(self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::ConvertHSVscale) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); if(self->mat.channels() != 3) - return v8::ThrowException(String::New("Image is no 3-channel")); + NanThrowError("Image is no 3-channel"); cv::Mat hsv; cv::cvtColor(self->mat, hsv, CV_BGR2HSV); hsv.copyTo(self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::GaussianBlur) { - HandleScope scope; + NanScope(); cv::Size ksize; - cv::Mat blurred; + cv::Mat blurred; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -845,16 +825,14 @@ NAN_METHOD(Matrix::GaussianBlur) { } else { if(!args[0]->IsArray()) { - return ThrowException(Exception::TypeError(String::New( - "'ksize' argument must be a 2 double array"))); + NanThrowTypeError("'ksize' argument must be a 2 double array"); } Local array = args[0]->ToObject(); // TODO: Length check Local x = array->Get(0); Local y = array->Get(1); if(!x->IsNumber() || !y->IsNumber()) { - return ThrowException(Exception::TypeError(String::New( - "'ksize' argument must be a 2 double array"))); + NanThrowTypeError("'ksize' argument must be a 2 double array"); } ksize = cv::Size(x->NumberValue(), y->NumberValue()); } @@ -862,12 +840,12 @@ NAN_METHOD(Matrix::GaussianBlur) { cv::GaussianBlur(self->mat, blurred, ksize, 0); blurred.copyTo(self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } -NAN_METHOD(Matrix::MedianBlur(const v8::Arguments &args) { - HandleScope scope; +NAN_METHOD(Matrix::MedianBlur) { + NanScope(); cv::Mat blurred; int ksize = 3; Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -875,23 +853,21 @@ NAN_METHOD(Matrix::MedianBlur(const v8::Arguments &args) { if (args[0]->IsNumber()) { ksize = args[0]->IntegerValue(); if ((ksize % 2) == 0) { - return ThrowException(Exception::TypeError(String::New( - "'ksize' argument must be a positive odd integer"))); + NanThrowTypeError("'ksize' argument must be a positive odd integer"); } } else { - return ThrowException(Exception::TypeError(String::New( - "'ksize' argument must be a positive odd integer"))); + NanThrowTypeError("'ksize' argument must be a positive odd integer"); } cv::medianBlur(self->mat, blurred, ksize); blurred.copyTo(self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } -NAN_METHOD(Matrix::BilateralFilter(const v8::Arguments &args) { - HandleScope scope; +NAN_METHOD(Matrix::BilateralFilter) { + NanScope(); cv::Mat filtered; int d = 15; double sigmaColor = 80; @@ -902,8 +878,7 @@ NAN_METHOD(Matrix::BilateralFilter(const v8::Arguments &args) { if (args.Length() != 0) { if (args.Length() < 3 || args.Length() > 4) { - return ThrowException(Exception::TypeError(String::New( - "BilateralFilter takes 0, 3, or 4 arguments"))); + NanThrowTypeError("BilateralFilter takes 0, 3, or 4 arguments"); } else { d = args[0]->IntegerValue(); sigmaColor = args[1]->NumberValue(); @@ -917,16 +892,16 @@ NAN_METHOD(Matrix::BilateralFilter(const v8::Arguments &args) { cv::bilateralFilter(self->mat, filtered, d, sigmaColor, sigmaSpace, borderType); filtered.copyTo(self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Copy) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); - Local img_to_return = Matrix::constructor->GetFunction()->NewInstance(); + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(img_to_return); self->mat.copyTo(img->mat); @@ -935,18 +910,17 @@ NAN_METHOD(Matrix::Copy) { NAN_METHOD(Matrix::Flip) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); if ( args.Length() < 1 || !args[0]->IsInt32() ) { - return v8::ThrowException(Exception::TypeError(String::New( - "Flip requires an integer flipCode argument (0 = X axis, positive = Y axis, negative = both axis)"))); + NanThrowTypeError("Flip requires an integer flipCode argument (0 = X axis, positive = Y axis, negative = both axis)"); } int flipCode = args[0]->ToInt32()->Value(); - Local img_to_return = Matrix::constructor->GetFunction()->NewInstance(); + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(img_to_return); cv::flip(self->mat, img->mat, flipCode); @@ -955,17 +929,16 @@ NAN_METHOD(Matrix::Flip) { NAN_METHOD(Matrix::ROI) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); if ( args.Length() != 4 ) { - return v8::ThrowException(Exception::TypeError(String::New( - "ROI requires x,y,w,h arguments"))); + NanThrowTypeError("ROI requires x,y,w,h arguments"); } // although it's an image to return, it is in fact a pointer to ROI of parent matrix - Local img_to_return = Matrix::constructor->GetFunction()->NewInstance(); + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(img_to_return); int x = args[0]->IntegerValue(); @@ -981,25 +954,22 @@ NAN_METHOD(Matrix::ROI) { NAN_METHOD(Matrix::Ptr) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); int line = args[0]->Uint32Value(); - char* data = self->mat.ptr(line); //uchar* data = self->mat.data; /* char *mydata = "Random raw data\0"; */ - node::Buffer *return_buffer = Buffer::New((char *)data, self->mat.step); - NanReturnValue( return_buffer->handle_ ); - -// return Undefined(); + Local return_buffer = NanNewBufferHandle((char*)data, self->mat.step); + NanReturnValue( return_buffer ); +// NanReturnUndefined(); } - NAN_METHOD(Matrix::AbsDiff) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1008,11 +978,11 @@ NAN_METHOD(Matrix::AbsDiff) { cv::absdiff(src1->mat, src2->mat, self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::AddWeighted) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1026,11 +996,11 @@ NAN_METHOD(Matrix::AddWeighted) { cv::addWeighted(src1->mat, alpha, src2->mat, beta, gamma, self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BitwiseXor) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1039,11 +1009,11 @@ NAN_METHOD(Matrix::BitwiseXor) { cv::bitwise_xor(src1->mat, src2->mat, self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BitwiseNot) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1051,11 +1021,11 @@ NAN_METHOD(Matrix::BitwiseNot) { cv::bitwise_not(self->mat, dst->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::BitwiseAnd) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); @@ -1064,29 +1034,29 @@ NAN_METHOD(Matrix::BitwiseAnd) { cv::bitwise_and(src1->mat, src2->mat, self->mat); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::CountNonZero) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); double count = (double)cv::countNonZero(self->mat); - NanReturnValue(v8::Number::New(count)); + NanReturnValue(NanNew(count)); } /*NAN_METHOD(Matrix::Split) { - HandleScope scope; + NanScope(); //Matrix *self = ObjectWrap::Unwrap(args.This()); - NanReturnValue(v8::Null()); + NanReturnNull(); }*/ NAN_METHOD(Matrix::Canny) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); int lowThresh = args[0]->NumberValue(); @@ -1094,39 +1064,39 @@ NAN_METHOD(Matrix::Canny) { cv::Canny(self->mat, self->mat, lowThresh, highThresh); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Dilate) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); int niters = args[0]->NumberValue(); cv::dilate(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::Erode) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); int niters = args[0]->NumberValue(); cv::erode(self->mat, self->mat, cv::Mat(), cv::Point(-1, -1), niters); - NanReturnValue(v8::Null()); + NanReturnNull(); } NAN_METHOD(Matrix::FindContours) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); - Local conts_to_return= Contour::constructor->GetFunction()->NewInstance(); + Local conts_to_return= NanNew(Contour::constructor)->GetFunction()->NewInstance(); Contour *contours = ObjectWrap::Unwrap(conts_to_return); cv::findContours(self->mat, contours->contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); @@ -1137,7 +1107,7 @@ NAN_METHOD(Matrix::FindContours) { NAN_METHOD(Matrix::DrawContour) { - HandleScope scope; + NanScope(); Matrix *self = ObjectWrap::Unwrap(args.This()); Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); @@ -1154,777 +1124,7 @@ NAN_METHOD(Matrix::DrawContour) { cv::drawContours(self->mat, cont->contours, pos, color, thickness); - return Undefined(); + NanReturnUndefined(); } -NAN_METHOD(Matrix::DrawAllContours) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); - - cv::Scalar color(0, 0, 255); - - if(args[1]->IsArray()) { - Local objColor = args[1]->ToObject(); - color = setColor(objColor); - } - - int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue(); - - cv::drawContours(self->mat, cont->contours, -1, color, thickness); - - - return Undefined(); -} - -NAN_METHOD(Matrix::GoodFeaturesToTrack) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - std::vector corners; - - cv::Mat gray; - - cvtColor(self->mat, gray, CV_BGR2GRAY); - equalizeHist(gray, gray); - - cv::goodFeaturesToTrack(gray, corners, 500, 0.01, 10); - - v8::Local arr = v8::Array::New(corners.size()); - - - for (unsigned int i=0; i pt = v8::Array::New(2); - pt->Set(0, Number::New((double) corners[i].x)); - pt->Set(1, Number::New((double) corners[i].y)); - arr->Set(i, pt); - } - - NanReturnValue(arr); - -} - -NAN_METHOD(Matrix::HoughLinesP) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - double rho = args.Length() < 1 ? 1 : args[0]->NumberValue(); - double theta = args.Length() < 2 ? CV_PI/180 : args[1]->NumberValue(); - int threshold = args.Length() < 3 ? 80 : args[2]->Uint32Value(); - double minLineLength = args.Length() < 4 ? 30 : args[3]->NumberValue(); - double maxLineGap = args.Length() < 5 ? 10 : args[4]->NumberValue(); - std::vector lines; - - cv::Mat gray; - - - equalizeHist(self->mat, gray); - // cv::Canny(gray, gray, 50, 200, 3); - cv::HoughLinesP(gray, lines, rho, theta, threshold, minLineLength, maxLineGap); - - v8::Local arr = v8::Array::New(lines.size()); - - - for (unsigned int i=0; i pt = v8::Array::New(4); - pt->Set(0, Number::New((double) lines[i][0])); - pt->Set(1, Number::New((double) lines[i][1])); - pt->Set(2, Number::New((double) lines[i][2])); - pt->Set(3, Number::New((double) lines[i][3])); - arr->Set(i, pt); - } - - NanReturnValue(arr); - -} - -cv::Scalar setColor(Local objColor) { - - Local valB = objColor->Get(0); - Local valG = objColor->Get(1); - Local valR = objColor->Get(2); - - cv::Scalar color = cv::Scalar(valB->IntegerValue(), valG->IntegerValue(), valR->IntegerValue()); - return color; - - -} - -cv::Point setPoint(Local objPoint) { - return cv::Point( objPoint->Get(0)->IntegerValue(), objPoint->Get(1)->IntegerValue() ); -} - -cv::Rect* setRect(Local objRect) { - - if(!objRect->IsArray() || !objRect->Get(0)->IsArray() || !objRect->Get(0)->IsArray() ){ - printf("error"); - return 0; - }; - - Local point = objRect->Get(0)->ToObject(); - Local size = objRect->Get(1)->ToObject(); - cv::Rect ret; - - ret.x = point->Get(0)->IntegerValue(); - ret.y = point->Get(1)->IntegerValue(); - ret.width = size->Get(0)->IntegerValue(); - ret.height = size->Get(1)->IntegerValue(); - - return (cv::Rect*) &ret; -} - - -NAN_METHOD(Matrix::Resize){ - HandleScope scope; - - int x = args[0]->Uint32Value(); - int y = args[1]->Uint32Value(); - /* - CV_INTER_NN =0, - CV_INTER_LINEAR =1, - CV_INTER_CUBIC =2, - CV_INTER_AREA =3, - CV_INTER_LANCZOS4 =4 - */ - int interpolation = (args.Length() < 3) ? (int)cv::INTER_LINEAR : args[2]->Uint32Value(); - - Matrix *self = ObjectWrap::Unwrap(args.This()); - cv::Mat res = cv::Mat(x, y, CV_32FC3); - cv::resize(self->mat, res, cv::Size(x, y), 0, 0, interpolation); - ~self->mat; - self->mat = res; - - - NanReturnUndefined(); -} - - -NAN_METHOD(Matrix::Rotate){ - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - cv::Mat rotMatrix(2, 3, CV_32FC1); - cv::Mat res; - - float angle = args[0]->ToNumber()->Value(); - - // Modification by SergeMv - //------------- - // If you provide only the angle argument and the angle is multiple of 90, then - // we do a fast thing - bool rightOrStraight = (ceil(angle) == angle) && (!((int)angle % 90)) - && (args.Length() == 1); - if (rightOrStraight) { - int angle2 = ((int)angle) % 360; - if (!angle2) { NanReturnUndefined(); } - if (angle2 < 0) { angle2 += 360; } - // See if we do right angle rotation, we transpose the matrix: - if (angle2 % 180) { - cv::transpose(self->mat, res); - ~self->mat; - self->mat = res; - } - // Now flip the image - int mode = -1; // flip around both axes - // If counterclockwise, flip around the x-axis - if (angle2 == 90) { mode = 0; } - // If clockwise, flip around the y-axis - if (angle2 == 270) { mode = 1; } - cv::flip(self->mat, self->mat, mode); - - NanReturnUndefined(); - } - //------------- - - int x = args[1]->IsUndefined() ? round(self->mat.size().width / 2) : args[1]->Uint32Value(); - int y = args[1]->IsUndefined() ? round(self->mat.size().height / 2) : args[2]->Uint32Value(); - - cv::Point center = cv::Point(x,y); - rotMatrix = getRotationMatrix2D(center, angle, 1.0); - - cv::warpAffine(self->mat, res, rotMatrix, self->mat.size()); - ~self->mat; - self->mat = res; - - NanReturnUndefined(); -} - -NAN_METHOD(Matrix::PyrDown){ - SETUP_FUNCTION(Matrix) - - cv::pyrDown(self->mat, self->mat); - NanReturnValue(v8::Undefined()); -} - -NAN_METHOD(Matrix::PyrUp){ - SETUP_FUNCTION(Matrix) - - cv::pyrUp(self->mat, self->mat); - NanReturnValue(v8::Undefined()); -} - -NAN_METHOD(Matrix::inRange) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - /*if(self->mat.channels() != 3) - return v8::ThrowException(String::New("Image is no 3-channel"));*/ - - if(args[0]->IsArray() && args[1]->IsArray()) { - Local args_lowerb = args[0]->ToObject(); - Local args_upperb = args[1]->ToObject(); - - cv::Scalar lowerb(0, 0, 0); - cv::Scalar upperb(0, 0, 0); - - lowerb = setColor(args_lowerb); - upperb = setColor(args_upperb); - - cv::Mat mask; - cv::inRange(self->mat, lowerb, upperb, mask); - mask.copyTo(self->mat); - } - - - NanReturnValue(v8::Null()); -} - -NAN_METHOD(Matrix::AdjustROI) { - SETUP_FUNCTION(Matrix) - int dtop = args[0]->Uint32Value(); - int dbottom = args[1]->Uint32Value(); - int dleft = args[2]->Uint32Value(); - int dright = args[3]->Uint32Value(); - - self->mat.adjustROI(dtop, dbottom, dleft, dright); - - NanReturnValue(v8::Null()); - -} - -NAN_METHOD(Matrix::LocateROI) { - SETUP_FUNCTION(Matrix) - - cv::Size wholeSize; - cv::Point ofs; - - self->mat.locateROI(wholeSize, ofs); - - v8::Local arr = v8::Array::New(4); - arr->Set(0, Number::New(wholeSize.width)); - arr->Set(1, Number::New(wholeSize.height)); - arr->Set(2, Number::New(ofs.x)); - arr->Set(3, Number::New(ofs.y)); - - NanReturnValue(arr); -} - -NAN_METHOD(Matrix::Threshold) { - SETUP_FUNCTION(Matrix) - - double threshold = args[0]->NumberValue(); - double maxVal = args[1]->NumberValue(); - - int typ = cv::THRESH_BINARY; - if (args.Length() == 3){ -// typ = args[2]->IntegerValue(); - String::AsciiValue typstr(args[2]); - if (strcmp(*typstr, "Binary") == 0){ - typ=0; - } - if (strcmp(*typstr, "Binary Inverted") == 0){ - typ=1; - } - if (strcmp(*typstr, "Threshold Truncated") == 0){ - typ=2; - } - if (strcmp(*typstr, "Threshold to Zero") == 0){ - typ=3; - } - if (strcmp(*typstr, "Threshold to Zero Inverted") == 0){ - typ=4; - } - } - - - - Local img_to_return = Matrix::constructor->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); - self->mat.copyTo(img->mat); - - cv::threshold(self->mat, img->mat, threshold, maxVal, typ); - - NanReturnValue(img_to_return); -} - -NAN_METHOD(Matrix::AdaptiveThreshold) { - SETUP_FUNCTION(Matrix) - - double maxVal = args[0]->NumberValue(); - double adaptiveMethod = args[1]->NumberValue(); - double thresholdType = args[2]->NumberValue(); - double blockSize = args[3]->NumberValue(); - double C = args[4]->NumberValue(); - - Local img_to_return = Matrix::constructor->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(img_to_return); - self->mat.copyTo(img->mat); - - cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C); - - NanReturnValue(img_to_return); -} - -NAN_METHOD(Matrix::MeanStdDev) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - - Local mean = Matrix::constructor->GetFunction()->NewInstance(); - Matrix *m_mean = ObjectWrap::Unwrap(mean); - Local stddev = Matrix::constructor->GetFunction()->NewInstance(); - Matrix *m_stddev = ObjectWrap::Unwrap(stddev); - - cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat); - - Local data = Object::New(); - data->Set(String::NewSymbol("mean"), mean); - data->Set(String::NewSymbol("stddev"), stddev); - NanReturnValue(data); -} - - -// @author SergeMv -// Copies our (small) image into a ROI of another (big) image -// @param Object another image (destination) -// @param Number Destination x (where our image is to be copied) -// @param Number Destination y (where our image is to be copied) -// Example: smallImg.copyTo(bigImg, 50, 50); -// Note, x,y and width and height of our image must be so that -// our.width + x <= destination.width (and the same for y and height) -// both x and y must be >= 0 -NAN_METHOD(Matrix::CopyTo) { - HandleScope scope; - - Matrix * self = ObjectWrap::Unwrap(args.This()); - int width = self->mat.size().width; - int height = self->mat.size().height; - - // param 0 - destination image: - Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); - // param 1 - x coord of the destination - int x = args[1]->IntegerValue(); - // param 2 - y coord of the destination - int y = args[2]->IntegerValue(); - - cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height)); - self->mat.copyTo(dstROI); - - NanReturnUndefined(); -} - - - -// @author SergeMv -// Does in-place color transformation -// img.cvtColor('CV_BGR2YCrCb'); -NAN_METHOD(Matrix::CvtColor) { - HandleScope scope; - - Matrix * self = ObjectWrap::Unwrap(args.This()); - - v8::String::Utf8Value str (args[0]->ToString()); - std::string str2 = std::string(*str); - const char * sTransform = (const char *) str2.c_str(); - int iTransform; - // - if (!strcmp(sTransform, "CV_BGR2GRAY")) { iTransform = CV_BGR2GRAY; } - else if (!strcmp(sTransform, "CV_GRAY2BGR")) { iTransform = CV_GRAY2BGR; } - // - else if (!strcmp(sTransform, "CV_BGR2XYZ")) { iTransform = CV_BGR2XYZ; } - else if (!strcmp(sTransform, "CV_XYZ2BGR")) { iTransform = CV_XYZ2BGR; } - // - else if (!strcmp(sTransform, "CV_BGR2YCrCb")) { iTransform = CV_BGR2YCrCb; } - else if (!strcmp(sTransform, "CV_YCrCb2BGR")) { iTransform = CV_YCrCb2BGR; } - // - else if (!strcmp(sTransform, "CV_BGR2HSV")) { iTransform = CV_BGR2HSV; } - else if (!strcmp(sTransform, "CV_HSV2BGR")) { iTransform = CV_HSV2BGR; } - // - else if (!strcmp(sTransform, "CV_BGR2HLS")) { iTransform = CV_BGR2HLS; } - else if (!strcmp(sTransform, "CV_HLS2BGR")) { iTransform = CV_HLS2BGR; } - // - else if (!strcmp(sTransform, "CV_BGR2Lab")) { iTransform = CV_BGR2Lab; } - else if (!strcmp(sTransform, "CV_Lab2BGR")) { iTransform = CV_Lab2BGR; } - // - else if (!strcmp(sTransform, "CV_BGR2Luv")) { iTransform = CV_BGR2Luv; } - else if (!strcmp(sTransform, "CV_Luv2BGR")) { iTransform = CV_Luv2BGR; } - // - else if (!strcmp(sTransform, "CV_BayerBG2BGR")) { iTransform = CV_BayerBG2BGR; } - else if (!strcmp(sTransform, "CV_BayerGB2BGR")) { iTransform = CV_BayerGB2BGR; } - else if (!strcmp(sTransform, "CV_BayerRG2BGR")) { iTransform = CV_BayerRG2BGR; } - else if (!strcmp(sTransform, "CV_BayerGR2BGR")) { iTransform = CV_BayerGR2BGR; } - else { - iTransform = 0; // to avoid compiler warning - return v8::ThrowException(Exception::TypeError(String::New( - "Conversion code is unsupported"))); - } - - cv::cvtColor(self->mat, self->mat, iTransform); - - NanReturnUndefined(); -} - - -// @author SergeMv -// arrChannels = img.split(); -NAN_METHOD(Matrix::Split) { - HandleScope scope; - - Matrix * self = ObjectWrap::Unwrap(args.This()); - - vector channels; - cv::split(self->mat, channels); - unsigned int size = channels.size(); - v8::Local arrChannels = v8::Array::New(size); - for (unsigned int i = 0; i < size; i++) { - Local matObject = Matrix::constructor->GetFunction()->NewInstance(); - Matrix * m = ObjectWrap::Unwrap(matObject); - m->mat = channels[i]; - arrChannels->Set(i, matObject); - } - - NanReturnValue(arrChannels); -} - - -// @author SergeMv -// img.merge(arrChannels); -NAN_METHOD(Matrix::Merge) { - HandleScope scope; - - Matrix * self = ObjectWrap::Unwrap(args.This()); - - if (!args[0]->IsArray()) { - return v8::ThrowException(Exception::TypeError(String::New( - "The argument must be an array"))); - } - v8::Handle jsChannels = v8::Handle::Cast(args[0]); - - unsigned int L = jsChannels->Length(); - vector vChannels(L); - for (unsigned int i = 0; i < L; i++) { - Matrix * matObject = ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); - vChannels[i] = matObject->mat; - } - cv::merge(vChannels, self->mat); - - NanReturnUndefined(); -} - - -// @author SergeMv -// Equalizes histogram -// img.equalizeHist() -NAN_METHOD(Matrix::EqualizeHist) { - HandleScope scope; - - Matrix * self = ObjectWrap::Unwrap(args.This()); - - cv::equalizeHist(self->mat, self->mat); - - NanReturnUndefined(); -} - -NAN_METHOD(Matrix::FloodFill(const Arguments& args){ - SETUP_FUNCTION(Matrix) - //obj->Get(v8::String::NewSymbol("x")) - //int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int) - - - /* mat.floodFill( { seedPoint: [1,1] , - newColor: [255,0,0] , - rect:[[0,2],[30,40]] , - loDiff : [8,90,60], - upDiff:[10,100,70] - } );*/ - - - if(args.Length() < 1 || !args[0]->IsObject()) { - //error - } - - - Local obj = args[0]->ToObject(); - - int ret = cv::floodFill(self->mat, setPoint(obj->Get(v8::String::NewSymbol("seedPoint"))->ToObject()) - , setColor(obj->Get(v8::String::NewSymbol("newColor"))->ToObject()) - , obj->Get(v8::String::NewSymbol("rect"))->IsUndefined() ? 0 : setRect(obj->Get(v8::String::NewSymbol("rect"))->ToObject()) - , setColor(obj->Get(v8::String::NewSymbol("loDiff"))->ToObject()) - , setColor(obj->Get(v8::String::NewSymbol("upDiff"))->ToObject()) - , 4 ); - - - NanReturnValue(Number::New( ret )); -} - - -// @author ytham -// Match Template filter -// Usage: output = input.matchTemplate("templateFileString", method); -NAN_METHOD(Matrix::MatchTemplate) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - - v8::String::Utf8Value args0(args[0]->ToString()); - std::string filename = std::string(*args0); - cv::Mat templ; - templ = cv::imread(filename, CV_8S); - - Local out = Matrix::constructor->GetFunction()->NewInstance(); - Matrix *m_out = ObjectWrap::Unwrap(out); - int cols = self->mat.cols - templ.cols + 1; - int rows = self->mat.rows - templ.rows + 1; - m_out->mat.create(cols, rows, CV_32FC1); - - /* - TM_SQDIFF =0 - TM_SQDIFF_NORMED =1 - TM_CCORR =2 - TM_CCORR_NORMED =3 - TM_CCOEFF =4 - TM_CCOEFF_NORMED =5 - */ - int method = (args.Length() < 2) ? (int)cv::TM_CCORR_NORMED : args[1]->Uint32Value(); - - cv::matchTemplate(self->mat, templ, m_out->mat, method); - - double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; - cv::minMaxLoc(m_out->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); - - NanReturnValue(out); -} - - -// @author ytham -// Min/Max location -NAN_METHOD(Matrix::MinMaxLoc) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - - double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; - - cv::minMaxLoc(self->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); - - Local v_minVal = v8::Number::New(minVal); - Local v_maxVal = v8::Number::New(maxVal); - Local v_minLoc_x = v8::Number::New(minLoc.x); - Local v_minLoc_y = v8::Number::New(minLoc.y); - Local v_maxLoc_x = v8::Number::New(maxLoc.x); - Local v_maxLoc_y = v8::Number::New(maxLoc.y); - - Local o_minLoc = Object::New(); - o_minLoc->Set(String::NewSymbol("x"), v_minLoc_x); - o_minLoc->Set(String::NewSymbol("y"), v_minLoc_y); - - Local o_maxLoc = Object::New(); - o_maxLoc->Set(String::NewSymbol("x"), v_maxLoc_x); - o_maxLoc->Set(String::NewSymbol("y"), v_maxLoc_y); - - // Output result object - Local result = Object::New(); - result->Set(String::NewSymbol("minVal"), v_minVal); - result->Set(String::NewSymbol("maxVal"), v_maxVal); - result->Set(String::NewSymbol("minLoc"), o_minLoc); - result->Set(String::NewSymbol("maxLoc"), o_maxLoc); - - NanReturnValue(result); -} - - -// @author ytham -// Pushes some matrix (argument) the back of a matrix (self) -NAN_METHOD(Matrix::PushBack) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - - Matrix *m_input = ObjectWrap::Unwrap(args[0]->ToObject()); - - self->mat.push_back(m_input->mat); - - NanReturnValue(args.This()); -} - -NAN_METHOD(Matrix::PutText) { - HandleScope scope; - - Matrix *self = ObjectWrap::Unwrap(args.This()); - - v8::String::AsciiValue textString(args[0]); - char *text = (char *) malloc(textString.length() + 1); - strcpy(text, *textString); - - int x = args[1]->IntegerValue(); - int y = args[2]->IntegerValue(); - - v8::String::AsciiValue fontString(args[3]); - char *font = (char *) malloc(fontString.length() + 1); - strcpy(font, *fontString); - int constFont = cv::FONT_HERSHEY_SIMPLEX; - - if (!strcmp(font, "HERSEY_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SIMPLEX; } - else if (!strcmp(font, "HERSEY_PLAIN")) { constFont = cv::FONT_HERSHEY_PLAIN; } - else if (!strcmp(font, "HERSEY_DUPLEX")) { constFont = cv::FONT_HERSHEY_DUPLEX; } - else if (!strcmp(font, "HERSEY_COMPLEX")) { constFont = cv::FONT_HERSHEY_COMPLEX; } - else if (!strcmp(font, "HERSEY_TRIPLEX")) { constFont = cv::FONT_HERSHEY_TRIPLEX; } - else if (!strcmp(font, "HERSEY_COMPLEX_SMALL")) { constFont = cv::FONT_HERSHEY_COMPLEX_SMALL; } - else if (!strcmp(font, "HERSEY_SCRIPT_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_SIMPLEX; } - else if (!strcmp(font, "HERSEY_SCRIPT_COMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_COMPLEX; } - else if (!strcmp(font, "HERSEY_SCRIPT_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_SIMPLEX; } - - cv::Scalar color(0, 0, 255); - - if(args[4]->IsArray()) { - Local objColor = args[4]->ToObject(); - color = setColor(objColor); - } - - double scale = args.Length() < 6 ? 1 : args[5]->NumberValue(); - - cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, 2); - - NanReturnUndefined(); -} - -NAN_METHOD(Matrix::GetPerspectiveTransform) { - HandleScope scope; - - // extract quad args - Local srcArray = args[0]->ToObject(); - Local tgtArray = args[1]->ToObject(); - - std::vector src_corners(4); - std::vector tgt_corners(4); - for (unsigned int i = 0; i < 4; i++) { - src_corners[i] = cvPoint(srcArray->Get(i*2)->IntegerValue(),srcArray->Get(i*2+1)->IntegerValue()); - tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue(),tgtArray->Get(i*2+1)->IntegerValue()); - } - - Local xfrm = Matrix::constructor->GetFunction()->NewInstance(); - Matrix *xfrmmat = ObjectWrap::Unwrap(xfrm); - xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners); - - NanReturnValue(xfrm); -} - -NAN_METHOD(Matrix::WarpPerspective) { - SETUP_FUNCTION(Matrix) - - Matrix *xfrm = ObjectWrap::Unwrap(args[0]->ToObject()); - - int width = args[1]->IntegerValue(); - int height = args[2]->IntegerValue(); - - int flags = cv::INTER_LINEAR; - int borderMode = cv::BORDER_REPLICATE; - - cv::Scalar borderColor(0, 0, 255); - - if(args[3]->IsArray()) { - Local objColor = args[3]->ToObject(); - borderColor = setColor(objColor); - } - - cv::Mat res = cv::Mat(width, height, CV_32FC3); - - cv::warpPerspective(self->mat, res, xfrm->mat, cv::Size(width, height), flags, borderMode, borderColor); - - ~self->mat; - self->mat = res; - - NanReturnValue(v8::Null()); -} - -NAN_METHOD(Matrix::CopyWithMask) { - SETUP_FUNCTION(Matrix) - - // param 0 - destination image: - Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); - // param 1 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); - - self->mat.copyTo(dest->mat,mask->mat); - - NanReturnUndefined(); -} - - -NAN_METHOD(Matrix::SetWithMask) { - SETUP_FUNCTION(Matrix) - - // param 0 - target value: - Local valArray = args[0]->ToObject(); - cv::Scalar newvals; - newvals.val[0] = valArray->Get(0)->NumberValue(); - newvals.val[1] = valArray->Get(1)->NumberValue(); - newvals.val[2] = valArray->Get(2)->NumberValue(); - - // param 1 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); - - self->mat.setTo(newvals,mask->mat); - - NanReturnUndefined(); -} - -NAN_METHOD(Matrix::MeanWithMask) { - SETUP_FUNCTION(Matrix) - - // param 0 - mask. same size as src and dest - Matrix *mask = ObjectWrap::Unwrap(args[0]->ToObject()); - - cv::Scalar means = cv::mean(self->mat, mask->mat); - v8::Local arr = v8::Array::New(3); - arr->Set(0, Number::New( means[0] )); - arr->Set(1, Number::New( means[1] )); - arr->Set(2, Number::New( means[2] )); - - NanReturnValue(arr); -} - -NAN_METHOD(Matrix::Shift){ - SETUP_FUNCTION(Matrix) - - cv::Mat res; - - double tx = args[0]->NumberValue(); - double ty = args[1]->NumberValue(); - - // get the integer values of args - cv::Point2i deltai(ceil(tx), ceil(ty)); - - int fill=cv::BORDER_REPLICATE; - cv::Scalar value=cv::Scalar(0,0,0,0); - - // INTEGER SHIFT - // first create a border around the parts of the Mat that will be exposed - int t = 0, b = 0, l = 0, r = 0; - if (deltai.x > 0) l = deltai.x; - if (deltai.x < 0) r = -deltai.x; - if (deltai.y > 0) t = deltai.y; - if (deltai.y < 0) b = -deltai.y; - cv::Mat padded; - cv::copyMakeBorder(self->mat, padded, t, b, l, r, fill, value); - - // construct the region of interest around the new matrix - cv::Rect roi = cv::Rect(std::max(-deltai.x,0),std::max(-deltai.y,0),0,0) + self->mat.size(); - res = padded(roi); - ~self->mat; - self->mat = res; - - NanReturnUndefined(); -} diff --git a/src/OpenCV.cc b/src/OpenCV.cc index 7dd7fe7..bb8635f 100755 --- a/src/OpenCV.cc +++ b/src/OpenCV.cc @@ -1,30 +1,29 @@ #include "OpenCV.h" #include "Matrix.h" +#include void OpenCV::Init(Handle target) { - HandleScope scope; - + NanScope(); // Version string. char out [21]; int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION); - target->Set(String::NewSymbol("version"), String::New(out, n)); + target->Set(NanNew("version"), NanNew(out, n)); NODE_SET_METHOD(target, "readImage", ReadImage); } - -Handle -OpenCV::ReadImage() { - HandleScope scope; +NAN_METHOD(OpenCV::ReadImage) { + NanEscapableScope(); try{ - Local im_h = Matrix::constructor->GetFunction()->NewInstance(); + Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(im_h); + cv::Mat mat; REQ_FUN_ARG(1, cb); @@ -38,7 +37,7 @@ OpenCV::ReadImage() { } else if (args[0]->IsString()) { - std::string filename = std::string(*v8::String::AsciiValue(args[0]->ToString())); + std::string filename = std::string(*NanAsciiString(args[0]->ToString())); mat = cv::imread(filename); } else if (Buffer::HasInstance(args[0])){ @@ -49,7 +48,7 @@ OpenCV::ReadImage() { mat = cv::imdecode(*mbuf, -1); if (mat.empty()){ - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Error loading file"))); + NanThrowTypeError("Error loading file"); } } @@ -57,23 +56,21 @@ OpenCV::ReadImage() { Local argv[2]; - argv[0] = Local::New(Null()); + argv[0] = NanNull(); argv[1] = im_h; TryCatch try_catch; - cb->Call(Context::GetCurrent()->Global(), 2, argv); + cb->Call(NanGetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - return Undefined(); + NanReturnUndefined(); } catch( cv::Exception& e ){ const char* err_msg = e.what(); - return v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg))); + NanThrowError(err_msg); } }; - - diff --git a/src/OpenCV.h b/src/OpenCV.h index d640be1..ea1ca83 100755 --- a/src/OpenCV.h +++ b/src/OpenCV.h @@ -16,8 +16,7 @@ using namespace node; #define REQ_FUN_ARG(I, VAR) \ if (args.Length() <= (I) || !args[I]->IsFunction()) \ - return v8::ThrowException(v8::Exception::TypeError( \ - String::New("Argument " #I " must be a function"))); \ + return NanThrowTypeError("Argument " #I " must be a function"); \ Local VAR = Local::Cast(args[I]); @@ -27,13 +26,13 @@ using namespace node; #define JSFUNC(NAME) \ static NAN_METHOD(NAME); - //static Handle NAME(const Arguments& args); #define JSTHROW_TYPE(ERR) \ - return v8::ThrowException(v8::Exception::TypeError(v8::String::New(ERR))); + NanThrowTypeError( ERR ); + #define JSTHROW(ERR) \ - return v8::ThrowException(v8::Exception::Error(v8::String::New(ERR))); + NanThrowError( ERR ); #define INT_FROM_ARGS(NAME, IND) \ @@ -51,7 +50,6 @@ class OpenCV: public node::ObjectWrap{ static void Init(Handle target); static NAN_METHOD(ReadImage); - //static Handle ReadImage(const v8::Arguments&); }; diff --git a/src/init.cc b/src/init.cc index 08df48f..ed4d20d 100755 --- a/src/init.cc +++ b/src/init.cc @@ -1,12 +1,12 @@ #include "OpenCV.h" -#include "Point.h" +/*#include "Point.h" #include "Matrix.h" #include "CascadeClassifierWrap.h" #include "VideoCaptureWrap.h" #include "Contours.h" #include "CamShift.h" #include "HighGUI.h" -#include "FaceRecognizer.h" +#include "FaceRecognizer.h"*/ extern "C" void @@ -14,7 +14,7 @@ init(Handle target) { //HandleScope scope; NanScope(); OpenCV::Init(target); - Point::Init(target); + /*Point::Init(target); Matrix::Init(target); CascadeClassifierWrap::Init(target); VideoCaptureWrap::Init(target); @@ -24,7 +24,7 @@ init(Handle target) { #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4 FaceRecognizerWrap::Init(target); - #endif + #endif*/ }; From 0a23d23636ac74d86b36f816d297664c8924a944 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Sat, 20 Sep 2014 16:16:00 +0200 Subject: [PATCH 05/12] - ported Contours.cc --- src/Contours.cc | 94 +++++++++++++++++++++++-------------------------- 1 file changed, 44 insertions(+), 50 deletions(-) diff --git a/src/Contours.cc b/src/Contours.cc index 3eb6040..1038220 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -11,14 +11,7 @@ void Contour::Init(Handle target) { NanScope(); - //Class - /*v8::Local m = v8::FunctionTemplate::New(New); - m->SetClassName(v8::String::NewSymbol("Contours")); - - // Constructor - constructor = Persistent::New(m); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("Contours"));*/ + //Class/contructor Local ctor = NanNew(Contour::New); NanAssignPersistent(constructor, ctor); @@ -41,7 +34,6 @@ Contour::Init(Handle target) { NODE_SET_PROTOTYPE_METHOD(ctor, "minAreaRect", MinAreaRect); NODE_SET_PROTOTYPE_METHOD(ctor, "isConvex", IsConvex); NODE_SET_PROTOTYPE_METHOD(ctor, "moments", Moments); - //target->Set(String::NewSymbol("Contours"), m->GetFunction()); target->Set(NanNew("Contours"), ctor->GetFunction()); }; @@ -73,14 +65,14 @@ NAN_METHOD(Contour::Point) { cv::Point point = self->contours[pos][index]; - Local data = Object::New(); - data->Set(String::NewSymbol("x"), Number::New(point.x)); - data->Set(String::NewSymbol("y"), Number::New(point.y)); + Local data = NanNew(); + data->Set(NanNew("x"), NanNew(point.x)); + data->Set(NanNew("y"), NanNew(point.y)); - return scope.Close(data); + NanReturnValue(data); } -/* + // FIXME: this sould better be called "Length" as ``Contours`` is an Array like structure // also, this would allow to use ``Size`` for the function returning the number of corners // in the contour for better consistency with OpenCV. @@ -89,26 +81,28 @@ NAN_METHOD(Contour::Size) { Contour *self = ObjectWrap::Unwrap(args.This()); - return scope.Close(Number::New(self->contours.size())); + NanReturnValue(NanNew(self->contours.size())); } + NAN_METHOD(Contour::CornerCount) { NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); - return scope.Close(Number::New(self->contours[pos].size())); + NanReturnValue(NanNew(self->contours[pos].size())); } + NAN_METHOD(Contour::Area) { NanScope(); Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); - //return scope.Close(Number::New(contourArea(self->contours))); - return scope.Close(Number::New(contourArea(cv::Mat(self->contours[pos])))); + //NanReturnValue(NanNew(contourArea(self->contours))); + NanReturnValue(NanNew(contourArea(cv::Mat(self->contours[pos])))); } @@ -119,7 +113,7 @@ NAN_METHOD(Contour::ArcLength) { int pos = args[0]->NumberValue(); bool isClosed = args[1]->BooleanValue(); - return scope.Close(Number::New(arcLength(cv::Mat(self->contours[pos]), isClosed))); + NanReturnValue(NanNew(arcLength(cv::Mat(self->contours[pos]), isClosed))); } @@ -135,7 +129,7 @@ NAN_METHOD(Contour::ApproxPolyDP) { approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed); approxed.copyTo(self->contours[pos]); - return scope.Close(v8::Null()); + NanReturnNull(); } @@ -151,7 +145,7 @@ NAN_METHOD(Contour::ConvexHull) { cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise); hull.copyTo(self->contours[pos]); - return scope.Close(v8::Null()); + NanReturnNull(); } @@ -162,14 +156,14 @@ NAN_METHOD(Contour::BoundingRect) { int pos = args[0]->NumberValue(); cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos])); - Local rect = Object::New(); + Local rect = NanNew(); - rect->Set(String::NewSymbol("x"), Number::New(bounding.x)); - rect->Set(String::NewSymbol("y"), Number::New(bounding.y)); - rect->Set(String::NewSymbol("width"), Number::New(bounding.width)); - rect->Set(String::NewSymbol("height"), Number::New(bounding.height)); + rect->Set(NanNew("x"), NanNew(bounding.x)); + rect->Set(NanNew("y"), NanNew(bounding.y)); + rect->Set(NanNew("width"), NanNew(bounding.width)); + rect->Set(NanNew("height"), NanNew(bounding.height)); - return scope.Close(rect); + NanReturnValue(rect); } @@ -181,33 +175,33 @@ NAN_METHOD(Contour::MinAreaRect) { cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos])); - Local rect = Object::New(); - rect->Set(String::NewSymbol("angle"), Number::New(minimum.angle)); + Local rect = NanNew(); + rect->Set(NanNew("angle"), NanNew(minimum.angle)); - Local size = Object::New(); - size->Set(String::NewSymbol("height"), Number::New(minimum.size.height)); - size->Set(String::NewSymbol("width"), Number::New(minimum.size.width)); - rect->Set(String::NewSymbol("size"), size); + Local size = NanNew(); + size->Set(NanNew("height"), NanNew(minimum.size.height)); + size->Set(NanNew("width"), NanNew(minimum.size.width)); + rect->Set(NanNew("size"), size); - Local center = Object::New(); - center->Set(String::NewSymbol("x"), Number::New(minimum.center.x)); - center->Set(String::NewSymbol("y"), Number::New(minimum.center.y)); + Local center = NanNew(); + center->Set(NanNew("x"), NanNew(minimum.center.x)); + center->Set(NanNew("y"), NanNew(minimum.center.y)); - v8::Local points = v8::Array::New(4); + v8::Local points = NanNew(4); cv::Point2f rect_points[4]; minimum.points(rect_points); for (unsigned int i=0; i<4; i++){ - Local point = Object::New(); - point->Set(String::NewSymbol("x"), Number::New(rect_points[i].x)); - point->Set(String::NewSymbol("y"), Number::New(rect_points[i].y)); + Local point = NanNew(); + point->Set(NanNew("x"), NanNew(rect_points[i].x)); + point->Set(NanNew("y"), NanNew(rect_points[i].y)); points->Set(i, point); } - rect->Set(String::NewSymbol("points"), points); + rect->Set(NanNew("points"), points); - return scope.Close(rect); + NanReturnValue(rect); } @@ -217,7 +211,7 @@ NAN_METHOD(Contour::IsConvex) { Contour *self = ObjectWrap::Unwrap(args.This()); int pos = args[0]->NumberValue(); - return scope.Close(Boolean::New(isContourConvex(cv::Mat(self->contours[pos])))); + NanReturnValue(NanNew(isContourConvex(cv::Mat(self->contours[pos])))); } NAN_METHOD(Contour::Moments) { @@ -229,13 +223,13 @@ NAN_METHOD(Contour::Moments) { /// Get the moments cv::Moments mu = moments( self->contours[pos], false ); - Local res = Object::New(); + Local res = NanNew(); - res->Set(String::NewSymbol("m00"), Number::New(mu.m00)); - res->Set(String::NewSymbol("m10"), Number::New(mu.m10)); - res->Set(String::NewSymbol("m01"), Number::New(mu.m01)); - res->Set(String::NewSymbol("m11"), Number::New(mu.m11)); + res->Set(NanNew("m00"), NanNew(mu.m00)); + res->Set(NanNew("m10"), NanNew(mu.m10)); + res->Set(NanNew("m01"), NanNew(mu.m01)); + res->Set(NanNew("m11"), NanNew(mu.m11)); - return scope.Close(res); + NanReturnValue(res); } -*/ + From 3bf2ee7fac4271bfc100c94327e06f025d859565 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Sat, 20 Sep 2014 17:08:19 +0200 Subject: [PATCH 06/12] - finished converting Matrix.cc (preliminary pass) * no compile error in nw-gyp v0.10.5 --- src/Matrix.cc | 773 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 773 insertions(+) diff --git a/src/Matrix.cc b/src/Matrix.cc index 15870ef..a4bd78b 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -1128,3 +1128,776 @@ NAN_METHOD(Matrix::DrawContour) { } +NAN_METHOD(Matrix::DrawAllContours) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + Contour *cont = ObjectWrap::Unwrap(args[0]->ToObject()); + + cv::Scalar color(0, 0, 255); + + if(args[1]->IsArray()) { + Local objColor = args[1]->ToObject(); + color = setColor(objColor); + } + + int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue(); + + cv::drawContours(self->mat, cont->contours, -1, color, thickness); + + + NanReturnUndefined(); +} + + +NAN_METHOD(Matrix::GoodFeaturesToTrack) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + std::vector corners; + + cv::Mat gray; + + cvtColor(self->mat, gray, CV_BGR2GRAY); + equalizeHist(gray, gray); + + cv::goodFeaturesToTrack(gray, corners, 500, 0.01, 10); + + v8::Local arr = NanNew(corners.size()); + + + for (unsigned int i=0; i pt = NanNew(2); + pt->Set(0, NanNew((double) corners[i].x)); + pt->Set(1, NanNew((double) corners[i].y)); + arr->Set(i, pt); + } + + NanReturnValue(arr); + +} + + +NAN_METHOD(Matrix::HoughLinesP) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + double rho = args.Length() < 1 ? 1 : args[0]->NumberValue(); + double theta = args.Length() < 2 ? CV_PI/180 : args[1]->NumberValue(); + int threshold = args.Length() < 3 ? 80 : args[2]->Uint32Value(); + double minLineLength = args.Length() < 4 ? 30 : args[3]->NumberValue(); + double maxLineGap = args.Length() < 5 ? 10 : args[4]->NumberValue(); + std::vector lines; + + cv::Mat gray; + + + equalizeHist(self->mat, gray); + // cv::Canny(gray, gray, 50, 200, 3); + cv::HoughLinesP(gray, lines, rho, theta, threshold, minLineLength, maxLineGap); + + v8::Local arr = NanNew(lines.size()); + + + for (unsigned int i=0; i pt = NanNew(4); + pt->Set(0, NanNew((double) lines[i][0])); + pt->Set(1, NanNew((double) lines[i][1])); + pt->Set(2, NanNew((double) lines[i][2])); + pt->Set(3, NanNew((double) lines[i][3])); + arr->Set(i, pt); + } + + NanReturnValue(arr); + +} + +cv::Scalar setColor(Local objColor) { + + Local valB = objColor->Get(0); + Local valG = objColor->Get(1); + Local valR = objColor->Get(2); + + cv::Scalar color = cv::Scalar(valB->IntegerValue(), valG->IntegerValue(), valR->IntegerValue()); + return color; + + +} + +cv::Point setPoint(Local objPoint) { + return cv::Point( objPoint->Get(0)->IntegerValue(), objPoint->Get(1)->IntegerValue() ); +} + +cv::Rect* setRect(Local objRect) { + + if(!objRect->IsArray() || !objRect->Get(0)->IsArray() || !objRect->Get(0)->IsArray() ){ + printf("error"); + return 0; + }; + + Local point = objRect->Get(0)->ToObject(); + Local size = objRect->Get(1)->ToObject(); + cv::Rect ret; + + ret.x = point->Get(0)->IntegerValue(); + ret.y = point->Get(1)->IntegerValue(); + ret.width = size->Get(0)->IntegerValue(); + ret.height = size->Get(1)->IntegerValue(); + + return (cv::Rect*) &ret; +} + + +NAN_METHOD(Matrix::Resize){ + NanScope(); + + int x = args[0]->Uint32Value(); + int y = args[1]->Uint32Value(); + /* + CV_INTER_NN =0, + CV_INTER_LINEAR =1, + CV_INTER_CUBIC =2, + CV_INTER_AREA =3, + CV_INTER_LANCZOS4 =4 + */ + int interpolation = (args.Length() < 3) ? (int)cv::INTER_LINEAR : args[2]->Uint32Value(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + cv::Mat res = cv::Mat(x, y, CV_32FC3); + cv::resize(self->mat, res, cv::Size(x, y), 0, 0, interpolation); + ~self->mat; + self->mat = res; + + + NanReturnUndefined(); +} + + +NAN_METHOD(Matrix::Rotate){ + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + cv::Mat rotMatrix(2, 3, CV_32FC1); + cv::Mat res; + + float angle = args[0]->ToNumber()->Value(); + + // Modification by SergeMv + //------------- + // If you provide only the angle argument and the angle is multiple of 90, then + // we do a fast thing + bool rightOrStraight = (ceil(angle) == angle) && (!((int)angle % 90)) + && (args.Length() == 1); + if (rightOrStraight) { + int angle2 = ((int)angle) % 360; + if (!angle2) { NanReturnUndefined(); } + if (angle2 < 0) { angle2 += 360; } + // See if we do right angle rotation, we transpose the matrix: + if (angle2 % 180) { + cv::transpose(self->mat, res); + ~self->mat; + self->mat = res; + } + // Now flip the image + int mode = -1; // flip around both axes + // If counterclockwise, flip around the x-axis + if (angle2 == 90) { mode = 0; } + // If clockwise, flip around the y-axis + if (angle2 == 270) { mode = 1; } + cv::flip(self->mat, self->mat, mode); + + NanReturnUndefined(); + } + //------------- + + int x = args[1]->IsUndefined() ? round(self->mat.size().width / 2) : args[1]->Uint32Value(); + int y = args[1]->IsUndefined() ? round(self->mat.size().height / 2) : args[2]->Uint32Value(); + + cv::Point center = cv::Point(x,y); + rotMatrix = getRotationMatrix2D(center, angle, 1.0); + + cv::warpAffine(self->mat, res, rotMatrix, self->mat.size()); + ~self->mat; + self->mat = res; + + NanReturnUndefined(); +} + +NAN_METHOD(Matrix::PyrDown){ + SETUP_FUNCTION(Matrix) + + cv::pyrDown(self->mat, self->mat); + NanReturnUndefined(); +} + +NAN_METHOD(Matrix::PyrUp){ + SETUP_FUNCTION(Matrix) + + cv::pyrUp(self->mat, self->mat); + NanReturnUndefined(); +} + +NAN_METHOD(Matrix::inRange) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + /*if(self->mat.channels() != 3) + NanThrowError(String::New("Image is no 3-channel"));*/ + + if(args[0]->IsArray() && args[1]->IsArray()) { + Local args_lowerb = args[0]->ToObject(); + Local args_upperb = args[1]->ToObject(); + + cv::Scalar lowerb(0, 0, 0); + cv::Scalar upperb(0, 0, 0); + + lowerb = setColor(args_lowerb); + upperb = setColor(args_upperb); + + cv::Mat mask; + cv::inRange(self->mat, lowerb, upperb, mask); + mask.copyTo(self->mat); + } + + + NanReturnNull(); +} + +NAN_METHOD(Matrix::AdjustROI) { + SETUP_FUNCTION(Matrix) + int dtop = args[0]->Uint32Value(); + int dbottom = args[1]->Uint32Value(); + int dleft = args[2]->Uint32Value(); + int dright = args[3]->Uint32Value(); + + self->mat.adjustROI(dtop, dbottom, dleft, dright); + + NanReturnNull(); + +} + +NAN_METHOD(Matrix::LocateROI) { + SETUP_FUNCTION(Matrix) + + cv::Size wholeSize; + cv::Point ofs; + + self->mat.locateROI(wholeSize, ofs); + + v8::Local arr = NanNew(4); + arr->Set(0, NanNew(wholeSize.width)); + arr->Set(1, NanNew(wholeSize.height)); + arr->Set(2, NanNew(ofs.x)); + arr->Set(3, NanNew(ofs.y)); + + NanReturnValue(arr); +} + + + +NAN_METHOD(Matrix::Threshold) { + SETUP_FUNCTION(Matrix) + + double threshold = args[0]->NumberValue(); + double maxVal = args[1]->NumberValue(); + + int typ = cv::THRESH_BINARY; + if (args.Length() == 3){ +// typ = args[2]->IntegerValue(); + NanAsciiString typstr(args[2]); + if (strcmp(*typstr, "Binary") == 0){ + typ=0; + } + if (strcmp(*typstr, "Binary Inverted") == 0){ + typ=1; + } + if (strcmp(*typstr, "Threshold Truncated") == 0){ + typ=2; + } + if (strcmp(*typstr, "Threshold to Zero") == 0){ + typ=3; + } + if (strcmp(*typstr, "Threshold to Zero Inverted") == 0){ + typ=4; + } + } + + + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); + self->mat.copyTo(img->mat); + + cv::threshold(self->mat, img->mat, threshold, maxVal, typ); + + NanReturnValue(img_to_return); +} + +NAN_METHOD(Matrix::AdaptiveThreshold) { + SETUP_FUNCTION(Matrix) + + double maxVal = args[0]->NumberValue(); + double adaptiveMethod = args[1]->NumberValue(); + double thresholdType = args[2]->NumberValue(); + double blockSize = args[3]->NumberValue(); + double C = args[4]->NumberValue(); + + Local img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(img_to_return); + self->mat.copyTo(img->mat); + + cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C); + + NanReturnValue(img_to_return); +} + +NAN_METHOD(Matrix::MeanStdDev) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + + Local mean = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_mean = ObjectWrap::Unwrap(mean); + Local stddev = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_stddev = ObjectWrap::Unwrap(stddev); + + cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat); + + Local data = NanNew(); + data->Set(NanNew("mean"), mean); + data->Set(NanNew("stddev"), stddev); + NanReturnValue(data); +} + + +// @author SergeMv +// Copies our (small) image into a ROI of another (big) image +// @param Object another image (destination) +// @param Number Destination x (where our image is to be copied) +// @param Number Destination y (where our image is to be copied) +// Example: smallImg.copyTo(bigImg, 50, 50); +// Note, x,y and width and height of our image must be so that +// our.width + x <= destination.width (and the same for y and height) +// both x and y must be >= 0 +NAN_METHOD(Matrix::CopyTo) { + NanScope(); + + Matrix * self = ObjectWrap::Unwrap(args.This()); + int width = self->mat.size().width; + int height = self->mat.size().height; + + // param 0 - destination image: + Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); + // param 1 - x coord of the destination + int x = args[1]->IntegerValue(); + // param 2 - y coord of the destination + int y = args[2]->IntegerValue(); + + cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height)); + self->mat.copyTo(dstROI); + + NanReturnUndefined(); +} + + + +// @author SergeMv +// Does in-place color transformation +// img.cvtColor('CV_BGR2YCrCb'); +NAN_METHOD(Matrix::CvtColor) { + NanScope(); + + Matrix * self = ObjectWrap::Unwrap(args.This()); + + v8::String::Utf8Value str (args[0]->ToString()); + std::string str2 = std::string(*str); + const char * sTransform = (const char *) str2.c_str(); + int iTransform; + // + if (!strcmp(sTransform, "CV_BGR2GRAY")) { iTransform = CV_BGR2GRAY; } + else if (!strcmp(sTransform, "CV_GRAY2BGR")) { iTransform = CV_GRAY2BGR; } + // + else if (!strcmp(sTransform, "CV_BGR2XYZ")) { iTransform = CV_BGR2XYZ; } + else if (!strcmp(sTransform, "CV_XYZ2BGR")) { iTransform = CV_XYZ2BGR; } + // + else if (!strcmp(sTransform, "CV_BGR2YCrCb")) { iTransform = CV_BGR2YCrCb; } + else if (!strcmp(sTransform, "CV_YCrCb2BGR")) { iTransform = CV_YCrCb2BGR; } + // + else if (!strcmp(sTransform, "CV_BGR2HSV")) { iTransform = CV_BGR2HSV; } + else if (!strcmp(sTransform, "CV_HSV2BGR")) { iTransform = CV_HSV2BGR; } + // + else if (!strcmp(sTransform, "CV_BGR2HLS")) { iTransform = CV_BGR2HLS; } + else if (!strcmp(sTransform, "CV_HLS2BGR")) { iTransform = CV_HLS2BGR; } + // + else if (!strcmp(sTransform, "CV_BGR2Lab")) { iTransform = CV_BGR2Lab; } + else if (!strcmp(sTransform, "CV_Lab2BGR")) { iTransform = CV_Lab2BGR; } + // + else if (!strcmp(sTransform, "CV_BGR2Luv")) { iTransform = CV_BGR2Luv; } + else if (!strcmp(sTransform, "CV_Luv2BGR")) { iTransform = CV_Luv2BGR; } + // + else if (!strcmp(sTransform, "CV_BayerBG2BGR")) { iTransform = CV_BayerBG2BGR; } + else if (!strcmp(sTransform, "CV_BayerGB2BGR")) { iTransform = CV_BayerGB2BGR; } + else if (!strcmp(sTransform, "CV_BayerRG2BGR")) { iTransform = CV_BayerRG2BGR; } + else if (!strcmp(sTransform, "CV_BayerGR2BGR")) { iTransform = CV_BayerGR2BGR; } + else { + iTransform = 0; // to avoid compiler warning + NanThrowTypeError("Conversion code is unsupported"); + } + + cv::cvtColor(self->mat, self->mat, iTransform); + + NanReturnUndefined(); +} + + +// @author SergeMv +// arrChannels = img.split(); +NAN_METHOD(Matrix::Split) { + NanScope(); + + Matrix * self = ObjectWrap::Unwrap(args.This()); + + vector channels; + cv::split(self->mat, channels); + unsigned int size = channels.size(); + v8::Local arrChannels = NanNew(size); + for (unsigned int i = 0; i < size; i++) { + Local matObject = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix * m = ObjectWrap::Unwrap(matObject); + m->mat = channels[i]; + arrChannels->Set(i, matObject); + } + + NanReturnValue(arrChannels); +} + + +// @author SergeMv +// img.merge(arrChannels); +NAN_METHOD(Matrix::Merge) { + NanScope(); + + Matrix * self = ObjectWrap::Unwrap(args.This()); + + if (!args[0]->IsArray()) { + NanThrowTypeError("The argument must be an array"); + } + v8::Handle jsChannels = v8::Handle::Cast(args[0]); + + unsigned int L = jsChannels->Length(); + vector vChannels(L); + for (unsigned int i = 0; i < L; i++) { + Matrix * matObject = ObjectWrap::Unwrap(jsChannels->Get(i)->ToObject()); + vChannels[i] = matObject->mat; + } + cv::merge(vChannels, self->mat); + + NanReturnUndefined(); +} + + +// @author SergeMv +// Equalizes histogram +// img.equalizeHist() +NAN_METHOD(Matrix::EqualizeHist) { + NanScope(); + + Matrix * self = ObjectWrap::Unwrap(args.This()); + + cv::equalizeHist(self->mat, self->mat); + + NanReturnUndefined(); +} + +NAN_METHOD(Matrix::FloodFill){ + SETUP_FUNCTION(Matrix) + //obj->Get(NanNew("x")) + //int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int) + + + /* mat.floodFill( { seedPoint: [1,1] , + newColor: [255,0,0] , + rect:[[0,2],[30,40]] , + loDiff : [8,90,60], + upDiff:[10,100,70] + } );*/ + + + if(args.Length() < 1 || !args[0]->IsObject()) { + //error + } + + + Local obj = args[0]->ToObject(); + + int ret = cv::floodFill(self->mat, setPoint(obj->Get(NanNew("seedPoint"))->ToObject()) + , setColor(obj->Get(NanNew("newColor"))->ToObject()) + , obj->Get(NanNew("rect"))->IsUndefined() ? 0 : setRect(obj->Get(NanNew("rect"))->ToObject()) + , setColor(obj->Get(NanNew("loDiff"))->ToObject()) + , setColor(obj->Get(NanNew("upDiff"))->ToObject()) + , 4 ); + + + NanReturnValue(NanNew( ret )); +} + + +// @author ytham +// Match Template filter +// Usage: output = input.matchTemplate("templateFileString", method); +NAN_METHOD(Matrix::MatchTemplate) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + + v8::String::Utf8Value args0(args[0]->ToString()); + std::string filename = std::string(*args0); + cv::Mat templ; + templ = cv::imread(filename, CV_8S); + + Local out = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *m_out = ObjectWrap::Unwrap(out); + int cols = self->mat.cols - templ.cols + 1; + int rows = self->mat.rows - templ.rows + 1; + m_out->mat.create(cols, rows, CV_32FC1); + + /* + TM_SQDIFF =0 + TM_SQDIFF_NORMED =1 + TM_CCORR =2 + TM_CCORR_NORMED =3 + TM_CCOEFF =4 + TM_CCOEFF_NORMED =5 + */ + int method = (args.Length() < 2) ? (int)cv::TM_CCORR_NORMED : args[1]->Uint32Value(); + + cv::matchTemplate(self->mat, templ, m_out->mat, method); + + double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; + cv::minMaxLoc(m_out->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); + + NanReturnValue(out); +} + + +// @author ytham +// Min/Max location +NAN_METHOD(Matrix::MinMaxLoc) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + + double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc; + + cv::minMaxLoc(self->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() ); + + Local v_minVal = NanNew(minVal); + Local v_maxVal = NanNew(maxVal); + Local v_minLoc_x = NanNew(minLoc.x); + Local v_minLoc_y = NanNew(minLoc.y); + Local v_maxLoc_x = NanNew(maxLoc.x); + Local v_maxLoc_y = NanNew(maxLoc.y); + + Local o_minLoc = NanNew(); + o_minLoc->Set(NanNew("x"), v_minLoc_x); + o_minLoc->Set(NanNew("y"), v_minLoc_y); + + Local o_maxLoc = NanNew(); + o_maxLoc->Set(NanNew("x"), v_maxLoc_x); + o_maxLoc->Set(NanNew("y"), v_maxLoc_y); + + // Output result object + Local result = NanNew(); + result->Set(NanNew("minVal"), v_minVal); + result->Set(NanNew("maxVal"), v_maxVal); + result->Set(NanNew("minLoc"), o_minLoc); + result->Set(NanNew("maxLoc"), o_maxLoc); + + NanReturnValue(result); +} + + +// @author ytham +// Pushes some matrix (argument) the back of a matrix (self) +NAN_METHOD(Matrix::PushBack) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + + Matrix *m_input = ObjectWrap::Unwrap(args[0]->ToObject()); + + self->mat.push_back(m_input->mat); + + NanReturnValue(args.This()); +} + +NAN_METHOD(Matrix::PutText) { + NanScope(); + + Matrix *self = ObjectWrap::Unwrap(args.This()); + + NanAsciiString textString(args[0]);//FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152 + char *text = *textString; //(char *) malloc(textString.length() + 1); + //strcpy(text, *textString); + + int x = args[1]->IntegerValue(); + int y = args[2]->IntegerValue(); + + NanAsciiString fontString(args[3]); + char *font = *fontString;//(char *) malloc(fontString.length() + 1); + //strcpy(font, *fontString); + int constFont = cv::FONT_HERSHEY_SIMPLEX; + + if (!strcmp(font, "HERSEY_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SIMPLEX; } + else if (!strcmp(font, "HERSEY_PLAIN")) { constFont = cv::FONT_HERSHEY_PLAIN; } + else if (!strcmp(font, "HERSEY_DUPLEX")) { constFont = cv::FONT_HERSHEY_DUPLEX; } + else if (!strcmp(font, "HERSEY_COMPLEX")) { constFont = cv::FONT_HERSHEY_COMPLEX; } + else if (!strcmp(font, "HERSEY_TRIPLEX")) { constFont = cv::FONT_HERSHEY_TRIPLEX; } + else if (!strcmp(font, "HERSEY_COMPLEX_SMALL")) { constFont = cv::FONT_HERSHEY_COMPLEX_SMALL; } + else if (!strcmp(font, "HERSEY_SCRIPT_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_SIMPLEX; } + else if (!strcmp(font, "HERSEY_SCRIPT_COMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_COMPLEX; } + else if (!strcmp(font, "HERSEY_SCRIPT_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_SIMPLEX; } + + cv::Scalar color(0, 0, 255); + + if(args[4]->IsArray()) { + Local objColor = args[4]->ToObject(); + color = setColor(objColor); + } + + double scale = args.Length() < 6 ? 1 : args[5]->NumberValue(); + + cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, 2); + + NanReturnUndefined(); +} + + +NAN_METHOD(Matrix::GetPerspectiveTransform) { + NanScope(); + + // extract quad args + Local srcArray = args[0]->ToObject(); + Local tgtArray = args[1]->ToObject(); + + std::vector src_corners(4); + std::vector tgt_corners(4); + for (unsigned int i = 0; i < 4; i++) { + src_corners[i] = cvPoint(srcArray->Get(i*2)->IntegerValue(),srcArray->Get(i*2+1)->IntegerValue()); + tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue(),tgtArray->Get(i*2+1)->IntegerValue()); + } + + Local xfrm = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *xfrmmat = ObjectWrap::Unwrap(xfrm); + xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners); + + NanReturnValue(xfrm); +} + + +NAN_METHOD(Matrix::WarpPerspective) { + SETUP_FUNCTION(Matrix) + + Matrix *xfrm = ObjectWrap::Unwrap(args[0]->ToObject()); + + int width = args[1]->IntegerValue(); + int height = args[2]->IntegerValue(); + + int flags = cv::INTER_LINEAR; + int borderMode = cv::BORDER_REPLICATE; + + cv::Scalar borderColor(0, 0, 255); + + if(args[3]->IsArray()) { + Local objColor = args[3]->ToObject(); + borderColor = setColor(objColor); + } + + cv::Mat res = cv::Mat(width, height, CV_32FC3); + + cv::warpPerspective(self->mat, res, xfrm->mat, cv::Size(width, height), flags, borderMode, borderColor); + + ~self->mat; + self->mat = res; + + NanReturnNull(); +} + +NAN_METHOD(Matrix::CopyWithMask) { + SETUP_FUNCTION(Matrix) + + // param 0 - destination image: + Matrix *dest = ObjectWrap::Unwrap(args[0]->ToObject()); + // param 1 - mask. same size as src and dest + Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + + self->mat.copyTo(dest->mat,mask->mat); + + NanReturnUndefined(); +} + + +NAN_METHOD(Matrix::SetWithMask) { + SETUP_FUNCTION(Matrix) + + // param 0 - target value: + Local valArray = args[0]->ToObject(); + cv::Scalar newvals; + newvals.val[0] = valArray->Get(0)->NumberValue(); + newvals.val[1] = valArray->Get(1)->NumberValue(); + newvals.val[2] = valArray->Get(2)->NumberValue(); + + // param 1 - mask. same size as src and dest + Matrix *mask = ObjectWrap::Unwrap(args[1]->ToObject()); + + self->mat.setTo(newvals,mask->mat); + + NanReturnUndefined(); +} + +NAN_METHOD(Matrix::MeanWithMask) { + SETUP_FUNCTION(Matrix) + + // param 0 - mask. same size as src and dest + Matrix *mask = ObjectWrap::Unwrap(args[0]->ToObject()); + + cv::Scalar means = cv::mean(self->mat, mask->mat); + v8::Local arr = NanNew(3); + arr->Set(0, NanNew( means[0] )); + arr->Set(1, NanNew( means[1] )); + arr->Set(2, NanNew( means[2] )); + + NanReturnValue(arr); +} + +NAN_METHOD(Matrix::Shift){ + SETUP_FUNCTION(Matrix) + + cv::Mat res; + + double tx = args[0]->NumberValue(); + double ty = args[1]->NumberValue(); + + // get the integer values of args + cv::Point2i deltai(ceil(tx), ceil(ty)); + + int fill=cv::BORDER_REPLICATE; + cv::Scalar value=cv::Scalar(0,0,0,0); + + // INTEGER SHIFT + // first create a border around the parts of the Mat that will be exposed + int t = 0, b = 0, l = 0, r = 0; + if (deltai.x > 0) l = deltai.x; + if (deltai.x < 0) r = -deltai.x; + if (deltai.y > 0) t = deltai.y; + if (deltai.y < 0) b = -deltai.y; + cv::Mat padded; + cv::copyMakeBorder(self->mat, padded, t, b, l, r, fill, value); + + // construct the region of interest around the new matrix + cv::Rect roi = cv::Rect(std::max(-deltai.x,0),std::max(-deltai.y,0),0,0) + self->mat.size(); + res = padded(roi); + ~self->mat; + self->mat = res; + + NanReturnUndefined(); +} From a793f21561ddfced028ebc36fcf8ac1680d11c86 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Sun, 21 Sep 2014 12:42:55 +0200 Subject: [PATCH 07/12] - first pass migration of all relevant source done * compiling ok under node 0.11.13 * missing a number of async methods --- src/BackgroundSubtractor.cc | 53 ++++++++-------- src/BackgroundSubtractor.h | 8 +-- src/CamShift.cc | 51 ++++++++------- src/CascadeClassifierWrap.cc | 45 +++++++------ src/FaceRecognizer.cc | 118 +++++++++++++++++++---------------- src/HighGUI.cc | 42 +++++++------ src/Matrix.cc | 4 +- src/Point.cc | 55 +++++++++------- src/VideoCaptureWrap.cc | 96 ++++++++++++++-------------- src/init.cc | 11 ++-- 10 files changed, 256 insertions(+), 227 deletions(-) diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc index aed68d5..3841cab 100644 --- a/src/BackgroundSubtractor.cc +++ b/src/BackgroundSubtractor.cc @@ -1,6 +1,7 @@ #include "BackgroundSubtractor.h" #include "Matrix.h" #include +#include #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4 @@ -8,21 +9,23 @@ Persistent BackgroundSubtractorWrap::constructor; void BackgroundSubtractorWrap::Init(Handle target) { - HandleScope scope; + NanScope(); // Constructor - constructor = Persistent::New(FunctionTemplate::New(BackgroundSubtractorWrap::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("BackgroundSubtractor")); + Local ctor = NanNew(BackgroundSubtractorWrap::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("BackgroundSubtractor")); - NODE_SET_METHOD(constructor, "createMOG", CreateMOG); - NODE_SET_PROTOTYPE_METHOD(constructor, "applyMOG", ApplyMOG); + NODE_SET_METHOD(ctor, "createMOG", CreateMOG); + NODE_SET_PROTOTYPE_METHOD(ctor, "applyMOG", ApplyMOG); - target->Set(String::NewSymbol("BackgroundSubtractor"), constructor->GetFunction()); + target->Set(NanNew("BackgroundSubtractor"), ctor->GetFunction()); + }; -NAN_METHOD(BackgroundSubtractorWrap::New() { - HandleScope scope; +NAN_METHOD(BackgroundSubtractorWrap::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0) JSTHROW_TYPE("Cannot Instantiate without new") @@ -33,11 +36,11 @@ NAN_METHOD(BackgroundSubtractorWrap::New() { pt->Wrap(args.This()); - return args.This(); + NanReturnValue(args.This()); } -NAN_METHOD(BackgroundSubtractorWrap::CreateMOG() { - HandleScope scope; +NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) { + NanScope(); int history = 200; int nmixtures = 5; @@ -51,17 +54,17 @@ NAN_METHOD(BackgroundSubtractorWrap::CreateMOG() { DOUBLE_FROM_ARGS(noiseSigma, 3) } - Local n = BackgroundSubtractorWrap::constructor->GetFunction()->NewInstance(); + Local n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr bg; BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg); pt->Wrap(n); - return n; + NanReturnValue( n ); }; //Fetch foreground mask -NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG() { +NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) { SETUP_FUNCTION(BackgroundSubtractorWrap) @@ -70,15 +73,15 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG() { Local argv[2]; if(args.Length() == 0){ - argv[0] = String::New("Input image missing"); - argv[1] = Local::New(Null()); - cb->Call(Context::GetCurrent()->Global(), 2, argv); - return scope.Close(Undefined()); + argv[0] = NanNew("Input image missing"); + argv[1] = NanNull(); + cb->Call(NanGetCurrentContext()->Global(), 2, argv); + NanReturnUndefined(); } try{ - Local fgMask = Matrix::constructor->GetFunction()->NewInstance(); + Local fgMask = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(fgMask); @@ -97,7 +100,7 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG() { } if (mat.empty()){ - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Error loading file"))); + return NanThrowTypeError("Error loading file"); } cv::Mat _fgMask; @@ -107,22 +110,22 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG() { mat.release(); - argv[0] = Local::New(Null()); + argv[0] = NanNull(); argv[1] = fgMask; TryCatch try_catch; - cb->Call(Context::GetCurrent()->Global(), 2, argv); + cb->Call(NanGetCurrentContext()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } - return scope.Close(v8::Undefined()); + NanReturnUndefined(); } catch( cv::Exception& e ){ const char* err_msg = e.what(); - return v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg))); + NanThrowError(err_msg); } }; diff --git a/src/BackgroundSubtractor.h b/src/BackgroundSubtractor.h index 001967b..a0833bf 100644 --- a/src/BackgroundSubtractor.h +++ b/src/BackgroundSubtractor.h @@ -10,12 +10,12 @@ class BackgroundSubtractorWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - static Handle New(const Arguments &args); + static NAN_METHOD(New); BackgroundSubtractorWrap(cv::Ptr bg); - static Handle CreateMOG(const v8::Arguments&); - static Handle ApplyMOG(const v8::Arguments&); + static NAN_METHOD(CreateMOG); + static NAN_METHOD(ApplyMOG); }; -#endif \ No newline at end of file +#endif diff --git a/src/CamShift.cc b/src/CamShift.cc index 0999d6f..925c739 100644 --- a/src/CamShift.cc +++ b/src/CamShift.cc @@ -12,23 +12,27 @@ Persistent TrackedObject::constructor; void TrackedObject::Init(Handle target) { - HandleScope scope; + NanScope(); // Constructor - constructor = Persistent::New(FunctionTemplate::New(TrackedObject::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("TrackedObject")); + Local ctor = NanNew(TrackedObject::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("TrackedObject")); + // Prototype //Local proto = constructor->PrototypeTemplate(); - NODE_SET_PROTOTYPE_METHOD(constructor, "track", Track); - target->Set(String::NewSymbol("TrackedObject"), constructor->GetFunction()); + NODE_SET_PROTOTYPE_METHOD(ctor, "track", Track); + + //target->Set(String::NewSymbol("TrackedObject"), constructor->GetFunction()); + target->Set(NanNew("TrackedObject"), ctor->GetFunction()); }; -NAN_METHOD(TrackedObject::New() { - HandleScope scope; +NAN_METHOD(TrackedObject::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0){ JSTHROW_TYPE("Cannot Instantiate without new") @@ -52,8 +56,8 @@ NAN_METHOD(TrackedObject::New() { if (args[2]->IsObject()){ Local opts = args[2]->ToObject(); - if (opts->Get(String::New("channel"))->IsString()){ - v8::String::Utf8Value c(opts->Get(String::New("channel"))->ToString()); + if (opts->Get(NanNew("channel"))->IsString()){ + v8::String::Utf8Value c(opts->Get(NanNew("channel"))->ToString()); std::string cc = std::string(*c); if (cc == "hue" || cc == "h"){ @@ -74,7 +78,7 @@ NAN_METHOD(TrackedObject::New() { to->Wrap(args.This()); - return args.This(); + NanReturnValue(args.This()); } @@ -119,12 +123,12 @@ TrackedObject::TrackedObject(cv::Mat image, cv::Rect rect, int chan){ -NAN_METHOD(TrackedObject::Track(const v8::Arguments& args){ +NAN_METHOD(TrackedObject::Track){ SETUP_FUNCTION(TrackedObject) if (args.Length() != 1){ - v8::ThrowException(v8::Exception::TypeError(v8::String::New("track takes an image param"))); - return Undefined(); + NanThrowTypeError("track takes an image param"); + NanReturnUndefined(); } @@ -135,7 +139,7 @@ NAN_METHOD(TrackedObject::Track(const v8::Arguments& args){ self->prev_rect.y <0 || self->prev_rect.width <= 1 || self->prev_rect.height <= 1){ - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("OPENCV ERROR: prev rectangle is illogical"))); + return NanThrowTypeError("OPENCV ERROR: prev rectangle is illogical"); } update_chann_image(self, im->mat); @@ -165,25 +169,24 @@ NAN_METHOD(TrackedObject::Track(const v8::Arguments& args){ self->prev_rect = backup_prev_rect; } - - v8::Local arr = v8::Array::New(4); + v8::Local arr = NanNew(4); - arr->Set(0, Number::New(bounds.x)); - arr->Set(1, Number::New(bounds.y)); - arr->Set(2, Number::New(bounds.x + bounds.width)); - arr->Set(3, Number::New(bounds.y + bounds.height)); + arr->Set(0, NanNew(bounds.x)); + arr->Set(1, NanNew(bounds.y)); + arr->Set(2, NanNew(bounds.x + bounds.width)); + arr->Set(3, NanNew(bounds.y + bounds.height)); /* cv::Point2f pts[4]; r.points(pts); for (int i=0; i<8; i+=2){ - arr->Set(i, Number::New(pts[i].x)); - arr->Set(i+1, Number::New(pts[i].y)); + arr->Set(i, NanNew(pts[i].x)); + arr->Set(i+1, NanNew(pts[i].y)); } */ - return scope.Close(arr); + NanReturnValue(arr); } diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index 964971a..e35821a 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -10,45 +10,44 @@ Persistent CascadeClassifierWrap::constructor; void CascadeClassifierWrap::Init(Handle target) { - HandleScope scope; + NanScope(); - // Constructor - constructor = Persistent::New(FunctionTemplate::New(CascadeClassifierWrap::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("CascadeClassifier")); + Local ctor = NanNew(CascadeClassifierWrap::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("CascadeClassifier")); // Prototype //Local proto = constructor->PrototypeTemplate(); - NODE_SET_PROTOTYPE_METHOD(constructor, "detectMultiScale", DetectMultiScale); + NODE_SET_PROTOTYPE_METHOD(ctor, "detectMultiScale", DetectMultiScale); - - - target->Set(String::NewSymbol("CascadeClassifier"), constructor->GetFunction()); + target->Set(NanNew("CascadeClassifier"), ctor->GetFunction()); }; -NAN_METHOD(CascadeClassifierWrap::New() { - HandleScope scope; +NAN_METHOD(CascadeClassifierWrap::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0) - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Cannot Instantiate without new"))); + NanThrowTypeError("Cannot instantiate without new"); CascadeClassifierWrap *pt = new CascadeClassifierWrap(*args[0]); pt->Wrap(args.This()); - return args.This(); + NanReturnValue( args.This() ); } CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName){ std::string filename; - filename = std::string(*v8::String::AsciiValue(fileName->ToString())); + filename = std::string(*NanAsciiString(fileName->ToString())); if (!cc.load(filename.c_str())){ - v8::ThrowException(v8::Exception::TypeError(v8::String::New("Error loading file"))); + NanThrowTypeError("Error loading file"); } } + struct classifier_baton_t { CascadeClassifierWrap *cc; Persistent cb; @@ -65,12 +64,12 @@ struct classifier_baton_t { NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ - HandleScope scope; + NanScope(); CascadeClassifierWrap *self = ObjectWrap::Unwrap(args.This()); if (args.Length() < 2){ - v8::ThrowException(v8::Exception::TypeError(v8::String::New("detectMultiScale takes at least 2 args"))); + NanThrowTypeError("detectMultiScale takes at least 2 args"); } Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); @@ -91,7 +90,7 @@ NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ minh = args[5]->IntegerValue(); } - +/*FIXME: convert async classifier_baton_t *baton = new classifier_baton_t(); baton->cc = self; baton->cb = Persistent::New(cb); @@ -110,11 +109,11 @@ NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ uv_queue_work(uv_default_loop(), &baton->request, AsyncDetectMultiScale, (uv_after_work_cb)AfterAsyncDetectMultiScale); return Undefined(); - - + NanReturnUndefined(); + */ } - +/*FIXME: convert async void AsyncDetectMultiScale(uv_work_t *req) { classifier_baton_t *baton = static_cast(req->data); @@ -138,7 +137,7 @@ void AsyncDetectMultiScale(uv_work_t *req) { void AfterAsyncDetectMultiScale(uv_work_t *req) { - HandleScope scope; + NanScope(); classifier_baton_t *baton = static_cast(req->data); // ev_unref(EV_DEFAULT_UC); // baton->cc->Unref(); @@ -175,4 +174,4 @@ void AfterAsyncDetectMultiScale(uv_work_t *req) { // return 0; } - +*/ diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc index d7531a7..fcf203f 100644 --- a/src/FaceRecognizer.cc +++ b/src/FaceRecognizer.cc @@ -4,6 +4,7 @@ #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4 #include "Matrix.h" +#include #define EIGEN 0 #define LBPH 1 @@ -13,7 +14,7 @@ cv::Mat fromMatrixOrFilename(Local v){ cv::Mat im; if (v->IsString()){ - std::string filename = std::string(*v8::String::AsciiValue(v->ToString())); + std::string filename = std::string(*NanAsciiString(v->ToString())); im = cv::imread(filename); //std::cout<< im.size(); } else { @@ -31,30 +32,31 @@ Persistent FaceRecognizerWrap::constructor; void FaceRecognizerWrap::Init(Handle target) { - HandleScope scope; + NanScope(); // Constructor - constructor = Persistent::New(FunctionTemplate::New(FaceRecognizerWrap::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("FaceRecognizer")); + Local ctor = NanNew(FaceRecognizerWrap::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("FaceRecognizer")); - NODE_SET_METHOD(constructor, "createLBPHFaceRecognizer", CreateLBPH); - NODE_SET_METHOD(constructor, "createEigenFaceRecognizer", CreateEigen); - NODE_SET_METHOD(constructor, "createFisherFaceRecognizer", CreateFisher); + NODE_SET_METHOD(ctor, "createLBPHFaceRecognizer", CreateLBPH); + NODE_SET_METHOD(ctor, "createEigenFaceRecognizer", CreateEigen); + NODE_SET_METHOD(ctor, "createFisherFaceRecognizer", CreateFisher); - NODE_SET_PROTOTYPE_METHOD(constructor, "trainSync", TrainSync); - NODE_SET_PROTOTYPE_METHOD(constructor, "updateSync", UpdateSync); - NODE_SET_PROTOTYPE_METHOD(constructor, "predictSync", PredictSync); - NODE_SET_PROTOTYPE_METHOD(constructor, "saveSync", SaveSync); - NODE_SET_PROTOTYPE_METHOD(constructor, "loadSync", LoadSync); + NODE_SET_PROTOTYPE_METHOD(ctor, "trainSync", TrainSync); + NODE_SET_PROTOTYPE_METHOD(ctor, "updateSync", UpdateSync); + NODE_SET_PROTOTYPE_METHOD(ctor, "predictSync", PredictSync); + NODE_SET_PROTOTYPE_METHOD(ctor, "saveSync", SaveSync); + NODE_SET_PROTOTYPE_METHOD(ctor, "loadSync", LoadSync); - NODE_SET_PROTOTYPE_METHOD(constructor, "getMat", GetMat); + NODE_SET_PROTOTYPE_METHOD(ctor, "getMat", GetMat); - target->Set(String::NewSymbol("FaceRecognizer"), constructor->GetFunction()); + target->Set(NanNew("FaceRecognizer"), ctor->GetFunction()); }; -NAN_METHOD(FaceRecognizerWrap::New() { - HandleScope scope; +NAN_METHOD(FaceRecognizerWrap::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0) JSTHROW_TYPE("Cannot Instantiate without new") @@ -64,11 +66,11 @@ NAN_METHOD(FaceRecognizerWrap::New() { FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); pt->Wrap(args.This()); - return args.This(); + NanReturnValue(args.This()); } -NAN_METHOD(FaceRecognizerWrap::CreateLBPH() { - HandleScope scope; +NAN_METHOD(FaceRecognizerWrap::CreateLBPH) { + NanScope(); int radius = 1; int neighbors = 8; @@ -82,7 +84,7 @@ NAN_METHOD(FaceRecognizerWrap::CreateLBPH() { INT_FROM_ARGS(grid_y, 3) DOUBLE_FROM_ARGS(threshold, 4) - Local n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance(); + Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createLBPHFaceRecognizer( radius, neighbors, grid_x, grid_y, threshold @@ -90,11 +92,11 @@ NAN_METHOD(FaceRecognizerWrap::CreateLBPH() { FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH); pt->Wrap(n); - return n; + NanReturnValue( n ); } -NAN_METHOD(FaceRecognizerWrap::CreateEigen() { - HandleScope scope; +NAN_METHOD(FaceRecognizerWrap::CreateEigen) { + NanScope(); int components = 0; double threshold = DBL_MAX; @@ -102,7 +104,7 @@ NAN_METHOD(FaceRecognizerWrap::CreateEigen() { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance(); + Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createEigenFaceRecognizer( components, threshold @@ -110,11 +112,11 @@ NAN_METHOD(FaceRecognizerWrap::CreateEigen() { FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN); pt->Wrap(n); - return n; + NanReturnValue( n ); } -NAN_METHOD(FaceRecognizerWrap::CreateFisher() { - HandleScope scope; +NAN_METHOD(FaceRecognizerWrap::CreateFisher) { + NanScope(); int components = 0; double threshold = DBL_MAX; @@ -122,7 +124,7 @@ NAN_METHOD(FaceRecognizerWrap::CreateFisher() { INT_FROM_ARGS(components, 0) DOUBLE_FROM_ARGS(threshold, 1) - Local n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance(); + Local n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance(); cv::Ptr f = cv::createFisherFaceRecognizer( components, threshold @@ -130,7 +132,7 @@ NAN_METHOD(FaceRecognizerWrap::CreateFisher() { FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER); pt->Wrap(n); - return n; + NanReturnValue( n ); } @@ -140,15 +142,20 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr f, int type){ } -Handle UnwrapTrainingData(const Arguments& args, cv::vector* images, cv::vector* labels){ +Handle UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, cv::vector* images, cv::vector* labels){ + + if (args.Length() < 1 || !args[0]->IsArray()){ JSTHROW("FaceRecognizer.train takes a list of [ label, image] tuples") } // Iterate through [[label, image], ...] etc, and add matrix / label to vectors - const Local tuples = v8::Array::Cast(*args[0]); + //const + //Local tuples = v8::Array::Cast(*args[0]); + const Local tuples = Local::Cast(args[0]); + const uint32_t length = tuples->Length(); for (uint32_t i=0 ; i val = tuples->Get(i); @@ -157,7 +164,7 @@ Handle UnwrapTrainingData(const Arguments& args, cv::vector* ima JSTHROW("train takes a list of [label, image] tuples") } - Local valarr = v8::Array::Cast(*val); + Local valarr = Local::Cast(val); if (valarr->Length() != 2 || !valarr->Get(0)->IsInt32()){ JSTHROW("train takes a list of [label, image] tuples") @@ -170,10 +177,11 @@ Handle UnwrapTrainingData(const Arguments& args, cv::vector* ima labels->push_back(label); images->push_back(im); } - return v8::Undefined(); + return NanUndefined(); } -NAN_METHOD(FaceRecognizerWrap::TrainSync(const Arguments& args){ + +NAN_METHOD(FaceRecognizerWrap::TrainSync){ SETUP_FUNCTION(FaceRecognizerWrap) cv::vector images; @@ -181,15 +189,15 @@ NAN_METHOD(FaceRecognizerWrap::TrainSync(const Arguments& args){ Handle exception = UnwrapTrainingData(args, &images, &labels); if (!exception->IsUndefined()){ - return exception; + NanReturnValue(exception);//FIXME: not too sure about returning exceptions like this } self->rec->train(images, labels); - return scope.Close(v8::Undefined()); + NanReturnUndefined(); } -NAN_METHOD(FaceRecognizerWrap::UpdateSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::UpdateSync){ SETUP_FUNCTION(FaceRecognizerWrap) @@ -206,16 +214,16 @@ NAN_METHOD(FaceRecognizerWrap::UpdateSync(const Arguments& args){ Handle exception = UnwrapTrainingData(args, &images, &labels); if (!exception->IsUndefined()){ - return exception; + JSTHROW( exception ); } self->rec->update(images, labels); - return scope.Close(v8::Undefined()); + NanReturnUndefined(); } -NAN_METHOD(FaceRecognizerWrap::PredictSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::PredictSync){ SETUP_FUNCTION(FaceRecognizerWrap) cv::Mat im = fromMatrixOrFilename(args[0]);//TODO CHECK! @@ -226,47 +234,47 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync(const Arguments& args){ double confidence = 0.0; self->rec->predict(im, predictedLabel, confidence); - v8::Local res = v8::Object::New(); - res->Set(v8::String::New("id"), v8::Number::New(predictedLabel)); - res->Set(v8::String::New("confidence"), v8::Number::New(confidence)); + v8::Local res = NanNew(); + res->Set(NanNew("id"), NanNew(predictedLabel)); + res->Set(NanNew("confidence"), NanNew(confidence)); - return scope.Close(res); + NanReturnValue(res); } -NAN_METHOD(FaceRecognizerWrap::SaveSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::SaveSync){ SETUP_FUNCTION(FaceRecognizerWrap) if (!args[0]->IsString()){ JSTHROW("Save takes a filename") } - std::string filename = std::string(*v8::String::AsciiValue(args[0]->ToString())); + std::string filename = std::string(*NanAsciiString(args[0]->ToString())); self->rec->save(filename); - return v8::Undefined(); + NanReturnUndefined(); } -NAN_METHOD(FaceRecognizerWrap::LoadSync(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::LoadSync){ SETUP_FUNCTION(FaceRecognizerWrap) if (!args[0]->IsString()){ JSTHROW("Load takes a filename") } - std::string filename = std::string(*v8::String::AsciiValue(args[0]->ToString())); + std::string filename = std::string(*NanAsciiString(args[0]->ToString())); self->rec->load(filename); - return v8::Undefined(); + NanReturnUndefined(); } -NAN_METHOD(FaceRecognizerWrap::GetMat(const Arguments& args){ +NAN_METHOD(FaceRecognizerWrap::GetMat){ SETUP_FUNCTION(FaceRecognizerWrap) if (!args[0]->IsString()){ JSTHROW("getMat takes a key") } - std::string key = std::string(*v8::String::AsciiValue(args[0]->ToString())); + std::string key = std::string(*NanAsciiString(args[0]->ToString())); cv::Mat m = self->rec->getMat(key); - Local im = Matrix::constructor->GetFunction()->NewInstance(); + Local im = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(im); img->mat = m; - return im; + NanReturnValue( im ); } diff --git a/src/HighGUI.cc b/src/HighGUI.cc index 771efea..52d4493 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -7,25 +7,27 @@ Persistent NamedWindow::constructor; void NamedWindow::Init(Handle target) { - HandleScope scope; + NanScope(); // Constructor - constructor = Persistent::New(FunctionTemplate::New(NamedWindow::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("NamedWindow")); + Local ctor = NanNew(NamedWindow::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("NamedWindow")); // Prototype //Local proto = constructor->PrototypeTemplate(); - NODE_SET_PROTOTYPE_METHOD(constructor, "show", Show); - NODE_SET_PROTOTYPE_METHOD(constructor, "destroy", Destroy); - NODE_SET_PROTOTYPE_METHOD(constructor, "blockingWaitKey", BlockingWaitKey); - target->Set(String::NewSymbol("NamedWindow"), constructor->GetFunction()); + NODE_SET_PROTOTYPE_METHOD(ctor, "show", Show); + NODE_SET_PROTOTYPE_METHOD(ctor, "destroy", Destroy); + NODE_SET_PROTOTYPE_METHOD(ctor, "blockingWaitKey", BlockingWaitKey); + + target->Set(NanNew("NamedWindow"), ctor->GetFunction()); }; -NAN_METHOD(NamedWindow::New() { - HandleScope scope; +NAN_METHOD(NamedWindow::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0){ JSTHROW_TYPE("Cannot Instantiate without new") @@ -33,13 +35,13 @@ NAN_METHOD(NamedWindow::New() { NamedWindow* win; if (args.Length() == 1){ - win = new NamedWindow(std::string(*v8::String::AsciiValue(args[0]->ToString())), 0); + win = new NamedWindow(std::string(*NanAsciiString(args[0]->ToString())), 0); } else if (args.Length() == 2){ - win = new NamedWindow(std::string(*v8::String::AsciiValue(args[0]->ToString())), 0); + win = new NamedWindow(std::string(*NanAsciiString(args[0]->ToString())), 0); } win->Wrap(args.Holder()); - return scope.Close(args.Holder()); + NanReturnValue(args.Holder()); } @@ -50,23 +52,23 @@ NamedWindow::NamedWindow(const std::string& name, int f){ } -NAN_METHOD(NamedWindow::Show(const v8::Arguments& args){ +NAN_METHOD(NamedWindow::Show){ SETUP_FUNCTION(NamedWindow) Matrix *im = ObjectWrap::Unwrap(args[0]->ToObject()); cv::imshow(self->winname, im->mat); - return scope.Close(args.Holder()); + NanReturnValue(args.Holder()); } -NAN_METHOD(NamedWindow::Destroy(const v8::Arguments& args){ +NAN_METHOD(NamedWindow::Destroy){ SETUP_FUNCTION(NamedWindow) cv::destroyWindow(self->winname); - return scope.Close(args.Holder()); + NanReturnValue(args.Holder()); } -NAN_METHOD(NamedWindow::BlockingWaitKey(const v8::Arguments& args){ - HandleScope scope; +NAN_METHOD(NamedWindow::BlockingWaitKey){ + NanScope(); //SETUP_FUNCTION(NamedWindow) int time = 0; @@ -80,5 +82,5 @@ NAN_METHOD(NamedWindow::BlockingWaitKey(const v8::Arguments& args){ int res = cv::waitKey(time); - return scope.Close(Number::New(res)); + NanReturnValue(NanNew(res)); } diff --git a/src/Matrix.cc b/src/Matrix.cc index a4bd78b..ce83fc9 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -109,8 +109,6 @@ Matrix::Init(Handle target) { NODE_SET_PROTOTYPE_METHOD(ctor, "meanWithMask", MeanWithMask); NODE_SET_PROTOTYPE_METHOD(ctor, "shift", Shift); - //target->Set(NanNew("Matrix"), m->GetFunction()); - //target->Set( NanNew("Matrix"), ctor->GetFunction() ); target->Set(NanNew("Matrix"), ctor->GetFunction()); }; @@ -438,7 +436,7 @@ NAN_METHOD(Matrix::ToBuffer){ NanReturnValue(actualBuffer); } -/*FIXME: look into this +/*FIXME: async look into this struct matrixToBuffer_baton_t { Matrix *mm; Persistent cb; diff --git a/src/Point.cc b/src/Point.cc index cbf06a4..0c8af32 100755 --- a/src/Point.cc +++ b/src/Point.cc @@ -6,61 +6,72 @@ v8::Persistent Point::constructor; void Point::Init(Handle target) { - HandleScope scope; + NanScope(); // Constructor - constructor = Persistent::New(FunctionTemplate::New(Point::New)); + /*constructor = Persistent::New(FunctionTemplate::New(Point::New)); constructor->InstanceTemplate()->SetInternalFieldCount(1); constructor->SetClassName(String::NewSymbol("Point")); // Prototype Local proto = constructor->PrototypeTemplate(); proto->SetAccessor(String::NewSymbol("x"), GetX, RaiseImmutable); - proto->SetAccessor(String::NewSymbol("y"), GetY, RaiseImmutable); + proto->SetAccessor(String::NewSymbol("y"), GetY, RaiseImmutable);*/ - NODE_SET_PROTOTYPE_METHOD(constructor, "dot", Dot); + Local ctor = NanNew(Point::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("Point")); + + Local proto = ctor->PrototypeTemplate(); + proto->SetAccessor(NanNew("x"), GetX);//, RaiseImmutable); + proto->SetAccessor(NanNew("y"), GetY);//, RaiseImmutable); + + + NODE_SET_PROTOTYPE_METHOD(ctor, "dot", Dot); - target->Set(String::NewSymbol("Point"), constructor->GetFunction()); + target->Set(NanNew("Point"), ctor->GetFunction()); }; -NAN_METHOD(Point::New() { - HandleScope scope; +NAN_METHOD(Point::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0) - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Cannot Instantiate without new"))); + return NanThrowTypeError("Cannot Instantiate without new"); double x = 0, y = 0; if (args[0]->IsNumber()) x = args[0]->NumberValue(); if (args[1]->IsNumber()) y = args[1]->NumberValue(); Point *pt = new Point(x, y); pt->Wrap(args.This()); - return args.This(); + NanReturnValue(args.This()); } -NAN_METHOD(Point::GetX(Local prop, const AccessorInfo &info) { - HandleScope scope; - Point *pt = ObjectWrap::Unwrap(info.This()); - return scope.Close(Number::New(pt->point.x)); +NAN_GETTER(Point::GetX){ //(Local prop, const AccessorInfo &info) { + NanScope(); + Point *pt = ObjectWrap::Unwrap(args.This()); + NanReturnValue(NanNew(pt->point.x)); } -NAN_METHOD(Point::GetY(Local prop, const AccessorInfo &info) { - HandleScope scope; - Point *pt = ObjectWrap::Unwrap(info.This()); - return scope.Close(Number::New(pt->point.y)); +NAN_GETTER(Point::GetY){//(Local prop, const AccessorInfo &info) { + NanScope(); + Point *pt = ObjectWrap::Unwrap(args.This()); + NanReturnValue(NanNew(pt->point.y)); } +/*FIXME: add this back, possibly in a setter void Point::RaiseImmutable(Local property, Local value, const AccessorInfo& info) { - v8::ThrowException(v8::Exception::TypeError(v8::String::New("Point is immutable"))); -} + NanThrowTypeError("Point is immutable"); +} */ -NAN_METHOD(Point::Dot(const v8::Arguments& args){ - HandleScope scope; +NAN_METHOD(Point::Dot){ + NanScope(); Point *p1 = ObjectWrap::Unwrap(args.This()); Point *p2 = ObjectWrap::Unwrap(args[0]->ToObject()); // Since V 2.3 Native Dot no longer supported - return scope.Close(Number::New(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); + NanReturnValue(NanNew(p1->point.x * p2->point.x + p1->point.y * p2->point.y)); } diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index bac4e64..347ed15 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -23,31 +23,32 @@ struct videocapture_baton { void VideoCaptureWrap::Init(Handle target) { - HandleScope scope; - - // Constructor - constructor = Persistent::New(FunctionTemplate::New(VideoCaptureWrap::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("VideoCapture")); + NanScope(); // Prototype //Local proto = constructor->PrototypeTemplate(); + + //Class + Local ctor = NanNew(VideoCaptureWrap::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("VideoCapture")); - NODE_SET_PROTOTYPE_METHOD(constructor, "read", Read); - NODE_SET_PROTOTYPE_METHOD(constructor, "setWidth", SetWidth); - NODE_SET_PROTOTYPE_METHOD(constructor, "setHeight", SetHeight); - NODE_SET_PROTOTYPE_METHOD(constructor, "setPosition", SetPosition); - NODE_SET_PROTOTYPE_METHOD(constructor, "close", Close); - NODE_SET_PROTOTYPE_METHOD(constructor, "ReadSync", ReadSync); + NODE_SET_PROTOTYPE_METHOD(ctor, "read", Read); + NODE_SET_PROTOTYPE_METHOD(ctor, "setWidth", SetWidth); + NODE_SET_PROTOTYPE_METHOD(ctor, "setHeight", SetHeight); + NODE_SET_PROTOTYPE_METHOD(ctor, "setPosition", SetPosition); + NODE_SET_PROTOTYPE_METHOD(ctor, "close", Close); + NODE_SET_PROTOTYPE_METHOD(ctor, "ReadSync", ReadSync); - target->Set(String::NewSymbol("VideoCapture"), constructor->GetFunction()); + target->Set(NanNew("VideoCapture"), ctor->GetFunction()); }; -NAN_METHOD(VideoCaptureWrap::New() { - HandleScope scope; +NAN_METHOD(VideoCaptureWrap::New) { + NanScope(); if (args.This()->InternalFieldCount() == 0) - return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Cannot Instantiate without new"))); + return NanThrowTypeError("Cannot Instantiate without new"); VideoCaptureWrap *v; @@ -55,94 +56,95 @@ NAN_METHOD(VideoCaptureWrap::New() { v = new VideoCaptureWrap(args[0]->NumberValue()); } else { //TODO - assumes that we have string, verify - v = new VideoCaptureWrap(std::string(*v8::String::AsciiValue(args[0]->ToString()))); + v = new VideoCaptureWrap(std::string(*NanAsciiString(args[0]->ToString()))); } v->Wrap(args.This()); - return args.This(); + NanReturnValue(args.This()); } VideoCaptureWrap::VideoCaptureWrap(int device){ - HandleScope scope; + NanScope(); cap.open(device); if(!cap.isOpened()){ - v8::ThrowException(v8::Exception::Error(String::New("Camera could not be opened"))); + NanThrowError("Camera could not be opened"); } } VideoCaptureWrap::VideoCaptureWrap(const std::string& filename){ - HandleScope scope; + NanScope(); cap.open(filename); // TODO! At the moment this only takes a full path - do relative too. if(!cap.isOpened()){ - v8::ThrowException(v8::Exception::Error(String::New("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){ - HandleScope scope; + NanScope(); VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); if(args.Length() != 1) - return scope.Close(Undefined()); + NanReturnUndefined(); int w = args[0]->IntegerValue(); if(v->cap.isOpened()) v->cap.set(CV_CAP_PROP_FRAME_WIDTH, w); - return scope.Close(Undefined()); + NanReturnUndefined(); } -NAN_METHOD(VideoCaptureWrap::SetHeight(){ +NAN_METHOD(VideoCaptureWrap::SetHeight){ - HandleScope scope; + NanScope(); VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); if(args.Length() != 1) - return scope.Close(Undefined()); + NanReturnUndefined(); int h = args[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_FRAME_HEIGHT, h); - return Undefined(); + NanReturnUndefined(); } -NAN_METHOD(VideoCaptureWrap::SetPosition(){ +NAN_METHOD(VideoCaptureWrap::SetPosition){ - HandleScope scope; + NanScope(); VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); if(args.Length() != 1) - return scope.Close(Undefined()); + NanReturnUndefined(); int pos = args[0]->IntegerValue(); v->cap.set(CV_CAP_PROP_POS_FRAMES, pos); - return Undefined(); + NanReturnUndefined(); } -NAN_METHOD(VideoCaptureWrap::Close(){ +NAN_METHOD(VideoCaptureWrap::Close){ - HandleScope scope; + NanScope(); VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); v->cap.release(); - return Undefined(); + NanReturnUndefined(); } -NAN_METHOD(VideoCaptureWrap::Read() { +/*FIXME: migrate async method +NAN_METHOD(VideoCaptureWrap::Read) { - HandleScope scope; + NanScope(); VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); REQ_FUN_ARG(0, cb); @@ -154,10 +156,12 @@ NAN_METHOD(VideoCaptureWrap::Read() { baton->request.data = baton; uv_queue_work(uv_default_loop(), &baton->request, AsyncRead, (uv_after_work_cb)AfterAsyncRead); - return Undefined(); + + NanReturnUndefined(); } + void AsyncRead(uv_work_t *req) { videocapture_baton *baton = static_cast(req->data); @@ -167,7 +171,7 @@ void AsyncRead(uv_work_t *req) { void AfterAsyncRead(uv_work_t *req) { - HandleScope scope; + NanScope(); videocapture_baton *baton = static_cast(req->data); @@ -188,19 +192,19 @@ void AfterAsyncRead(uv_work_t *req) { delete baton; } +*/ +NAN_METHOD(VideoCaptureWrap::ReadSync) { -NAN_METHOD(VideoCaptureWrap::ReadSync() { - - HandleScope scope; + NanScope(); VideoCaptureWrap *v = ObjectWrap::Unwrap(args.This()); - Local im_to_return= Matrix::constructor->GetFunction()->NewInstance(); + Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *img = ObjectWrap::Unwrap(im_to_return); v->cap.read(img->mat); - return scope.Close(im_to_return); + NanReturnValue(im_to_return); } diff --git a/src/init.cc b/src/init.cc index ed4d20d..f82a181 100755 --- a/src/init.cc +++ b/src/init.cc @@ -1,20 +1,21 @@ #include "OpenCV.h" -/*#include "Point.h" + +#include "Point.h" #include "Matrix.h" #include "CascadeClassifierWrap.h" #include "VideoCaptureWrap.h" #include "Contours.h" #include "CamShift.h" #include "HighGUI.h" -#include "FaceRecognizer.h"*/ +#include "FaceRecognizer.h" extern "C" void init(Handle target) { - //HandleScope scope; NanScope(); OpenCV::Init(target); - /*Point::Init(target); + + Point::Init(target); Matrix::Init(target); CascadeClassifierWrap::Init(target); VideoCaptureWrap::Init(target); @@ -24,7 +25,7 @@ init(Handle target) { #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4 FaceRecognizerWrap::Init(target); - #endif*/ + #endif }; From 52a1e827f2c113bff8b5b1007566da03dd881b98 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Sun, 21 Sep 2014 15:54:36 +0200 Subject: [PATCH 08/12] - implemented NAN version of async methods for Matrix.cc --- src/Matrix.cc | 223 ++++++++++++++++++++++---------------------------- 1 file changed, 100 insertions(+), 123 deletions(-) diff --git a/src/Matrix.cc b/src/Matrix.cc index ce83fc9..07646a9 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -436,29 +436,70 @@ NAN_METHOD(Matrix::ToBuffer){ NanReturnValue(actualBuffer); } -/*FIXME: async look into this -struct matrixToBuffer_baton_t { - Matrix *mm; - Persistent cb; - std::vector res; - std::vector params; + + +class AsyncToBufferWorker : public NanAsyncWorker { + public: + AsyncToBufferWorker(NanCallback *callback, Matrix* matrix, string ext, vector params ) + : NanAsyncWorker(callback), matrix(matrix), ext(ext), params(params) {} + ~AsyncToBufferWorker() {} + + void Execute () { + std::vector vec(0); + + //std::vector params(0);//CV_IMWRITE_JPEG_QUALITY 90 + + cv::imencode(ext, this->matrix->mat, vec, this->params); + + res = vec; + } + + // Executed when the async work is complete + // this function will be run inside the main event loop + // so it is safe to use V8 again + void HandleOKCallback () { + NanScope(); + + Local buf = NanNewBufferHandle(res.size()); + uchar* data = (uchar*) Buffer::Data(buf); + memcpy(data, &res[0], res.size());//dest, source, size + + v8::Local globalObj = NanGetCurrentContext()->Global(); + v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); + v8::Handle constructorArgs[3] = {buf, NanNew(res.size()), NanNew(0)}; + v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); + + + Local argv[] = { + NanNull() + , actualBuffer + }; + + TryCatch try_catch; + callback->Call(2, argv); + if (try_catch.HasCaught()) { + FatalException(try_catch); + } + + } + + private: + Matrix* matrix; + //char* filename; std::string ext; - uv_work_t request; + std::vector params; + std::vector res; }; -void AsyncToBufferAsync(uv_work_t *req); -void AfterAsyncToBufferAsync(uv_work_t *req); NAN_METHOD(Matrix::ToBufferAsync){ SETUP_FUNCTION(Matrix) REQ_FUN_ARG(0, cb); - - matrixToBuffer_baton_t *baton = new matrixToBuffer_baton_t(); - - std::string ext = std::string(".jpg"); + std::vector params; + // See if the options argument is passed if ((args.Length() > 1) && (args[1]->IsObject())) { // Get this options argument @@ -471,80 +512,24 @@ NAN_METHOD(Matrix::ToBufferAsync){ } if (options->Has(NanNew("jpegQuality"))) { int compression = options->Get(NanNew("jpegQuality"))->IntegerValue(); - baton->params.push_back(CV_IMWRITE_JPEG_QUALITY); - baton->params.push_back(compression); + params.push_back(CV_IMWRITE_JPEG_QUALITY); + params.push_back(compression); } if (options->Has(NanNew("pngCompression"))) { int compression = options->Get(NanNew("pngCompression"))->IntegerValue(); - baton->params.push_back(CV_IMWRITE_PNG_COMPRESSION); - baton->params.push_back(compression); + params.push_back(CV_IMWRITE_PNG_COMPRESSION); + params.push_back(compression); } } - baton->ext = ext; - baton->mm = self; NanCallback *callback = new NanCallback(cb.As()); + + NanAsyncQueueWorker(new AsyncToBufferWorker(callback, self, ext, params)); - baton->cb = callback; //NAN_WEAK_CALLBACK(cb);//Persistent::New(cb); - baton->request.data = baton; - - uv_queue_work(uv_default_loop(), &baton->request, AsyncToBufferAsync, (uv_after_work_cb)AfterAsyncToBufferAsync); - NanReturnUndefined(); } -void AsyncToBufferAsync(uv_work_t *req) { - matrixToBuffer_baton_t *baton = static_cast(req->data); - - std::vector vec(0); - //std::vector params(0);//CV_IMWRITE_JPEG_QUALITY 90 - - const char * ext = (const char *) baton->ext.c_str(); - cv::imencode(ext, baton->mm->mat, vec, baton->params); - - - baton->res = vec; -} - -void AfterAsyncToBufferAsync(uv_work_t *req) { - - NanScope(); - //FIXME: too many errors here : how to handle integers and node::buffer? - /*matrixToBuffer_baton_t *baton = static_cast(req->data); -// ev_unref(EV_DEFAULT_UC); -// baton->cc->Unref(); - - Local argv[2]; - - argv[0] = NanNull(); - - v8::Integer resSize = NanNew(baton->res.size()); - node::Buffer *buf = node::Buffer(resSize); - uchar* data = (uchar*) Buffer::Data(buf); - memcpy(data, &baton->res[0], resSize); - - v8::Local globalObj = v8::Context::GetCurrent()->Global(); - v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); - v8::Handle constructorArgs[3] = {buf->handle_, v8::Integer::New(baton->res.size()), v8::Integer::New(0)}; - v8::Local actualBuffer = bufferConstructor->NewInstance(3, constructorArgs); - - argv[1] = actualBuffer; - - TryCatch try_catch; - - baton->cb->Call(Context::GetCurrent()->Global(), 2, argv); - - if (try_catch.HasCaught()) { - FatalException(try_catch); - } - - baton->cb.Dispose(); - - delete baton; - -// return 0; -}*/ NAN_METHOD(Matrix::Ellipse){ SETUP_FUNCTION(Matrix) @@ -697,19 +682,46 @@ NAN_METHOD(Matrix::Save) { } -//FIXME:All this is for async save, see here for nan example: https://github.com/rvagg/nan/blob/c579ae858ae3208d7e702e8400042ba9d48fa64b/examples/async_pi_estimate/async.cc -/* -struct save_baton_t { - Matrix *mm; - Persistent cb; - std::string filename; - int res; - uv_work_t request; +//All this is for async save, see here for nan example: https://github.com/rvagg/nan/blob/c579ae858ae3208d7e702e8400042ba9d48fa64b/examples/async_pi_estimate/async.cc +class AsyncSaveWorker : public NanAsyncWorker { + public: + AsyncSaveWorker(NanCallback *callback, Matrix* matrix, char* filename) + : NanAsyncWorker(callback), matrix(matrix), filename(filename) {} + ~AsyncSaveWorker() {} + + // Executed inside the worker-thread. + // It is not safe to access V8, or V8 data structures + // here, so everything we need for input and output + // should go on `this`. + void Execute () { + res = cv::imwrite(this->filename, this->matrix->mat); + } + + // Executed when the async work is complete + // this function will be run inside the main event loop + // so it is safe to use V8 again + void HandleOKCallback () { + NanScope(); + + Local argv[] = { + NanNull() + , NanNew(res) + }; + + TryCatch try_catch; + callback->Call(2, argv); + if (try_catch.HasCaught()) { + FatalException(try_catch); + } + } + + private: + Matrix* matrix; + char* filename; + int res; }; -void DoSaveAsync(uv_work_t *req); -void AfterSaveAsync(uv_work_t *req); NAN_METHOD(Matrix::SaveAsync){ SETUP_FUNCTION(Matrix) @@ -720,49 +732,14 @@ NAN_METHOD(Matrix::SaveAsync){ NanAsciiString filename(args[0]); REQ_FUN_ARG(1, cb); - - save_baton_t *baton = new save_baton_t(); - baton->mm = self; - baton->cb = new NanCallback(cb.As()); //Persistent::New(cb);//NanCallback *callback = - baton->filename = *filename; - baton->request.data = baton; - - //uv_queue_work(uv_default_loop(), &baton->request, DoSaveAsync, (uv_after_work_cb)AfterSaveAsync); - //TODO: swtich to NanAsyncQueueWorker( + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncSaveWorker(callback, self, *filename)); + NanReturnUndefined(); } -void DoSaveAsync(uv_work_t *req) { - save_baton_t *baton = static_cast(req->data); - - int res = cv::imwrite(baton->filename.c_str(), baton->mm->mat); - baton->res = res; -} - -void AfterSaveAsync(uv_work_t *req) { - NanScope(); - save_baton_t *baton = static_cast(req->data); - - Local argv[2]; // (err, result) - - argv[0] = NanNull();//Local::New(Null()); - argv[1] = NanNew(baton->res); - - TryCatch try_catch; - - baton->cb->Call(Context::GetCurrent()->Global(), 2, argv); - - if (try_catch.HasCaught()) { - FatalException(try_catch); - } - - baton->cb.Dispose(); - - delete baton; -}*/ - NAN_METHOD(Matrix::Eye){ NanScope(); From 416fe0a6d535e4c54b15e52769b4ce03303b07a2 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Sun, 21 Sep 2014 16:08:43 +0200 Subject: [PATCH 09/12] - migrate the async methods of VideoCaptureWrap to NAN --- src/VideoCaptureWrap.cc | 100 +++++++++++++++++++++------------------- 1 file changed, 53 insertions(+), 47 deletions(-) diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index 347ed15..05a55ff 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -23,16 +23,16 @@ struct videocapture_baton { void VideoCaptureWrap::Init(Handle target) { - NanScope(); + NanScope(); - // Prototype - //Local proto = constructor->PrototypeTemplate(); - //Class Local ctor = NanNew(VideoCaptureWrap::New); NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->SetClassName(NanNew("VideoCapture")); + + // Prototype + //Local proto = constructor->PrototypeTemplate(); NODE_SET_PROTOTYPE_METHOD(ctor, "read", Read); NODE_SET_PROTOTYPE_METHOD(ctor, "setWidth", SetWidth); @@ -141,7 +141,53 @@ NAN_METHOD(VideoCaptureWrap::Close){ NanReturnUndefined(); } -/*FIXME: migrate async method + +class AsyncVCWorker : public NanAsyncWorker { + public: + AsyncVCWorker(NanCallback *callback, VideoCaptureWrap* vc, Matrix* matrix) + : NanAsyncWorker(callback), vc(vc), matrix(matrix) {} + ~AsyncVCWorker() {} + + // Executed inside the worker-thread. + // It is not safe to access V8, or V8 data structures + // here, so everything we need for input and output + // should go on `this`. + void Execute () { + this->vc->cap.read(matrix->mat); + } + + // Executed when the async work is complete + // this function will be run inside the main event loop + // so it is safe to use V8 again + void HandleOKCallback () { + NanScope(); + + Local im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *img = ObjectWrap::Unwrap(im_to_return); + cv::Mat mat; + mat = this->matrix->mat; + img->mat = mat; + + Local argv[] = { + NanNull() + , im_to_return + }; + + TryCatch try_catch; + callback->Call(2, argv); + if (try_catch.HasCaught()) { + FatalException(try_catch); + } + } + + private: + VideoCaptureWrap *vc; + Matrix* matrix; + int res; +}; + + + NAN_METHOD(VideoCaptureWrap::Read) { NanScope(); @@ -149,52 +195,13 @@ NAN_METHOD(VideoCaptureWrap::Read) { REQ_FUN_ARG(0, cb); - videocapture_baton *baton = new videocapture_baton(); - baton->vc = v; - baton->cb = Persistent::New(cb); - baton->im = new Matrix(); - baton->request.data = baton; - - uv_queue_work(uv_default_loop(), &baton->request, AsyncRead, (uv_after_work_cb)AfterAsyncRead); + NanCallback *callback = new NanCallback(cb.As()); + NanAsyncQueueWorker(new AsyncVCWorker(callback, v, new Matrix())); NanReturnUndefined(); - } -void AsyncRead(uv_work_t *req) { - videocapture_baton *baton = static_cast(req->data); - - baton->vc->cap.read(baton->im->mat); -} - - -void AfterAsyncRead(uv_work_t *req) { - - NanScope(); - - videocapture_baton *baton = static_cast(req->data); - - Local im_to_return= Matrix::constructor->GetFunction()->NewInstance(); - Matrix *img = ObjectWrap::Unwrap(im_to_return); - cv::Mat mat; - mat = baton->im->mat; - - img->mat = mat; - Local argv[2]; - - argv[0] = Local::New(Null()); - argv[1] = im_to_return; - - baton->cb->Call(Context::GetCurrent()->Global(), 2, argv); - baton->cb.Dispose(); - - delete baton; - -} -*/ - - NAN_METHOD(VideoCaptureWrap::ReadSync) { NanScope(); @@ -206,5 +213,4 @@ NAN_METHOD(VideoCaptureWrap::ReadSync) { v->cap.read(img->mat); NanReturnValue(im_to_return); - } From cac848fa87d6bd273b31e256f942b80802c0ccb1 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Mon, 29 Sep 2014 11:52:58 +0200 Subject: [PATCH 10/12] - added missing Nan conversion of async method AsyncDetectMultiScale --- src/CascadeClassifierWrap.cc | 173 ++++++++++++++++------------------- 1 file changed, 81 insertions(+), 92 deletions(-) diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index e35821a..5c8b3d5 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -1,11 +1,9 @@ #include "CascadeClassifierWrap.h" #include "OpenCV.h" #include "Matrix.h" +#include -void AsyncDetectMultiScale(uv_work_t *req); -void AfterAsyncDetectMultiScale(uv_work_t *req); - Persistent CascadeClassifierWrap::constructor; void @@ -48,21 +46,83 @@ CascadeClassifierWrap::CascadeClassifierWrap(v8::Value* fileName){ } -struct classifier_baton_t { - CascadeClassifierWrap *cc; - Persistent cb; - Matrix *im; - double scale; - int neighbors; - int minw; - int minh; - int sleep_for; - std::vector res; - uv_work_t request; + +class AsyncDetectMultiScale : public NanAsyncWorker { + public: + AsyncDetectMultiScale(NanCallback *callback, CascadeClassifierWrap *cc, Matrix* im, double scale, int neighbors, int minw, int minh, int sleep_for) : NanAsyncWorker(callback), cc(cc), im(im), scale(scale), neighbors(neighbors), minw(minw), minh(minh), sleep_for(sleep_for) {} + ~AsyncDetectMultiScale() {} + + void Execute () { + std::vector objects; + + cv::Mat gray; + + if(this->im->mat.channels() != 1) + cvtColor(this->im->mat, gray, CV_BGR2GRAY); + + equalizeHist( gray, gray); + this->cc->cc.detectMultiScale(gray, objects, this->scale, this->neighbors, 0 | CV_HAAR_SCALE_IMAGE, cv::Size(this->minw, this->minh)); + + res = objects; + } + + void HandleOKCallback () { + NanScope(); + // ev_unref(EV_DEFAULT_UC); + // this->matrix->Unref(); + + v8::Local arr = NanNew(this->res.size()); + + for(unsigned int i = 0; i < this->res.size(); i++ ){ + v8::Local x = NanNew(); + x->Set(NanNew("x"), NanNew(this->res[i].x)); + x->Set(NanNew("y"), NanNew(this->res[i].y)); + x->Set(NanNew("width"), NanNew(this->res[i].width)); + x->Set(NanNew("height"), NanNew(this->res[i].height)); + arr->Set(i, x); + } + + //argv[1] = arr; + Local argv[] = { + NanNull() + , arr + }; + + TryCatch try_catch; + callback->Call(2, argv); + if (try_catch.HasCaught()) { + FatalException(try_catch); + } + + } + + private: + CascadeClassifierWrap *cc; + Matrix* im; + double scale; + int neighbors; + int minw; + int minh; + int sleep_for; + std::vector res; + + /* baton->cc = self; + baton->cb = Persistent::New(cb); + baton->im = im; + baton->scale = scale; + baton->neighbors = neighbors; + baton->minw = minw; + baton->minh = minh; + baton->sleep_for = 1; + baton->request.data = baton; +};*/ + }; + + NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ NanScope(); @@ -90,88 +150,17 @@ NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ minh = args[5]->IntegerValue(); } -/*FIXME: convert async - classifier_baton_t *baton = new classifier_baton_t(); - baton->cc = self; - baton->cb = Persistent::New(cb); - baton->im = im; - baton->scale = scale; - baton->neighbors = neighbors; - baton->minw = minw; - baton->minh = minh; - baton->sleep_for = 1; - baton->request.data = baton; -// self->Ref(); +//FIXME: convert async + /* classifier_baton_t *baton = new classifier_baton_t(); // eio_custom(EIO_DetectMultiScale, EIO_PRI_DEFAULT, EIO_AfterDetectMultiScale, baton); // ev_ref(EV_DEFAULT_UC); - uv_queue_work(uv_default_loop(), &baton->request, AsyncDetectMultiScale, (uv_after_work_cb)AfterAsyncDetectMultiScale); + uv_queue_work(uv_default_loop(), &baton->request, AsyncDetectMultiScale, (uv_after_work_cb)AfterAsyncDetectMultiScale);*/ - return Undefined(); + NanCallback *callback = new NanCallback(cb.As()); + + NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, neighbors, minw, minh, 1) ); NanReturnUndefined(); - */ + } - -/*FIXME: convert async -void AsyncDetectMultiScale(uv_work_t *req) { - classifier_baton_t *baton = static_cast(req->data); - -// sleep(baton->sleep_for); - - std::vector objects; - - cv::Mat gray; - - if(baton->im->mat.channels() != 1) - cvtColor(baton->im->mat, gray, CV_BGR2GRAY); - - - equalizeHist( gray, gray); - baton->cc->cc.detectMultiScale(gray, objects, baton->scale, baton->neighbors, 0 | CV_HAAR_SCALE_IMAGE, cv::Size(baton->minw, baton->minh)); - - baton->res = objects; - - -} - -void AfterAsyncDetectMultiScale(uv_work_t *req) { - - NanScope(); - classifier_baton_t *baton = static_cast(req->data); -// ev_unref(EV_DEFAULT_UC); -// baton->cc->Unref(); - - Local argv[2]; - - argv[0] = Local::New(Null()); - - - v8::Local arr = v8::Array::New(baton->res.size()); - - for(unsigned int i = 0; i < baton->res.size(); i++ ){ - v8::Local x = v8::Object::New(); - x->Set(v8::String::New("x"), v8::Number::New(baton->res[i].x)); - x->Set(v8::String::New("y"), v8::Number::New(baton->res[i].y)); - x->Set(v8::String::New("width"), v8::Number::New(baton->res[i].width)); - x->Set(v8::String::New("height"), v8::Number::New(baton->res[i].height)); - arr->Set(i, x); - } - - argv[1] = arr; - - TryCatch try_catch; - - baton->cb->Call(Context::GetCurrent()->Global(), 2, argv); - - if (try_catch.HasCaught()) { - FatalException(try_catch); - } - - baton->cb.Dispose(); - - delete baton; - -// return 0; -} -*/ From a5a4b59ff3bc0a16eb90202d017d58a3b97eeeb8 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Mon, 29 Sep 2014 12:18:05 +0200 Subject: [PATCH 11/12] - fixed immutability of Point class with Nan --- src/Point.cc | 11 +++++------ src/Point.h | 9 ++------- 2 files changed, 7 insertions(+), 13 deletions(-) diff --git a/src/Point.cc b/src/Point.cc index 0c8af32..3ee1d00 100755 --- a/src/Point.cc +++ b/src/Point.cc @@ -24,8 +24,8 @@ Point::Init(Handle target) { ctor->SetClassName(NanNew("Point")); Local proto = ctor->PrototypeTemplate(); - proto->SetAccessor(NanNew("x"), GetX);//, RaiseImmutable); - proto->SetAccessor(NanNew("y"), GetY);//, RaiseImmutable); + proto->SetAccessor(NanNew("x"), GetX, RaiseImmutable);//, RaiseImmutable); + proto->SetAccessor(NanNew("y"), GetY, RaiseImmutable);//, RaiseImmutable); NODE_SET_PROTOTYPE_METHOD(ctor, "dot", Dot); @@ -59,11 +59,10 @@ NAN_GETTER(Point::GetY){//(Local prop, const AccessorInfo &info) { NanReturnValue(NanNew(pt->point.y)); } -/*FIXME: add this back, possibly in a setter -void -Point::RaiseImmutable(Local property, Local value, const AccessorInfo& info) { + +NAN_SETTER(Point::RaiseImmutable){ NanThrowTypeError("Point is immutable"); -} */ +} NAN_METHOD(Point::Dot){ NanScope(); diff --git a/src/Point.h b/src/Point.h index fd5bc84..ca8b218 100755 --- a/src/Point.h +++ b/src/Point.h @@ -7,18 +7,13 @@ class Point: public node::ObjectWrap { CvPoint2D32f point; static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); Point(double x, double y); - //static Handle GetX(Local prop, const AccessorInfo &info); static NAN_GETTER(GetX); - //static Handle GetY(Local prop, const AccessorInfo &info); static NAN_GETTER(GetY); - - //static void RaiseImmutable(Local property, Local value, const AccessorInfo& info); - static NAN_METHOD(RaiseImmutable); - //static Handle Dot(const v8::Arguments&); + static NAN_SETTER(RaiseImmutable); + static NAN_METHOD(Dot); }; From a42033ac96f3a3506c62b5add536074ffa0801e8 Mon Sep 17 00:00:00 2001 From: Mark Moissette Date: Tue, 30 Sep 2014 21:49:24 +0200 Subject: [PATCH 12/12] - overall cleanup : * removed obsolete code , comments --- src/CamShift.cc | 1 - src/CamShift.h | 1 - src/CascadeClassifierWrap.cc | 19 ------------------- src/CascadeClassifierWrap.h | 4 +--- src/Contours.cc | 3 --- src/Contours.h | 1 - src/FaceRecognizer.h | 1 - src/HighGUI.cc | 2 -- src/HighGUI.h | 2 -- src/Matrix.cc | 15 +++------------ src/Matrix.h | 1 - src/Point.cc | 18 +++++------------- src/VideoCaptureWrap.cc | 3 --- src/VideoCaptureWrap.h | 13 +------------ 14 files changed, 10 insertions(+), 74 deletions(-) diff --git a/src/CamShift.cc b/src/CamShift.cc index 925c739..788a1a4 100644 --- a/src/CamShift.cc +++ b/src/CamShift.cc @@ -26,7 +26,6 @@ TrackedObject::Init(Handle target) { NODE_SET_PROTOTYPE_METHOD(ctor, "track", Track); - //target->Set(String::NewSymbol("TrackedObject"), constructor->GetFunction()); target->Set(NanNew("TrackedObject"), ctor->GetFunction()); }; diff --git a/src/CamShift.h b/src/CamShift.h index c79b090..d421fef 100644 --- a/src/CamShift.h +++ b/src/CamShift.h @@ -14,7 +14,6 @@ class TrackedObject: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); TrackedObject(cv::Mat image, cv::Rect rect, int channel); diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc index 5c8b3d5..d2f8871 100755 --- a/src/CascadeClassifierWrap.cc +++ b/src/CascadeClassifierWrap.cc @@ -69,7 +69,6 @@ class AsyncDetectMultiScale : public NanAsyncWorker { void HandleOKCallback () { NanScope(); - // ev_unref(EV_DEFAULT_UC); // this->matrix->Unref(); v8::Local arr = NanNew(this->res.size()); @@ -107,17 +106,6 @@ class AsyncDetectMultiScale : public NanAsyncWorker { int sleep_for; std::vector res; - /* baton->cc = self; - baton->cb = Persistent::New(cb); - baton->im = im; - baton->scale = scale; - baton->neighbors = neighbors; - baton->minw = minw; - baton->minh = minh; - baton->sleep_for = 1; - baton->request.data = baton; -};*/ - }; @@ -150,13 +138,6 @@ NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){ minh = args[5]->IntegerValue(); } -//FIXME: convert async - /* classifier_baton_t *baton = new classifier_baton_t(); - -// eio_custom(EIO_DetectMultiScale, EIO_PRI_DEFAULT, EIO_AfterDetectMultiScale, baton); -// ev_ref(EV_DEFAULT_UC); - - uv_queue_work(uv_default_loop(), &baton->request, AsyncDetectMultiScale, (uv_after_work_cb)AfterAsyncDetectMultiScale);*/ NanCallback *callback = new NanCallback(cb.As()); diff --git a/src/CascadeClassifierWrap.h b/src/CascadeClassifierWrap.h index fb3c033..36972d9 100755 --- a/src/CascadeClassifierWrap.h +++ b/src/CascadeClassifierWrap.h @@ -6,14 +6,12 @@ class CascadeClassifierWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); CascadeClassifierWrap(v8::Value* fileName); - //static Handle LoadHaarClassifierCascade(const v8::Arguments&); + //static Handle LoadHaarClassifierCascade(const v8::Arguments&); - //static Handle DetectMultiScale(const v8::Arguments&); static NAN_METHOD(DetectMultiScale); static void EIO_DetectMultiScale(uv_work_t *req); diff --git a/src/Contours.cc b/src/Contours.cc index 1038220..786ca9b 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -12,7 +12,6 @@ Contour::Init(Handle target) { NanScope(); //Class/contructor - Local ctor = NanNew(Contour::New); NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); @@ -21,8 +20,6 @@ Contour::Init(Handle target) { // Prototype //Local proto = constructor->PrototypeTemplate(); - - NODE_SET_PROTOTYPE_METHOD(ctor, "point", Point); NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size); NODE_SET_PROTOTYPE_METHOD(ctor, "cornerCount", CornerCount); diff --git a/src/Contours.h b/src/Contours.h index e67c37b..36427a3 100755 --- a/src/Contours.h +++ b/src/Contours.h @@ -9,7 +9,6 @@ class Contour: public node::ObjectWrap { vector > contours; static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); Contour(); diff --git a/src/FaceRecognizer.h b/src/FaceRecognizer.h index 274d691..07a5afd 100644 --- a/src/FaceRecognizer.h +++ b/src/FaceRecognizer.h @@ -11,7 +11,6 @@ class FaceRecognizerWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); FaceRecognizerWrap(cv::Ptr f, int type); diff --git a/src/HighGUI.cc b/src/HighGUI.cc index 52d4493..f2160b9 100644 --- a/src/HighGUI.cc +++ b/src/HighGUI.cc @@ -16,8 +16,6 @@ NamedWindow::Init(Handle target) { ctor->SetClassName(NanNew("NamedWindow")); // Prototype - //Local proto = constructor->PrototypeTemplate(); - NODE_SET_PROTOTYPE_METHOD(ctor, "show", Show); NODE_SET_PROTOTYPE_METHOD(ctor, "destroy", Destroy); NODE_SET_PROTOTYPE_METHOD(ctor, "blockingWaitKey", BlockingWaitKey); diff --git a/src/HighGUI.h b/src/HighGUI.h index faf4ab0..3a18e81 100644 --- a/src/HighGUI.h +++ b/src/HighGUI.h @@ -6,10 +6,8 @@ class NamedWindow: public node::ObjectWrap { std::string winname; int flags; - static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); NamedWindow(const std::string& winname, int flags); diff --git a/src/Matrix.cc b/src/Matrix.cc index 07646a9..8256d1d 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -22,7 +22,6 @@ Matrix::Init(Handle target) { ctor->SetClassName(NanNew("Matrix")); // Prototype - NODE_SET_PROTOTYPE_METHOD(ctor, "row", Row); NODE_SET_PROTOTYPE_METHOD(ctor, "col", Col); @@ -279,7 +278,6 @@ NAN_METHOD(Matrix::Size){ NAN_METHOD(Matrix::Clone){ SETUP_FUNCTION(Matrix) - //Local constructorHandle = NanNew(Matrix::constructor); Local im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); Matrix *m = ObjectWrap::Unwrap(im_h); @@ -418,15 +416,12 @@ NAN_METHOD(Matrix::ToBuffer){ std::vector vec(0); - // We use operator * before the "ext" variable, because it converts String to char * - cv::imencode(ext, self->mat, vec, params); - //Local buf = NanNewBufferHandle((char*)closure->data, closure->len); - //memcpy(Buffer::Data(buf), closure->data, closure->len); + cv::imencode(ext, self->mat, vec, params); Local buf = NanNewBufferHandle(vec.size()); uchar* data = (uchar*) Buffer::Data(buf); - memcpy(data, &vec[0], vec.size());//dest, source, size + memcpy(data, &vec[0], vec.size()); v8::Local globalObj = NanGetCurrentContext()->Global(); v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); @@ -454,15 +449,12 @@ class AsyncToBufferWorker : public NanAsyncWorker { res = vec; } - // Executed when the async work is complete - // this function will be run inside the main event loop - // so it is safe to use V8 again void HandleOKCallback () { NanScope(); Local buf = NanNewBufferHandle(res.size()); uchar* data = (uchar*) Buffer::Data(buf); - memcpy(data, &res[0], res.size());//dest, source, size + memcpy(data, &res[0], res.size()); v8::Local globalObj = NanGetCurrentContext()->Global(); v8::Local bufferConstructor = v8::Local::Cast(globalObj->Get(NanNew("Buffer"))); @@ -485,7 +477,6 @@ class AsyncToBufferWorker : public NanAsyncWorker { private: Matrix* matrix; - //char* filename; std::string ext; std::vector params; std::vector res; diff --git a/src/Matrix.h b/src/Matrix.h index 4ccde47..5dac9e6 100755 --- a/src/Matrix.h +++ b/src/Matrix.h @@ -6,7 +6,6 @@ class Matrix: public node::ObjectWrap { cv::Mat mat; static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); Matrix(); Matrix(cv::Mat other, cv::Rect roi); diff --git a/src/Point.cc b/src/Point.cc index 3ee1d00..328f78c 100755 --- a/src/Point.cc +++ b/src/Point.cc @@ -9,23 +9,15 @@ Point::Init(Handle target) { NanScope(); // Constructor - /*constructor = Persistent::New(FunctionTemplate::New(Point::New)); - constructor->InstanceTemplate()->SetInternalFieldCount(1); - constructor->SetClassName(String::NewSymbol("Point")); - - // Prototype - Local proto = constructor->PrototypeTemplate(); - proto->SetAccessor(String::NewSymbol("x"), GetX, RaiseImmutable); - proto->SetAccessor(String::NewSymbol("y"), GetY, RaiseImmutable);*/ - Local ctor = NanNew(Point::New); NanAssignPersistent(constructor, ctor); ctor->InstanceTemplate()->SetInternalFieldCount(1); ctor->SetClassName(NanNew("Point")); + // Prototype Local proto = ctor->PrototypeTemplate(); - proto->SetAccessor(NanNew("x"), GetX, RaiseImmutable);//, RaiseImmutable); - proto->SetAccessor(NanNew("y"), GetY, RaiseImmutable);//, RaiseImmutable); + proto->SetAccessor(NanNew("x"), GetX, RaiseImmutable); + proto->SetAccessor(NanNew("y"), GetY, RaiseImmutable); NODE_SET_PROTOTYPE_METHOD(ctor, "dot", Dot); @@ -47,13 +39,13 @@ NAN_METHOD(Point::New) { NanReturnValue(args.This()); } -NAN_GETTER(Point::GetX){ //(Local prop, const AccessorInfo &info) { +NAN_GETTER(Point::GetX){ NanScope(); Point *pt = ObjectWrap::Unwrap(args.This()); NanReturnValue(NanNew(pt->point.x)); } -NAN_GETTER(Point::GetY){//(Local prop, const AccessorInfo &info) { +NAN_GETTER(Point::GetY){ NanScope(); Point *pt = ObjectWrap::Unwrap(args.This()); NanReturnValue(NanNew(pt->point.y)); diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc index 05a55ff..89b17c0 100755 --- a/src/VideoCaptureWrap.cc +++ b/src/VideoCaptureWrap.cc @@ -6,9 +6,6 @@ using namespace std; -void AsyncRead(uv_work_t *req); -void AfterAsyncRead(uv_work_t *req); - v8::Persistent VideoCaptureWrap::constructor; struct videocapture_baton { diff --git a/src/VideoCaptureWrap.h b/src/VideoCaptureWrap.h index 1118cec..02c2cf8 100755 --- a/src/VideoCaptureWrap.h +++ b/src/VideoCaptureWrap.h @@ -6,35 +6,24 @@ class VideoCaptureWrap: public node::ObjectWrap { static Persistent constructor; static void Init(Handle target); - //static Handle New(const Arguments &args); static NAN_METHOD(New); VideoCaptureWrap(const std::string& filename); VideoCaptureWrap(int device); - //static Handle Read(const v8::Arguments&); static NAN_METHOD(Read); + static NAN_METHOD(ReadSync); //(Optional) For setting width and height of the input video stream - //static Handle SetWidth(const v8::Arguments&); static NAN_METHOD(SetWidth); - - //static Handle SetHeight(const v8::Arguments&); static NAN_METHOD(SetHeight); // to set frame position - //static Handle SetPosition(const v8::Arguments&); static NAN_METHOD(SetPosition); - //static Handle GetFrameAt(const v8::Arguments&); static NAN_METHOD(GetFrameAt); //close the stream - //static Handle Close(const v8::Arguments&); static NAN_METHOD(Close); - - //experimental - //static Handle ReadSync(const v8::Arguments&); - static NAN_METHOD(ReadSync); };