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

Merge branch 'nodev11.x' of github.com:kaosat-dev/node-opencv into kaosat-dev-nodev11.x

Browse Source 
Conflicts:
	src/Contours.cc
	src/Contours.h
	src/Matrix.cc
	src/VideoCaptureWrap.cc
This commit is contained in:
Peter Braden 2014-10-07 07:56:31 +02:00
commit 19058ecea9
23 changed files with 1080 additions and 1205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
binding.gyp
View File

@ -21,7 +21,8 @@
# For windows
,'include_dirs': [
'<!@(pkg-config --cflags opencv)'
'<!@(pkg-config --cflags opencv)',
"<!(node -e \"require('nan')\")"
]
, 'cflags': [

3
package.json
View File

@ -3,7 +3,8 @@
"description": "Node Bindings to OpenCV",
"author": "Peter Braden <peterbraden@peterbraden.co.uk>",
"dependencies": {
"buffers": "0.1.1"
"buffers": "0.1.1",
"nan": "^1.3.0"
},
"version": "0.7.0",
"devDependencies": {

58
src/BackgroundSubtractor.cc
View File

@ -1,6 +1,7 @@
#include "BackgroundSubtractor.h"
#include "Matrix.h"
#include <iostream>
#include <nan.h>
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4
@ -8,22 +9,23 @@ Persistent<FunctionTemplate> BackgroundSubtractorWrap::constructor;
void
BackgroundSubtractorWrap::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(BackgroundSubtractorWrap::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("BackgroundSubtractor"));
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(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());
};
Handle<Value>
BackgroundSubtractorWrap::New(const Arguments &args) {
HandleScope scope;
NAN_METHOD(BackgroundSubtractorWrap::New) {
NanScope();
if (args.This()->InternalFieldCount() == 0)
JSTHROW_TYPE("Cannot Instantiate without new")
@ -34,12 +36,11 @@ BackgroundSubtractorWrap::New(const Arguments &args) {
pt->Wrap(args.This());
return args.This();
NanReturnValue(args.This());
}
Handle<Value>
BackgroundSubtractorWrap::CreateMOG(const Arguments &args) {
HandleScope scope;
NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) {
NanScope();
int history = 200;
int nmixtures = 5;
@ -53,18 +54,17 @@ BackgroundSubtractorWrap::CreateMOG(const Arguments &args) {
DOUBLE_FROM_ARGS(noiseSigma, 3)
}
Local<Object> n = BackgroundSubtractorWrap::constructor->GetFunction()->NewInstance();
Local<Object> n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::BackgroundSubtractor> bg;
BackgroundSubtractorWrap *pt = new BackgroundSubtractorWrap(bg);
pt->Wrap(n);
return n;
NanReturnValue( n );
};
//Fetch foreground mask
Handle<Value>
BackgroundSubtractorWrap::ApplyMOG(const Arguments &args) {
NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) {
SETUP_FUNCTION(BackgroundSubtractorWrap)
@ -73,15 +73,15 @@ BackgroundSubtractorWrap::ApplyMOG(const Arguments &args) {
Local<Value> argv[2];
if(args.Length() == 0){
argv[0] = String::New("Input image missing");
argv[1] = Local<Value>::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<Object> fgMask = Matrix::constructor->GetFunction()->NewInstance();
Local<Object> fgMask = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(fgMask);
@ -100,7 +100,7 @@ BackgroundSubtractorWrap::ApplyMOG(const Arguments &args) {
}
if (mat.empty()){
return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Error loading file")));
return NanThrowTypeError("Error loading file");
}
cv::Mat _fgMask;
@ -110,22 +110,22 @@ BackgroundSubtractorWrap::ApplyMOG(const Arguments &args) {
mat.release();
argv[0] = Local<Value>::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);
}
};
@ -134,4 +134,4 @@ BackgroundSubtractorWrap::BackgroundSubtractorWrap(cv::Ptr<cv::BackgroundSubtrac
subtractor = _subtractor;
};
#endif
#endif

8
src/BackgroundSubtractor.h
View File

@ -10,12 +10,12 @@ class BackgroundSubtractorWrap: public node::ObjectWrap {
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
BackgroundSubtractorWrap(cv::Ptr<cv::BackgroundSubtractor> bg);
static Handle<Value> CreateMOG(const v8::Arguments&);
static Handle<Value> ApplyMOG(const v8::Arguments&);
static NAN_METHOD(CreateMOG);
static NAN_METHOD(ApplyMOG);
};
#endif
#endif

52
src/CamShift.cc
View File

@ -12,24 +12,26 @@ Persistent<FunctionTemplate> TrackedObject::constructor;
void
TrackedObject::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(TrackedObject::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("TrackedObject"));
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(TrackedObject::New);
NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("TrackedObject"));
// Prototype
//Local<ObjectTemplate> 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(NanNew("TrackedObject"), ctor->GetFunction());
};
Handle<Value>
TrackedObject::New(const Arguments &args) {
HandleScope scope;
NAN_METHOD(TrackedObject::New) {
NanScope();
if (args.This()->InternalFieldCount() == 0){
JSTHROW_TYPE("Cannot Instantiate without new")
@ -53,8 +55,8 @@ TrackedObject::New(const Arguments &args) {
if (args[2]->IsObject()){
Local<Object> 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"){
@ -75,7 +77,7 @@ TrackedObject::New(const Arguments &args) {
to->Wrap(args.This());
return args.This();
NanReturnValue(args.This());
}
@ -120,13 +122,12 @@ TrackedObject::TrackedObject(cv::Mat image, cv::Rect rect, int chan){
Handle<Value>
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();
}
@ -137,7 +138,7 @@ 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);
@ -167,25 +168,24 @@ TrackedObject::Track(const v8::Arguments& args){
self->prev_rect = backup_prev_rect;
}
v8::Local<v8::Array> arr = v8::Array::New(4);
v8::Local<v8::Array> arr = NanNew<Array>(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<Number>(bounds.x));
arr->Set(1, NanNew<Number>(bounds.y));
arr->Set(2, NanNew<Number>(bounds.x + bounds.width));
arr->Set(3, NanNew<Number>(bounds.y + bounds.height));
/*
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<Number>(pts[i].x));
arr->Set(i+1, NanNew<Number>(pts[i].y));
}
*/
return scope.Close(arr);
NanReturnValue(arr);
}

2
src/CamShift.h
View File

@ -14,7 +14,7 @@ class TrackedObject: public node::ObjectWrap {
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
TrackedObject(cv::Mat image, cv::Rect rect, int channel);

199
src/CascadeClassifierWrap.cc
View File

@ -1,78 +1,123 @@
#include "CascadeClassifierWrap.h"
#include "OpenCV.h"
#include "Matrix.h"
#include <nan.h>
void AsyncDetectMultiScale(uv_work_t *req);
void AfterAsyncDetectMultiScale(uv_work_t *req);
Persistent<FunctionTemplate> CascadeClassifierWrap::constructor;
void
CascadeClassifierWrap::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(CascadeClassifierWrap::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("CascadeClassifier"));
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(CascadeClassifierWrap::New);
NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("CascadeClassifier"));
// Prototype
//Local<ObjectTemplate> 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());
};
Handle<Value>
CascadeClassifierWrap::New(const Arguments &args) {
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<Function> cb;
Matrix *im;
double scale;
int neighbors;
int minw;
int minh;
int sleep_for;
std::vector<cv::Rect> 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<cv::Rect> 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();
// this->matrix->Unref();
v8::Local<v8::Array> arr = NanNew<v8::Array>(this->res.size());
for(unsigned int i = 0; i < this->res.size(); i++ ){
v8::Local<v8::Object> x = NanNew<v8::Object>();
x->Set(NanNew("x"), NanNew<Number>(this->res[i].x));
x->Set(NanNew("y"), NanNew<Number>(this->res[i].y));
x->Set(NanNew("width"), NanNew<Number>(this->res[i].width));
x->Set(NanNew("height"), NanNew<Number>(this->res[i].height));
arr->Set(i, x);
}
//argv[1] = arr;
Local<Value> 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<cv::Rect> res;
};
Handle<Value>
CascadeClassifierWrap::DetectMultiScale(const v8::Arguments& args){
HandleScope scope;
NAN_METHOD(CascadeClassifierWrap::DetectMultiScale){
NanScope();
CascadeClassifierWrap *self = ObjectWrap::Unwrap<CascadeClassifierWrap>(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<Matrix>(args[0]->ToObject());
@ -94,87 +139,9 @@ CascadeClassifierWrap::DetectMultiScale(const v8::Arguments& args){
}
classifier_baton_t *baton = new classifier_baton_t();
baton->cc = self;
baton->cb = Persistent<Function>::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();
// 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);
return Undefined();
NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker( new AsyncDetectMultiScale(callback, self, im, scale, neighbors, minw, minh, 1) );
NanReturnUndefined();
}
void AsyncDetectMultiScale(uv_work_t *req) {
classifier_baton_t *baton = static_cast<classifier_baton_t *>(req->data);
// sleep(baton->sleep_for);
std::vector<cv::Rect> 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) {
HandleScope scope;
classifier_baton_t *baton = static_cast<classifier_baton_t *>(req->data);
// ev_unref(EV_DEFAULT_UC);
// baton->cc->Unref();
Local<Value> argv[2];
argv[0] = Local<Value>::New(Null());
v8::Local<v8::Array> arr = v8::Array::New(baton->res.size());
for(unsigned int i = 0; i < baton->res.size(); i++ ){
v8::Local<v8::Object> 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;
}

7
src/CascadeClassifierWrap.h
View File

@ -6,13 +6,14 @@ class CascadeClassifierWrap: public node::ObjectWrap {
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
CascadeClassifierWrap(v8::Value* fileName);
//static Handle<Value> LoadHaarClassifierCascade(const v8::Arguments&);
//static Handle<Value> LoadHaarClassifierCascade(const v8::Arguments&);
static NAN_METHOD(DetectMultiScale);
static Handle<Value> DetectMultiScale(const v8::Arguments&);
static void EIO_DetectMultiScale(uv_work_t *req);
static int EIO_AfterDetectMultiScale(uv_work_t *req);

194
src/Contours.cc
View File

@ -1,5 +1,6 @@
#include "Contours.h"
#include "OpenCV.h"
#include <nan.h>
#include <iostream>
@ -8,62 +9,54 @@ v8::Persistent<FunctionTemplate> Contour::constructor;
void
Contour::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
//Class
v8::Local<v8::FunctionTemplate> m = v8::FunctionTemplate::New(New);
m->SetClassName(v8::String::NewSymbol("Contours"));
// Constructor
constructor = Persistent<FunctionTemplate>::New(m);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("Contours"));
//Class/contructor
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Contour::New);
NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("Contours"));
// Prototype
//Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
NODE_SET_PROTOTYPE_METHOD(constructor, "point", Point);
NODE_SET_PROTOTYPE_METHOD(constructor, "points", Points);
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);
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);
NODE_SET_PROTOTYPE_METHOD(constructor, "hierarchy", Hierarchy);
NODE_SET_PROTOTYPE_METHOD(constructor, "serialize", Serialize);
NODE_SET_PROTOTYPE_METHOD(constructor, "deserialize", Deserialize);
target->Set(String::NewSymbol("Contours"), m->GetFunction());
target->Set(NanNew("Contours"), ctor->GetFunction());
};
Handle<Value>
Contour::New(const Arguments &args) {
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() {
}
Handle<Value>
Contour::Point(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::Point) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
@ -71,13 +64,14 @@ Contour::Point(const Arguments &args) {
cv::Point point = self->contours[pos][index];
Local<Object> data = Object::New();
data->Set(String::NewSymbol("x"), Number::New(point.x));
data->Set(String::NewSymbol("y"), Number::New(point.y));
Local<Object> data = NanNew<Object>();
data->Set(NanNew("x"), NanNew<Number>(point.x));
data->Set(NanNew("y"), NanNew<Number>(point.y));
return scope.Close(data);
NanReturnValue(data);
}
<<<<<<< HEAD
Handle<Value>
Contour::Points(const Arguments &args) {
HandleScope scope;
@ -99,56 +93,55 @@ Contour::Points(const Arguments &args) {
return scope.Close(data);
}
=======
>>>>>>> a42033ac96f3a3506c62b5add536074ffa0801e8
// 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<Value>
Contour::Size(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::Size) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
return scope.Close(Number::New(self->contours.size()));
NanReturnValue(NanNew<Number>(self->contours.size()));
}
Handle<Value>
Contour::CornerCount(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::CornerCount) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
return scope.Close(Number::New(self->contours[pos].size()));
NanReturnValue(NanNew<Number>(self->contours[pos].size()));
}
Handle<Value>
Contour::Area(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::Area) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(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<Number>(contourArea(self->contours)));
NanReturnValue(NanNew<Number>(contourArea(cv::Mat(self->contours[pos]))));
}
Handle<Value>
Contour::ArcLength(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::ArcLength) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
bool isClosed = args[1]->BooleanValue();
return scope.Close(Number::New(arcLength(cv::Mat(self->contours[pos]), isClosed)));
NanReturnValue(NanNew<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
}
Handle<Value>
Contour::ApproxPolyDP(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::ApproxPolyDP) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
@ -159,13 +152,12 @@ Contour::ApproxPolyDP(const Arguments &args) {
approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed);
approxed.copyTo(self->contours[pos]);
return scope.Close(v8::Null());
NanReturnNull();
}
Handle<Value>
Contour::ConvexHull(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::ConvexHull) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
@ -176,81 +168,77 @@ Contour::ConvexHull(const Arguments &args) {
cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise);
hull.copyTo(self->contours[pos]);
return scope.Close(v8::Null());
NanReturnNull();
}
Handle<Value>
Contour::BoundingRect(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::BoundingRect) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos]));
Local<Object> rect = Object::New();
Local<Object> rect = NanNew<Object>();
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<Number>(bounding.x));
rect->Set(NanNew("y"), NanNew<Number>(bounding.y));
rect->Set(NanNew("width"), NanNew<Number>(bounding.width));
rect->Set(NanNew("height"), NanNew<Number>(bounding.height));
return scope.Close(rect);
NanReturnValue(rect);
}
Handle<Value>
Contour::MinAreaRect(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::MinAreaRect) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos]));
Local<Object> rect = Object::New();
rect->Set(String::NewSymbol("angle"), Number::New(minimum.angle));
Local<Object> rect = NanNew<Object>();
rect->Set(NanNew("angle"), NanNew<Number>(minimum.angle));
Local<Object> 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<Object> size = NanNew<Object>();
size->Set(NanNew("height"), NanNew<Number>(minimum.size.height));
size->Set(NanNew("width"), NanNew<Number>(minimum.size.width));
rect->Set(NanNew("size"), size);
Local<Object> center = Object::New();
center->Set(String::NewSymbol("x"), Number::New(minimum.center.x));
center->Set(String::NewSymbol("y"), Number::New(minimum.center.y));
Local<Object> center = NanNew<Object>();
center->Set(NanNew("x"), NanNew<Number>(minimum.center.x));
center->Set(NanNew("y"), NanNew<Number>(minimum.center.y));
v8::Local<v8::Array> points = v8::Array::New(4);
v8::Local<v8::Array> points = NanNew<Array>(4);
cv::Point2f rect_points[4];
minimum.points(rect_points);
for (unsigned int i=0; i<4; i++){
Local<Object> 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<Object> point = NanNew<Object>();
point->Set(NanNew("x"), NanNew<Number>(rect_points[i].x));
point->Set(NanNew("y"), NanNew<Number>(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);
}
Handle<Value>
Contour::IsConvex(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::IsConvex) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
return scope.Close(Boolean::New(isContourConvex(cv::Mat(self->contours[pos]))));
NanReturnValue(NanNew<Boolean>(isContourConvex(cv::Mat(self->contours[pos]))));
}
Handle<Value>
Contour::Moments(const Arguments &args) {
HandleScope scope;
NAN_METHOD(Contour::Moments) {
NanScope();
Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
int pos = args[0]->NumberValue();
@ -258,14 +246,14 @@ Contour::Moments(const Arguments &args) {
/// Get the moments
cv::Moments mu = moments( self->contours[pos], false );
Local<Object> res = Object::New();
Local<Object> res = NanNew<Object>();
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<Number>(mu.m00));
res->Set(NanNew("m10"), NanNew<Number>(mu.m10));
res->Set(NanNew("m01"), NanNew<Number>(mu.m01));
res->Set(NanNew("m11"), NanNew<Number>(mu.m11));
return scope.Close(res);
NanReturnValue(res);
}
Handle<Value>
@ -373,4 +361,4 @@ Contour::Deserialize(const Arguments &args) {
self->hierarchy = hierarchy_res;
return scope.Close(v8::Null());
}
}

35
src/Contours.h
View File

@ -11,25 +11,22 @@ class Contour: public node::ObjectWrap {
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
Contour();
JSFUNC(Point)
JSFUNC(Points)
JSFUNC(Size)
JSFUNC(CornerCount)
JSFUNC(Area)
JSFUNC(ArcLength)
JSFUNC(ApproxPolyDP)
JSFUNC(ConvexHull)
JSFUNC(BoundingRect)
JSFUNC(MinAreaRect)
JSFUNC(IsConvex)
JSFUNC(Moments)
Contour();
//JSFUNC(Size)
static Handle<Value> Point(const v8::Arguments&);
static Handle<Value> Points(const v8::Arguments&);
static Handle<Value> Size(const v8::Arguments&);
static Handle<Value> CornerCount(const v8::Arguments&);
static Handle<Value> Area(const v8::Arguments&);
static Handle<Value> ArcLength(const v8::Arguments&);
static Handle<Value> ApproxPolyDP(const v8::Arguments&);
static Handle<Value> ConvexHull(const v8::Arguments&);
static Handle<Value> BoundingRect(const v8::Arguments&);
static Handle<Value> MinAreaRect(const v8::Arguments&);
static Handle<Value> IsConvex(const v8::Arguments&);
static Handle<Value> Moments(const v8::Arguments&);
static Handle<Value> Hierarchy(const v8::Arguments&);
static Handle<Value> Serialize(const v8::Arguments&);
static Handle<Value> Deserialize(const v8::Arguments&);
};

128
src/FaceRecognizer.cc
View File

@ -4,6 +4,7 @@
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4
#include "Matrix.h"
#include <nan.h>
#define EIGEN 0
#define LBPH 1
@ -13,7 +14,7 @@
cv::Mat fromMatrixOrFilename(Local<Value> 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,31 +32,31 @@ Persistent<FunctionTemplate> FaceRecognizerWrap::constructor;
void
FaceRecognizerWrap::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(FaceRecognizerWrap::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("FaceRecognizer"));
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(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());
};
Handle<Value>
FaceRecognizerWrap::New(const Arguments &args) {
HandleScope scope;
NAN_METHOD(FaceRecognizerWrap::New) {
NanScope();
if (args.This()->InternalFieldCount() == 0)
JSTHROW_TYPE("Cannot Instantiate without new")
@ -65,12 +66,11 @@ FaceRecognizerWrap::New(const Arguments &args) {
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH);
pt->Wrap(args.This());
return args.This();
NanReturnValue(args.This());
}
Handle<Value>
FaceRecognizerWrap::CreateLBPH(const Arguments &args) {
HandleScope scope;
NAN_METHOD(FaceRecognizerWrap::CreateLBPH) {
NanScope();
int radius = 1;
int neighbors = 8;
@ -84,7 +84,7 @@ FaceRecognizerWrap::CreateLBPH(const Arguments &args) {
INT_FROM_ARGS(grid_y, 3)
DOUBLE_FROM_ARGS(threshold, 4)
Local<Object> n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance();
Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(
radius, neighbors, grid_x, grid_y, threshold
@ -92,12 +92,11 @@ FaceRecognizerWrap::CreateLBPH(const Arguments &args) {
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH);
pt->Wrap(n);
return n;
NanReturnValue( n );
}
Handle<Value>
FaceRecognizerWrap::CreateEigen(const Arguments &args) {
HandleScope scope;
NAN_METHOD(FaceRecognizerWrap::CreateEigen) {
NanScope();
int components = 0;
double threshold = DBL_MAX;
@ -105,7 +104,7 @@ FaceRecognizerWrap::CreateEigen(const Arguments &args) {
INT_FROM_ARGS(components, 0)
DOUBLE_FROM_ARGS(threshold, 1)
Local<Object> n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance();
Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::FaceRecognizer> f = cv::createEigenFaceRecognizer(
components, threshold
@ -113,12 +112,11 @@ FaceRecognizerWrap::CreateEigen(const Arguments &args) {
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN);
pt->Wrap(n);
return n;
NanReturnValue( n );
}
Handle<Value>
FaceRecognizerWrap::CreateFisher(const Arguments &args) {
HandleScope scope;
NAN_METHOD(FaceRecognizerWrap::CreateFisher) {
NanScope();
int components = 0;
double threshold = DBL_MAX;
@ -126,7 +124,7 @@ FaceRecognizerWrap::CreateFisher(const Arguments &args) {
INT_FROM_ARGS(components, 0)
DOUBLE_FROM_ARGS(threshold, 1)
Local<Object> n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance();
Local<Object> n = NanNew(FaceRecognizerWrap::constructor)->GetFunction()->NewInstance();
cv::Ptr<cv::FaceRecognizer> f = cv::createFisherFaceRecognizer(
components, threshold
@ -134,7 +132,7 @@ FaceRecognizerWrap::CreateFisher(const Arguments &args) {
FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER);
pt->Wrap(n);
return n;
NanReturnValue( n );
}
@ -144,15 +142,20 @@ FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, int type){
}
Handle<Value> UnwrapTrainingData(const Arguments& args, cv::vector<cv::Mat>* images, cv::vector<int>* labels){
Handle<Value> UnwrapTrainingData(_NAN_METHOD_ARGS_TYPE args, cv::vector<cv::Mat>* images, cv::vector<int>* labels){
if (args.Length() < 1 || !args[0]->IsArray()){
JSTHROW("FaceRecognizer.train takes a list of [<int> label, image] tuples")
}
// Iterate through [[label, image], ...] etc, and add matrix / label to vectors
const Local<Array> tuples = v8::Array::Cast(*args[0]);
//const
//Local<Array> tuples = v8::Array::Cast(*args[0]);
const Local<Array> tuples = Local<Array>::Cast(args[0]);
const uint32_t length = tuples->Length();
for (uint32_t i=0 ; i<length ; ++i){
const Local<Value> val = tuples->Get(i);
@ -161,7 +164,7 @@ Handle<Value> UnwrapTrainingData(const Arguments& args, cv::vector<cv::Mat>* ima
JSTHROW("train takes a list of [label, image] tuples")
}
Local<Array> valarr = v8::Array::Cast(*val);
Local<Array> valarr = Local<Array>::Cast(val);
if (valarr->Length() != 2 || !valarr->Get(0)->IsInt32()){
JSTHROW("train takes a list of [label, image] tuples")
@ -174,11 +177,11 @@ Handle<Value> UnwrapTrainingData(const Arguments& args, cv::vector<cv::Mat>* ima
labels->push_back(label);
images->push_back(im);
}
return v8::Undefined();
return NanUndefined();
}
Handle<Value>
FaceRecognizerWrap::TrainSync(const Arguments& args){
NAN_METHOD(FaceRecognizerWrap::TrainSync){
SETUP_FUNCTION(FaceRecognizerWrap)
cv::vector<cv::Mat> images;
@ -186,16 +189,15 @@ FaceRecognizerWrap::TrainSync(const Arguments& args){
Handle<Value> 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();
}
Handle<Value>
FaceRecognizerWrap::UpdateSync(const Arguments& args){
NAN_METHOD(FaceRecognizerWrap::UpdateSync){
SETUP_FUNCTION(FaceRecognizerWrap)
@ -212,17 +214,16 @@ FaceRecognizerWrap::UpdateSync(const Arguments& args){
Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
if (!exception->IsUndefined()){
return exception;
JSTHROW( exception );
}
self->rec->update(images, labels);
return scope.Close(v8::Undefined());
NanReturnUndefined();
}
Handle<Value>
FaceRecognizerWrap::PredictSync(const Arguments& args){
NAN_METHOD(FaceRecognizerWrap::PredictSync){
SETUP_FUNCTION(FaceRecognizerWrap)
cv::Mat im = fromMatrixOrFilename(args[0]);//TODO CHECK!
@ -233,50 +234,47 @@ FaceRecognizerWrap::PredictSync(const Arguments& args){
double confidence = 0.0;
self->rec->predict(im, predictedLabel, confidence);
v8::Local<v8::Object> 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<v8::Object> res = NanNew<Object>();
res->Set(NanNew("id"), NanNew<Number>(predictedLabel));
res->Set(NanNew("confidence"), NanNew<Number>(confidence));
return scope.Close(res);
NanReturnValue(res);
}
Handle<Value>
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();
}
Handle<Value>
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();
}
Handle<Value>
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<Object> im = Matrix::constructor->GetFunction()->NewInstance();
Local<Object> im = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im);
img->mat = m;
return im;
NanReturnValue( im );
}

2
src/FaceRecognizer.h
View File

@ -11,7 +11,7 @@ class FaceRecognizerWrap: public node::ObjectWrap {
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, int type);

48
src/HighGUI.cc
View File

@ -7,26 +7,25 @@ Persistent<FunctionTemplate> NamedWindow::constructor;
void
NamedWindow::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(NamedWindow::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("NamedWindow"));
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(NamedWindow::New);
NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("NamedWindow"));
// Prototype
//Local<ObjectTemplate> 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());
};
Handle<Value>
NamedWindow::New(const Arguments &args) {
HandleScope scope;
NAN_METHOD(NamedWindow::New) {
NanScope();
if (args.This()->InternalFieldCount() == 0){
JSTHROW_TYPE("Cannot Instantiate without new")
@ -34,13 +33,13 @@ NamedWindow::New(const Arguments &args) {
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());
}
@ -51,26 +50,23 @@ NamedWindow::NamedWindow(const std::string& name, int f){
}
Handle<Value>
NamedWindow::Show(const v8::Arguments& args){
NAN_METHOD(NamedWindow::Show){
SETUP_FUNCTION(NamedWindow)
Matrix *im = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
cv::imshow(self->winname, im->mat);
return scope.Close(args.Holder());
NanReturnValue(args.Holder());
}
Handle<Value>
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());
}
Handle<Value>
NamedWindow::BlockingWaitKey(const v8::Arguments& args){
HandleScope scope;
NAN_METHOD(NamedWindow::BlockingWaitKey){
NanScope();
//SETUP_FUNCTION(NamedWindow)
int time = 0;
@ -84,5 +80,5 @@ NamedWindow::BlockingWaitKey(const v8::Arguments& args){
int res = cv::waitKey(time);
return scope.Close(Number::New(res));
NanReturnValue(NanNew<Number>(res));
}

3
src/HighGUI.h
View File

@ -6,10 +6,9 @@ class NamedWindow: public node::ObjectWrap {
std::string winname;
int flags;
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
NamedWindow(const std::string& winname, int flags);

1212
src/Matrix.cc
View File

File diff suppressed because it is too large Load Diff

2
src/Matrix.h
View File

@ -6,7 +6,7 @@ class Matrix: public node::ObjectWrap {
cv::Mat mat;
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
Matrix();
Matrix(cv::Mat other, cv::Rect roi);
Matrix(int rows, int cols);

29
src/OpenCV.cc
View File

@ -1,30 +1,29 @@
#include "OpenCV.h"
#include "Matrix.h"
#include <nan.h>
void
OpenCV::Init(Handle<Object> 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<String>("version"), NanNew<String>(out, n));
NODE_SET_METHOD(target, "readImage", ReadImage);
}
Handle<Value>
OpenCV::ReadImage(const Arguments &args) {
HandleScope scope;
NAN_METHOD(OpenCV::ReadImage) {
NanEscapableScope();
try{
Local<Object> im_h = Matrix::constructor->GetFunction()->NewInstance();
Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h);
cv::Mat mat;
REQ_FUN_ARG(1, cb);
@ -38,7 +37,7 @@ OpenCV::ReadImage(const Arguments &args) {
} 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(const Arguments &args) {
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(const Arguments &args) {
Local<Value> argv[2];
argv[0] = Local<Value>::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);
}
};

17
src/OpenCV.h
View File

@ -9,29 +9,30 @@
#include <opencv/cv.h>
#include <opencv/highgui.h>
#include <string.h>
#include <nan.h>
using namespace v8;
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<Function> VAR = Local<Function>::Cast(args[I]);
#define SETUP_FUNCTION(TYP) \
HandleScope scope; \
NanScope(); \
TYP *self = ObjectWrap::Unwrap<TYP>(args.This());
#define JSFUNC(NAME) \
static Handle<Value> NAME(const Arguments& args);
static NAN_METHOD(NAME);
#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) \
@ -48,10 +49,10 @@ class OpenCV: public node::ObjectWrap{
public:
static void Init(Handle<Object> target);
static Handle<Value> ReadImage(const v8::Arguments&);
static NAN_METHOD(ReadImage);
};
#endif

66
src/Point.cc
View File

@ -6,65 +6,63 @@ v8::Persistent<FunctionTemplate> Point::constructor;
void
Point::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(Point::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("Point"));
// Prototype
Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
proto->SetAccessor(String::NewSymbol("x"), GetX, RaiseImmutable);
proto->SetAccessor(String::NewSymbol("y"), GetY, RaiseImmutable);
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(Point::New);
NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("Point"));
NODE_SET_PROTOTYPE_METHOD(constructor, "dot", Dot);
// Prototype
Local<ObjectTemplate> 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());
};
Handle<Value>
Point::New(const Arguments &args) {
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());
}
Handle<Value>
Point::GetX(Local<String> prop, const AccessorInfo &info) {
HandleScope scope;
Point *pt = ObjectWrap::Unwrap<Point>(info.This());
return scope.Close(Number::New(pt->point.x));
NAN_GETTER(Point::GetX){
NanScope();
Point *pt = ObjectWrap::Unwrap<Point>(args.This());
NanReturnValue(NanNew<Number>(pt->point.x));
}
Handle<Value>
Point::GetY(Local<String> prop, const AccessorInfo &info) {
HandleScope scope;
Point *pt = ObjectWrap::Unwrap<Point>(info.This());
return scope.Close(Number::New(pt->point.y));
NAN_GETTER(Point::GetY){
NanScope();
Point *pt = ObjectWrap::Unwrap<Point>(args.This());
NanReturnValue(NanNew<Number>(pt->point.y));
}
void
Point::RaiseImmutable(Local<String> property, Local<Value> value, const AccessorInfo& info) {
v8::ThrowException(v8::Exception::TypeError(v8::String::New("Point is immutable")));
}
Handle<Value>
Point::Dot(const v8::Arguments& args){
HandleScope scope;
NAN_SETTER(Point::RaiseImmutable){
NanThrowTypeError("Point is immutable");
}
NAN_METHOD(Point::Dot){
NanScope();
Point *p1 = ObjectWrap::Unwrap<Point>(args.This());
Point *p2 = ObjectWrap::Unwrap<Point>(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<Number>(p1->point.x * p2->point.x + p1->point.y * p2->point.y));
}

14
src/Point.h
View File

@ -7,13 +7,13 @@ class Point: public node::ObjectWrap {
CvPoint2D32f point;
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
Point(double x, double y);
static Handle<Value> GetX(Local<String> prop, const AccessorInfo &info);
static Handle<Value> GetY(Local<String> prop, const AccessorInfo &info);
static void RaiseImmutable(Local<String> property, Local<Value> value, const AccessorInfo& info);
static Handle<Value> Dot(const v8::Arguments&);
static NAN_GETTER(GetX);
static NAN_GETTER(GetY);
static NAN_SETTER(RaiseImmutable);
static NAN_METHOD(Dot);
};

183
src/VideoCaptureWrap.cc
View File

@ -6,9 +6,6 @@
using namespace std;
void AsyncRead(uv_work_t *req);
void AfterAsyncRead(uv_work_t *req);
v8::Persistent<FunctionTemplate> VideoCaptureWrap::constructor;
struct videocapture_baton {
@ -23,30 +20,32 @@ struct videocapture_baton {
void
VideoCaptureWrap::Init(Handle<Object> target) {
HandleScope scope;
NanScope();
// Constructor
constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(VideoCaptureWrap::New));
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(String::NewSymbol("VideoCapture"));
// Prototype
//Class
Local<FunctionTemplate> ctor = NanNew<FunctionTemplate>(VideoCaptureWrap::New);
NanAssignPersistent(constructor, ctor);
ctor->InstanceTemplate()->SetInternalFieldCount(1);
ctor->SetClassName(NanNew("VideoCapture"));
// Prototype
//Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
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(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());
};
Handle<Value>
VideoCaptureWrap::New(const Arguments &args) {
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;
@ -54,131 +53,161 @@ VideoCaptureWrap::New(const Arguments &args) {
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)");
}
}
Handle<Value>
VideoCaptureWrap::SetWidth(const Arguments &args){
NAN_METHOD(VideoCaptureWrap::SetWidth){
HandleScope scope;
NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(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();
}
Handle<Value>
VideoCaptureWrap::SetHeight(const Arguments &args){
NAN_METHOD(VideoCaptureWrap::SetHeight){
HandleScope scope;
NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(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();
}
Handle<Value>
VideoCaptureWrap::SetPosition(const Arguments &args){
NAN_METHOD(VideoCaptureWrap::SetPosition){
HandleScope scope;
NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(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();
}
Handle<Value>
VideoCaptureWrap::Read(const Arguments &args) {
NAN_METHOD(VideoCaptureWrap::Close){
HandleScope scope;
NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
v->cap.release();
NanReturnUndefined();
}
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<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
cv::Mat mat;
mat = this->matrix->mat;
img->mat = mat;
Local<Value> 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();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
REQ_FUN_ARG(0, cb);
videocapture_baton *baton = new videocapture_baton();
baton->vc = v;
baton->cb = Persistent<Function>::New(cb);
baton->im = new Matrix();
baton->request.data = baton;
uv_queue_work(uv_default_loop(), &baton->request, AsyncRead, (uv_after_work_cb)AfterAsyncRead);
return Undefined();
}
void AsyncRead(uv_work_t *req) {
videocapture_baton *baton = static_cast<videocapture_baton *>(req->data);
baton->vc->cap.read(baton->im->mat);
NanCallback *callback = new NanCallback(cb.As<Function>());
NanAsyncQueueWorker(new AsyncVCWorker(callback, v, new Matrix()));
NanReturnUndefined();
}
void AfterAsyncRead(uv_work_t *req) {
NAN_METHOD(VideoCaptureWrap::ReadSync) {
HandleScope scope;
NanScope();
VideoCaptureWrap *v = ObjectWrap::Unwrap<VideoCaptureWrap>(args.This());
videocapture_baton *baton = static_cast<videocapture_baton *>(req->data);
Local<Object> im_to_return= NanNew(Matrix::constructor)->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
Local<Object> im_to_return= Matrix::constructor->GetFunction()->NewInstance();
Matrix *img = ObjectWrap::Unwrap<Matrix>(im_to_return);
cv::Mat mat;
mat = baton->im->mat;
img->mat = mat;
Local<Value> argv[2];
argv[0] = Local<Value>::New(Null());
argv[1] = im_to_return;
baton->cb->Call(Context::GetCurrent()->Global(), 2, argv);
baton->cb.Dispose();
delete baton->im;
delete baton;
v->cap.read(img->mat);
NanReturnValue(im_to_return);
}

16
src/VideoCaptureWrap.h
View File

@ -6,22 +6,24 @@ class VideoCaptureWrap: public node::ObjectWrap {
static Persistent<FunctionTemplate> constructor;
static void Init(Handle<Object> target);
static Handle<Value> New(const Arguments &args);
static NAN_METHOD(New);
VideoCaptureWrap(const std::string& filename);
VideoCaptureWrap(int device);
static Handle<Value> 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<Value> SetWidth(const v8::Arguments&);
static Handle<Value> SetHeight(const v8::Arguments&);
static NAN_METHOD(SetWidth);
static NAN_METHOD(SetHeight);
// to set frame position
static Handle<Value> SetPosition(const v8::Arguments&);
static NAN_METHOD(SetPosition);
static NAN_METHOD(GetFrameAt);
static Handle<Value> GetFrameAt(const v8::Arguments&);
//close the stream
static NAN_METHOD(Close);
};

4
src/init.cc
View File

@ -1,4 +1,5 @@
#include "OpenCV.h"
#include "Point.h"
#include "Matrix.h"
#include "CascadeClassifierWrap.h"
@ -12,8 +13,9 @@
extern "C" void
init(Handle<Object> target) {
HandleScope scope;
NanScope();
OpenCV::Init(target);
Point::Init(target);
Matrix::Init(target);
CascadeClassifierWrap::Init(target);