Merge branch 'master' of github.com:peterbraden/node-opencv into beta

Add async save method

.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

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

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)
       }
 

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/HighGUI.cc

@@ -70,7 +70,8 @@ NamedWindow::Destroy(const v8::Arguments& args){
 
 Handle<Value>
 NamedWindow::BlockingWaitKey(const v8::Arguments& args){
-	SETUP_FUNCTION(NamedWindow)
+  HandleScope scope;
+	//SETUP_FUNCTION(NamedWindow)
 	int time = 0;
   if (args.Length() > 0){
     time = args[1]->IntegerValue();

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,8 @@ 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_METHOD(constructor, "Eye", Eye);
 
@@ -348,9 +351,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 +367,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 +515,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 +967,35 @@ 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);
+}

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,8 @@ class Matrix: public node::ObjectWrap {
 
     JSFUNC(inRange)
 
+    JSFUNC(LocateROI)
+    JSFUNC(AdjustROI)
 /*
 	static Handle<Value> Val(const Arguments& args);
 	static Handle<Value> RowRange(const Arguments& args);
@@ -86,8 +89,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/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;