Open Source Bridge Live coding - woohoo

Build instructions for docker

.travis.yml

@@ -1,7 +1,8 @@
 language: node_js
 node_js:
-   - 0.6
-   - 0.8
+   - "0.6"
+   - "0.8"
+   - "0.10"
 
 before_install:
   - sudo apt-get update

Dockerfile

@@ -0,0 +1,18 @@
+# This file describes how to build node-opencv into a runnable linux container with all dependencies installed
+# To build:
+# 1) Install docker (http://docker.io)
+# 2) Build: wget https://raw.github.com/dotcloud/docker/v0.1.6/contrib/docker-build/docker-build && python docker-build $USER/node-opencv < Dockerfile
+# 3) Test: docker run $USER/node-opencv node -e "console.log(require('opencv').version)"
+#
+# VERSION		0.1
+# DOCKER-VERSION	0.1.6
+
+from	ubuntu:12.04
+run	echo "deb http://archive.ubuntu.com/ubuntu precise main universe" > /etc/apt/sources.list
+run	apt-get update
+run	apt-get install -q -y libcv-dev
+run	apt-get install -q -y libopencv-dev
+run	apt-get install -q -y libhighgui-dev
+run	apt-get install wget
+run	wget -O - http://nodejs.org/dist/v0.8.23/node-v0.8.23-linux-x64.tar.gz | tar -C /usr/local/ --strip-components=1 -zxv
+run	npm install opencv

README.md

@@ -185,6 +185,11 @@ doesn't work for you please get in touch.
 
 ## Changelog
 
+#### 0.0.13
+
+- V Early support for face recognition - API is _likely_ to change. Have fun!
+- *API Change*: VideoCapture.read now calls callback(err, im) instead of callback(im)
+
 #### 0.0.12
 - Matrix clone()
 - NamedWindow Support

binding.gyp

@@ -11,6 +11,7 @@
         , "src/VideoCaptureWrap.cc"
         , "src/CamShift.cc"
         , "src/HighGUI.cc"
+        , "src/FaceRecognizer.cc"
         ]
       , 'libraries': [
           '<!@(pkg-config --libs opencv)'

examples/camera.js

@@ -5,7 +5,7 @@ var camera = new cv.VideoCapture(0);
 
 setInterval(function() {
 
-	camera.read(function(im) {
+	camera.read(function(err, im) {
 
 		im.save('/tmp/cam.png');
 	});

examples/take-face-pics.js

@@ -0,0 +1,29 @@
+var cv = require('../lib/opencv')
+
+var vid = new cv.VideoCapture(0)
+
+
+var snap = function(){
+  vid.read(function(im){
+    im.detectObject(cv.FACE_CASCADE, {}, function(err, faces){
+      if (!faces){
+        console.log("No Faces")
+        return;
+      }
+      var face = faces[0]
+        , ims = im.size()
+      
+      im.adjustROI(
+           -face.y
+         , (face.y + face.height) - ims[0]
+         , -face.x
+         , (face.x + face.width) - ims[1])
+   
+      console.log("!!", im.locateROI());
+      var im2 = im.clone()
+    })
+
+
+  });
+}
+snap()

lib/opencv.js

@@ -130,7 +130,7 @@ videostream.read = function(){
   var frame = function(){
     self.video.read(function(mat){
       self.emit('data', mat)
-      if (!this.paused){
+      if (!self.paused){
         process.nextTick(frame)
       }
 

package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "buffers": "0.1.1"
   },
-  "version": "0.0.12",
+  "version": "0.1.0",
   "devDependencies": {
     "vows": "*"
   },

smoke/smoketest.js

@@ -1,47 +1,28 @@
 var cv = require('../lib/opencv')
 
-var win = new cv.NamedWindow("foo");
-cv.readImage('./examples/stuff.png', function(e, im){
-  im.pyrDown();
-  win.show(im);
-  setTimeout(function(){
-    win.destroy();
-  }, 1000)
-})
-
-
-
+var trainingData = []
 /*
-new cv.VideoCapture(0).read(function(mat){
+for (var i = 1; i< 41; i++){
+  for (var j = 1; j<10; j++){
+    trainingData.push([i,"/Users/peterbraden/Downloads/orl_faces/s" + i + "/" + j + ".pgm" ])
+  }
+}
 
-  mat.resize(200,100)
-  mat.save('./out.jpg')
+cv.readImage("/Users/peterbraden/Downloads/orl_faces/s6/10.pgm", function(e, im){
+
+  var facerec = cv.FaceRecognizer.createEigenFaceRecognizer(); 
+  //facerec.trainSync(trainingData);
+  facerec.loadSync("/Users/peterbraden/Desktop/ORL")
+
+  console.log(facerec.predictSync(im));
 
-  mat.detectObject("./data/haarcascade_frontalface_alt.xml", {min : [30,30]}, function(err, faces){  
-    for (var i=0;i<faces.length; i++){
-      var x = faces[i]
-      mat.ellipse(x.x + x.width/2, x.y + x.height/2, x.width/2, x.height/2);
-    }
-    console.log(faces.length ? (faces.length + " faces found") : "No faces")
-    mat.save('./out.jpg');   
-    
-  })
 })
 
 
-
-cv.readImage("./examples/stuff.png", function(err, im){
-  var i2 = im.copy()
-  i2.convertGrayscale()
-  i2.canny(5, 300)
-  var features = i2.houghLinesP();
-  for (var i=0;i<features.length; i++){
-      var x = features[i]
-      im.line([x[0], x[1]], [x[2], x[3]]);
-      im.ellipse(x[0], x[1]);
-      im.ellipse(x[2], x[3]);
-    }
-  console.log(features)
-    im.save('./out.jpg');   
-});
 */
+cv.readImage("/Users/peterbraden/Desktop/repos/node-opencv/examples/mona.png", function(e, mat){
+  var th = mat.threshold(200, 200, "Threshold to Zero Inverted");
+  th.save('out.png')
+
+})
+

src/CascadeClassifierWrap.cc

@@ -112,7 +112,7 @@ CascadeClassifierWrap::DetectMultiScale(const v8::Arguments& args){
 //  eio_custom(EIO_DetectMultiScale, EIO_PRI_DEFAULT, EIO_AfterDetectMultiScale, baton);
 //  ev_ref(EV_DEFAULT_UC);
 
-  uv_queue_work(uv_default_loop(), &baton->request, AsyncDetectMultiScale, AfterAsyncDetectMultiScale);
+  uv_queue_work(uv_default_loop(), &baton->request, AsyncDetectMultiScale,  (uv_after_work_cb)AfterAsyncDetectMultiScale);
 
   return Undefined();
 

src/CascadeClassifierWrap.h

@@ -13,7 +13,7 @@ class CascadeClassifierWrap: public node::ObjectWrap {
     //static Handle<Value> LoadHaarClassifierCascade(const v8::Arguments&);
 
 	static Handle<Value> DetectMultiScale(const v8::Arguments&);
-	static void EIO_DetectMultiScale(eio_req *req);
-	static int EIO_AfterDetectMultiScale(eio_req *req);
+	static void EIO_DetectMultiScale(uv_work_t *req);
+	static int EIO_AfterDetectMultiScale(uv_work_t *req);
 
 };

src/FaceRecognizer.cc

@@ -0,0 +1,283 @@
+#include "FaceRecognizer.h"
+#include "OpenCV.h"
+
+#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4
+
+#include "Matrix.h"
+
+#define EIGEN 0
+#define LBPH 1
+#define FISHER 2
+
+// Todo, move somewhere useful
+cv::Mat fromMatrixOrFilename(Local<Value> v){
+  cv::Mat im;
+  if (v->IsString()){
+    std::string filename = std::string(*v8::String::AsciiValue(v->ToString()));
+    im = cv::imread(filename);
+    //std::cout<< im.size();
+  } else {
+    Matrix *img = ObjectWrap::Unwrap<Matrix>(v->ToObject());
+    im = img->mat;
+  }
+  return im;
+}
+
+
+void AsyncPredict(uv_work_t *req);
+void AfterAsyncPredict(uv_work_t *req);
+
+Persistent<FunctionTemplate> FaceRecognizerWrap::constructor;
+
+void
+FaceRecognizerWrap::Init(Handle<Object> target) {
+    HandleScope scope;
+
+    // Constructor
+      constructor = Persistent<FunctionTemplate>::New(FunctionTemplate::New(FaceRecognizerWrap::New));
+      constructor->InstanceTemplate()->SetInternalFieldCount(1);
+      constructor->SetClassName(String::NewSymbol("FaceRecognizer"));
+
+    NODE_SET_METHOD(constructor, "createLBPHFaceRecognizer", CreateLBPH);
+    NODE_SET_METHOD(constructor, "createEigenFaceRecognizer", CreateEigen);
+    NODE_SET_METHOD(constructor, "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(constructor, "getMat", GetMat);
+
+    target->Set(String::NewSymbol("FaceRecognizer"), constructor->GetFunction());
+};
+
+Handle<Value>
+FaceRecognizerWrap::New(const Arguments &args) {
+  HandleScope scope;
+
+  if (args.This()->InternalFieldCount() == 0)
+    JSTHROW_TYPE("Cannot Instantiate without new")
+
+  // By default initialize LBPH
+  cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(1, 8, 8, 8, 80.0);
+  FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH);
+
+  pt->Wrap(args.This());
+  return args.This();
+}
+
+Handle<Value>
+FaceRecognizerWrap::CreateLBPH(const Arguments &args) {
+  HandleScope scope;
+
+  int radius = 1;
+  int neighbors = 8;
+  int grid_x = 8;
+  int grid_y = 8;
+  double threshold = 80;
+
+  INT_FROM_ARGS(radius, 0)
+  INT_FROM_ARGS(neighbors, 1)
+  INT_FROM_ARGS(grid_x, 2)
+  INT_FROM_ARGS(grid_y, 3)
+  DOUBLE_FROM_ARGS(threshold, 4)
+
+  Local<Object> n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance();
+
+  cv::Ptr<cv::FaceRecognizer> f = cv::createLBPHFaceRecognizer(
+      radius, neighbors, grid_x, grid_y, threshold
+  );
+  FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, LBPH);
+
+  pt->Wrap(n);
+  return n;
+}
+
+Handle<Value>
+FaceRecognizerWrap::CreateEigen(const Arguments &args) {
+  HandleScope scope;
+
+  int components = 0;
+  double threshold = DBL_MAX;
+
+  INT_FROM_ARGS(components, 0)
+  DOUBLE_FROM_ARGS(threshold, 1)
+
+  Local<Object> n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance();
+
+  cv::Ptr<cv::FaceRecognizer> f = cv::createEigenFaceRecognizer(
+      components, threshold
+  );
+  FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, EIGEN);
+
+  pt->Wrap(n);
+  return n;
+}
+
+Handle<Value>
+FaceRecognizerWrap::CreateFisher(const Arguments &args) {
+  HandleScope scope;
+
+  int components = 0;
+  double threshold = DBL_MAX;
+
+  INT_FROM_ARGS(components, 0)
+  DOUBLE_FROM_ARGS(threshold, 1)
+
+  Local<Object> n = FaceRecognizerWrap::constructor->GetFunction()->NewInstance();
+
+  cv::Ptr<cv::FaceRecognizer> f = cv::createFisherFaceRecognizer(
+      components, threshold
+  );
+  FaceRecognizerWrap *pt = new FaceRecognizerWrap(f, FISHER);
+
+  pt->Wrap(n);
+  return n;
+}
+
+
+FaceRecognizerWrap::FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, int type){
+  rec = f;
+  typ = type;
+}
+
+
+Handle<Value> UnwrapTrainingData(const Arguments& 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 uint32_t length = tuples->Length();
+  for (uint32_t i=0 ; i<length ; ++i){
+      const Local<Value> val = tuples->Get(i);
+
+      if (!val->IsArray()){
+        JSTHROW("train takes a list of [label, image] tuples")
+      }
+
+      Local<Array> valarr = v8::Array::Cast(*val);
+
+      if (valarr->Length() != 2 || !valarr->Get(0)->IsInt32()){
+        JSTHROW("train takes a list of [label, image] tuples")
+      }
+
+	   int label = valarr->Get(0)->Uint32Value();
+     cv::Mat im = fromMatrixOrFilename(valarr->Get(1));
+     im = im.clone();
+     cv::cvtColor(im, im, CV_RGB2GRAY);
+     labels->push_back(label);
+     images->push_back(im);
+  }
+  return v8::Undefined();
+}
+
+Handle<Value>
+FaceRecognizerWrap::TrainSync(const Arguments& args){
+	SETUP_FUNCTION(FaceRecognizerWrap)
+
+  cv::vector<cv::Mat> images;
+  cv::vector<int> labels;
+
+  Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
+  if (!exception->IsUndefined()){
+    return exception;
+  }
+
+  self->rec->train(images, labels);
+
+  return scope.Close(v8::Undefined());
+}
+
+Handle<Value>
+FaceRecognizerWrap::UpdateSync(const Arguments& args){
+	SETUP_FUNCTION(FaceRecognizerWrap)
+
+
+  if (self->typ == EIGEN){
+    JSTHROW("Eigen Recognizer does not support update")
+  }
+  if (self->typ == FISHER){
+    JSTHROW("Fisher Recognizer does not support update")
+  }
+
+  cv::vector<cv::Mat> images;
+  cv::vector<int> labels;
+
+
+  Handle<Value> exception = UnwrapTrainingData(args, &images, &labels);
+  if (!exception->IsUndefined()){
+    return exception;
+  }
+
+  self->rec->update(images, labels);
+
+  return scope.Close(v8::Undefined());
+}
+
+
+Handle<Value>
+FaceRecognizerWrap::PredictSync(const Arguments& args){
+	SETUP_FUNCTION(FaceRecognizerWrap)
+
+  cv::Mat im = fromMatrixOrFilename(args[0]);//TODO CHECK!
+  cv::cvtColor(im, im, CV_RGB2GRAY);
+ // int predictedLabel = self->rec->predict(im);
+
+  int predictedLabel = -1;
+  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));
+
+  return scope.Close(res);
+}
+
+
+Handle<Value>
+FaceRecognizerWrap::SaveSync(const Arguments& args){
+	SETUP_FUNCTION(FaceRecognizerWrap)
+  if (!args[0]->IsString()){
+    JSTHROW("Save takes a filename")
+  }
+  std::string filename = std::string(*v8::String::AsciiValue(args[0]->ToString()));
+  self->rec->save(filename);
+  return v8::Undefined();
+}
+
+Handle<Value>
+FaceRecognizerWrap::LoadSync(const Arguments& args){
+	SETUP_FUNCTION(FaceRecognizerWrap)
+  if (!args[0]->IsString()){
+    JSTHROW("Load takes a filename")
+  }
+  std::string filename = std::string(*v8::String::AsciiValue(args[0]->ToString()));
+  self->rec->load(filename);
+  return v8::Undefined();
+}
+
+Handle<Value>
+FaceRecognizerWrap::GetMat(const Arguments& args){
+	SETUP_FUNCTION(FaceRecognizerWrap)
+  if (!args[0]->IsString()){
+    JSTHROW("getMat takes a key")
+  }
+  std::string key = std::string(*v8::String::AsciiValue(args[0]->ToString()));
+  cv::Mat m = self->rec->getMat(key);
+
+  Local<Object> im = Matrix::constructor->GetFunction()->NewInstance();
+  Matrix *img = ObjectWrap::Unwrap<Matrix>(im);
+  img->mat = m;
+
+  return im;
+}
+
+
+#endif // End version > 2.4

src/FaceRecognizer.h

@@ -0,0 +1,41 @@
+#include "OpenCV.h"
+
+#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4
+
+#include "opencv2/contrib/contrib.hpp"
+
+class FaceRecognizerWrap: public node::ObjectWrap {
+  public:
+    cv::Ptr<cv::FaceRecognizer> rec;
+    int typ;
+
+    static Persistent<FunctionTemplate> constructor;
+    static void Init(Handle<Object> target);
+    static Handle<Value> New(const Arguments &args);
+
+    FaceRecognizerWrap(cv::Ptr<cv::FaceRecognizer> f, int type);
+
+    JSFUNC(CreateLBPH)
+    JSFUNC(CreateEigen)
+    JSFUNC(CreateFisher)
+    
+    JSFUNC(TrainSync)
+    //JSFUNC(Train)
+    JSFUNC(UpdateSync)
+    //JSFUNC(Update)
+    
+    JSFUNC(PredictSync)
+    // JSFUNC(Predict)
+    //static void EIO_Predict(eio_req *req);
+    //static int EIO_AfterPredict(eio_req *req);
+
+
+    JSFUNC(SaveSync)
+    JSFUNC(LoadSync)
+    
+    JSFUNC(GetMat)
+};
+
+
+
+#endif

src/HighGUI.cc

@@ -19,6 +19,7 @@ NamedWindow::Init(Handle<Object> target) {
 
 	  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());
 };
 
@@ -65,3 +66,16 @@ NamedWindow::Destroy(const v8::Arguments& args){
   cv::destroyWindow(self->winname);
 	return scope.Close(args.Holder());
 }
+
+
+Handle<Value>
+NamedWindow::BlockingWaitKey(const v8::Arguments& args){
+  HandleScope scope;
+	//SETUP_FUNCTION(NamedWindow)
+	int time = 0;
+  if (args.Length() > 0){
+    time = args[1]->IntegerValue();
+  }
+  int res = cv::waitKey(time);
+	return scope.Close(Number::New(res));
+}

src/HighGUI.h

@@ -15,5 +15,6 @@ class NamedWindow: public node::ObjectWrap {
 
     JSFUNC(Show);
     JSFUNC(Destroy);
+    JSFUNC(BlockingWaitKey);
 
 };

src/Matrix.cc

@@ -44,6 +44,7 @@ Matrix::Init(Handle<Object> target) {
 	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, "pyrDown", PyrDown);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "pyrUp", PyrUp);
@@ -68,6 +69,10 @@ Matrix::Init(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(constructor, "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(constructor, "threshold", Threshold);
 
 	NODE_SET_METHOD(constructor, "Eye", Eye);
 
@@ -348,9 +353,6 @@ struct matrixToBuffer_baton_t {
   Matrix *mm;
   Persistent<Function> cb;
   std::vector<uchar>  res;
-  int resSize;
-  int sleep_for;
-
   uv_work_t request;
 };
 
@@ -367,9 +369,8 @@ Matrix::ToBufferAsync(const v8::Arguments& args){
   baton->mm = self;
   baton->cb = Persistent<Function>::New(cb);
   baton->request.data = baton;
-  baton->sleep_for = 1;
 
-  uv_queue_work(uv_default_loop(), &baton->request, AsyncToBufferAsync, AfterAsyncToBufferAsync);
+  uv_queue_work(uv_default_loop(), &baton->request, AsyncToBufferAsync, (uv_after_work_cb)AfterAsyncToBufferAsync);
 
   return Undefined();
 }
@@ -516,16 +517,83 @@ Matrix::Line(const Arguments& args) {
 }
 
 Handle<Value>
-Matrix::Save(const v8::Arguments& args){
-	HandleScope scope;
+Matrix::Save(const v8::Arguments& args) {
+  SETUP_FUNCTION(Matrix)
 
-	if (!args[0]->IsString())
-		return v8::ThrowException(v8::Exception::TypeError(String::New("filename required")));
+  if (args.Length() > 1) {
+    return SaveAsync(args);
+  }
+  
+  if (!args[0]->IsString())
+    return v8::ThrowException(v8::Exception::TypeError(String::New("filename required")));
 
-	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
-	String::AsciiValue filename(args[0]);
-	int res = cv::imwrite(*filename, self->mat);
-	return scope.Close(Number::New(res));
+  String::AsciiValue filename(args[0]);
+  int res = cv::imwrite(*filename, self->mat);
+  return scope.Close(Number::New(res));
+}
+
+
+struct save_baton_t {
+  Matrix *mm;
+  Persistent<Function> cb;
+  std::string filename;
+  int res;
+  uv_work_t request;
+};
+
+void DoSaveAsync(uv_work_t *req);
+void AfterSaveAsync(uv_work_t *req);
+
+Handle<Value>
+Matrix::SaveAsync(const v8::Arguments& args){
+  SETUP_FUNCTION(Matrix)
+
+  if (!args[0]->IsString())
+    return v8::ThrowException(v8::Exception::TypeError(String::New("filename required")));
+
+  String::AsciiValue filename(args[0]);
+
+  REQ_FUN_ARG(1, cb);
+
+  save_baton_t *baton = new save_baton_t();
+  baton->mm = self;
+  baton->cb = Persistent<Function>::New(cb);
+  baton->filename = *filename;
+  baton->request.data = baton;
+
+  uv_queue_work(uv_default_loop(), &baton->request, DoSaveAsync, (uv_after_work_cb)AfterSaveAsync);
+
+  return Undefined();
+}
+
+
+void DoSaveAsync(uv_work_t *req) {
+  save_baton_t *baton = static_cast<save_baton_t *>(req->data);
+
+  int res = cv::imwrite(baton->filename.c_str(), baton->mm->mat);
+  baton->res = res;
+}
+
+void AfterSaveAsync(uv_work_t *req) {
+  HandleScope scope;
+  save_baton_t *baton = static_cast<save_baton_t *>(req->data);
+
+  Local<Value> argv[2];  // (err, result)
+
+  argv[0] = Local<Value>::New(Null());
+  argv[1] = Number::New(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;
 }
 
 
@@ -901,3 +969,74 @@ Matrix::inRange(const v8::Arguments& args) {
 
 	return scope.Close(v8::Null());
 }
+
+Handle<Value>
+Matrix::AdjustROI(const v8::Arguments& args) {
+	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);
+
+  return scope.Close(v8::Null());
+
+}
+
+Handle<Value>
+Matrix::LocateROI(const v8::Arguments& args) {
+	SETUP_FUNCTION(Matrix)
+ 
+  cv::Size wholeSize;
+  cv::Point ofs;
+
+  self->mat.locateROI(wholeSize, ofs);
+
+	v8::Local<v8::Array> 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));
+
+	return scope.Close(arr);
+}
+
+Handle<Value>
+Matrix::Threshold(const v8::Arguments& args) {
+	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<Object> img_to_return = Matrix::constructor->GetFunction()->NewInstance();
+	Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+	self->mat.copyTo(img->mat);
+
+  cv::threshold(self->mat, img->mat, threshold, maxVal, typ);
+
+	return scope.Close(img_to_return);
+}

src/Matrix.h

@@ -36,8 +36,9 @@ class Matrix: public node::ObjectWrap {
     JSFUNC(Empty)
 
     JSFUNC(Save)
-    JSFUNC(ToBuffer)
+    JSFUNC(SaveAsync)
 
+    JSFUNC(ToBuffer)
     JSFUNC(ToBufferAsync)
 
     JSFUNC(Resize)
@@ -65,6 +66,10 @@ class Matrix: public node::ObjectWrap {
 
     JSFUNC(inRange)
 
+    JSFUNC(LocateROI)
+    JSFUNC(AdjustROI)
+
+    JSFUNC(Threshold)
 /*
 	static Handle<Value> Val(const Arguments& args);
 	static Handle<Value> RowRange(const Arguments& args);
@@ -86,8 +91,6 @@ class Matrix: public node::ObjectWrap {
 // create, increment, release
     static Handle<Value> PushBack(const Arguments& args);
     static Handle<Value> PopBack(const Arguments& args);
-    static Handle<Value> LocateROI(const Arguments& args);
-    static Handle<Value> AdjustROI(const Arguments& args);
     static Handle<Value> Total(const Arguments& args);
     static Handle<Value> IsContinous(const Arguments& args);
     static Handle<Value> Type(const Arguments& args);

src/OpenCV.h

@@ -30,6 +30,19 @@ using namespace node;
 #define JSTHROW_TYPE(ERR) \
   return v8::ThrowException(v8::Exception::TypeError(v8::String::New(ERR)));
 
+#define JSTHROW(ERR) \
+  return v8::ThrowException(v8::Exception::Error(v8::String::New(ERR)));
+
+
+#define INT_FROM_ARGS(NAME, IND) \
+  if (args[IND]->IsInt32()){ \
+    NAME = args[IND]->Uint32Value(); \
+  }
+
+#define DOUBLE_FROM_ARGS(NAME, IND) \
+  if (args[IND]->IsInt32()){ \
+    NAME = args[IND]->NumberValue(); \
+  }
 
 class OpenCV: public node::ObjectWrap{
   public:

src/VideoCaptureWrap.cc

@@ -92,7 +92,7 @@ VideoCaptureWrap::Read(const Arguments &args) {
 	baton->im = new Matrix();
 	baton->request.data = baton;
 
-	uv_queue_work(uv_default_loop(), &baton->request, AsyncRead, AfterAsyncRead);
+	uv_queue_work(uv_default_loop(), &baton->request, AsyncRead,  (uv_after_work_cb)AfterAsyncRead);
 	return Undefined();
 
 }
@@ -116,11 +116,12 @@ void AfterAsyncRead(uv_work_t *req) {
 	mat = baton->im->mat;
 
 	img->mat = mat;
-	Local<Value> argv[1];
+	Local<Value> argv[2];
 
-	argv[0] = im_to_return;
+  argv[0] = Local<Value>::New(Null());
+	argv[1] = im_to_return;
 
-	baton->cb->Call(Context::GetCurrent()->Global(), 1, argv);
+	baton->cb->Call(Context::GetCurrent()->Global(), 2, argv);
 	baton->cb.Dispose();
 
 		delete baton;

src/init.cc

@@ -6,6 +6,7 @@
 #include "Contours.h"
 #include "CamShift.h"
 #include "HighGUI.h"
+#include "FaceRecognizer.h"
 
 
 extern "C" void
@@ -18,8 +19,12 @@ init(Handle<Object> target) {
     VideoCaptureWrap::Init(target);
     Contour::Init(target);
 	  TrackedObject::Init(target);
-	  
     NamedWindow::Init(target);
+
+   #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4
+     FaceRecognizerWrap::Init(target);
+   #endif
+
 };
 
 NODE_MODULE(opencv, init)