From cca52ad691cac78069532d252dd7c0259e9750dd Mon Sep 17 00:00:00 2001
From: Ryan Lord <rnelord@gmail.com>
Date: Wed, 1 May 2013 02:10:27 +0100
Subject: [PATCH 1/9] Added cv::flip function to Matrix objects

---
 src/Matrix.cc | 21 +++++++++++++++++++++
 src/Matrix.h  |  1 +
 2 files changed, 22 insertions(+)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index ed4a24c..44cb1c1 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -54,6 +54,7 @@ Matrix::Init(Handle<Object> target) {
     NODE_SET_PROTOTYPE_METHOD(constructor, "convertHSVscale", ConvertHSVscale);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "gaussianBlur", GaussianBlur);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "copy", Copy);
+	NODE_SET_PROTOTYPE_METHOD(constructor, "flip", Flip);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "ptr", Ptr);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "addWeighted", AddWeighted);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "split", Split);
@@ -692,6 +693,26 @@ Matrix::Copy(const v8::Arguments& args) {
 }
 
 
+Handle<Value>
+Matrix::Flip(const v8::Arguments& args) {
+	HandleScope scope;
+
+	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+
+	if ( args.Length() < 1 || !args[0]->IsInt32() ) {
+		return v8::ThrowException(String::New("Flip requires an integer flipCode argument (0 = X axis, positive = Y axis, negative = both axis"));
+	}
+
+	int flipCode = args[0]->ToInt32()->Value();
+
+	Local<Object> img_to_return = Matrix::constructor->GetFunction()->NewInstance();
+	Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+	cv::flip(self->mat, img->mat, flipCode);
+
+	return scope.Close(img_to_return);
+}
+
+
 Handle<Value>
 Matrix::Ptr(const v8::Arguments& args) {
 	HandleScope scope;
diff --git a/src/Matrix.h b/src/Matrix.h
index de6652f..1d6886a 100755
--- a/src/Matrix.h
+++ b/src/Matrix.h
@@ -49,6 +49,7 @@ class Matrix: public node::ObjectWrap {
     JSFUNC(ConvertHSVscale)
     JSFUNC(GaussianBlur)
     JSFUNC(Copy)
+    JSFUNC(Flip)
     JSFUNC(Ptr)
     JSFUNC(AddWeighted)
     JSFUNC(Split)

From c4a20bb279423f46a204025db780b447500ec884 Mon Sep 17 00:00:00 2001
From: Ryan Lord <rnelord@gmail.com>
Date: Wed, 1 May 2013 02:18:55 +0100
Subject: [PATCH 2/9] Made exception from ::flip throw a type error

---
 src/Matrix.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 44cb1c1..fe81e3f 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -700,7 +700,8 @@ Matrix::Flip(const v8::Arguments& args) {
 	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
 
 	if ( args.Length() < 1 || !args[0]->IsInt32() ) {
-		return v8::ThrowException(String::New("Flip requires an integer flipCode argument (0 = X axis, positive = Y axis, negative = both axis"));
+		return v8::ThrowException(Exception::TypeError(String::New(
+			"Flip requires an integer flipCode argument (0 = X axis, positive = Y axis, negative = both axis)")));
 	}
 
 	int flipCode = args[0]->ToInt32()->Value();

From c3d1379cd5491082357cb8d15bdd2737980a4727 Mon Sep 17 00:00:00 2001
From: Ryan Lord <rnelord@gmail.com>
Date: Wed, 1 May 2013 11:50:37 +0100
Subject: [PATCH 3/9] Added ROI bindings to Matrix

---
 src/Matrix.cc | 28 ++++++++++++++++++++++++++++
 src/Matrix.h  |  1 +
 2 files changed, 29 insertions(+)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index fe81e3f..dfde4bd 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -55,6 +55,7 @@ Matrix::Init(Handle<Object> target) {
 	NODE_SET_PROTOTYPE_METHOD(constructor, "gaussianBlur", GaussianBlur);
 	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, "addWeighted", AddWeighted);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "split", Split);
@@ -714,6 +715,33 @@ Matrix::Flip(const v8::Arguments& args) {
 }
 
 
+Handle<Value>
+Matrix::ROI(const v8::Arguments& args) {
+	HandleScope scope;
+
+	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+
+	if ( args.Length() != 4 ) {
+		return v8::ThrowException(Exception::TypeError(String::New(
+			"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<Object> img_to_return = Matrix::constructor->GetFunction()->NewInstance();
+	Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
+
+	int x = args[0]->IntegerValue();
+	int y = args[1]->IntegerValue();
+	int w = args[2]->IntegerValue();
+	int h = args[3]->IntegerValue();
+
+	cv::Mat roi(self->mat, cv::Rect(x,y,w,h));
+	img->mat = roi;
+
+	return scope.Close(img_to_return);
+}
+
+
 Handle<Value>
 Matrix::Ptr(const v8::Arguments& args) {
 	HandleScope scope;
diff --git a/src/Matrix.h b/src/Matrix.h
index 1d6886a..c869706 100755
--- a/src/Matrix.h
+++ b/src/Matrix.h
@@ -50,6 +50,7 @@ class Matrix: public node::ObjectWrap {
     JSFUNC(GaussianBlur)
     JSFUNC(Copy)
     JSFUNC(Flip)
+    JSFUNC(ROI)
     JSFUNC(Ptr)
     JSFUNC(AddWeighted)
     JSFUNC(Split)

From 7b3835bbf54178edc8f2b3415abb6117499a54eb Mon Sep 17 00:00:00 2001
From: Ryan Lord <rnelord@gmail.com>
Date: Wed, 1 May 2013 14:12:30 +0100
Subject: [PATCH 4/9] Matrix::rotate bind using cv::warpAffine

---
 src/Matrix.cc | 25 +++++++++++++++++++++++++
 src/Matrix.h  |  1 +
 2 files changed, 26 insertions(+)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index dfde4bd..8543b5b 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -46,6 +46,7 @@ Matrix::Init(Handle<Object> target) {
 	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, "pyrDown", PyrDown);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "pyrUp", PyrUp);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "channels", Channels);
@@ -973,6 +974,30 @@ Matrix::Resize(const v8::Arguments& args){
   return scope.Close(Undefined());
 }
 
+
+Handle<Value>
+Matrix::Rotate(const v8::Arguments& args){
+  HandleScope scope;
+
+  Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+  cv::Mat rotMatrix(2, 3, CV_32FC1);
+  cv::Mat res;
+
+  float angle = args[0]->ToNumber()->Value();
+  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;
+
+  return scope.Close(Undefined());
+}
+
 Handle<Value>
 Matrix::PyrDown(const v8::Arguments& args){
 	SETUP_FUNCTION(Matrix)
diff --git a/src/Matrix.h b/src/Matrix.h
index c869706..a9dd9b3 100755
--- a/src/Matrix.h
+++ b/src/Matrix.h
@@ -42,6 +42,7 @@ class Matrix: public node::ObjectWrap {
     JSFUNC(ToBufferAsync)
 
     JSFUNC(Resize)
+    JSFUNC(Rotate)
     JSFUNC(PyrDown)
     JSFUNC(PyrUp)
 

From e507377a80f0364ef830dce890092c004bad67ee Mon Sep 17 00:00:00 2001
From: mattholl <matthew.hollings@gmail.com>
Date: Tue, 7 May 2013 19:37:07 +0100
Subject: [PATCH 5/9] fixed tiny issue where err is missing as the first
 argument to read from a video stream

---
 lib/opencv.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/opencv.js b/lib/opencv.js
index 48a4284..edd51ec 100755
--- a/lib/opencv.js
+++ b/lib/opencv.js
@@ -50,14 +50,14 @@ util.inherits(cv.ImageDataStream, Stream);
 var imagedatastream = cv.ImageDataStream.prototype;
 
 imagedatastream.write = function(buf){
-	this.data.push(buf)	
+	this.data.push(buf)
 	return true;
 }
 
 
 imagedatastream.end = function(b){
 	var self = this;
-	
+
 	if (b)
 	  imagestream.write.call(this,b);
 
@@ -98,7 +98,7 @@ var ods = cv.ObjectDetectionStream.prototype;
 ods.write = function(m){
   var self = this;
 
-	this.classifier.detectMultiScale(m, 
+	this.classifier.detectMultiScale(m,
       function(e, objs){
         if (e) { throw e }
         self.emit('data', objs, m);
@@ -111,7 +111,7 @@ ods.write = function(m){
 cv.VideoStream = function(src){
   if (src instanceof cv.VideoCapture){
     this.video = src
-  } else { 
+  } else {
     this.video = new cv.VideoCapture(src);
   }
   this.readable = true;
@@ -128,7 +128,7 @@ videostream.read = function(){
   var self = this;
 
   var frame = function(){
-    self.video.read(function(mat){
+    self.video.read(function(err, mat){
       self.emit('data', mat)
       if (!self.paused){
         process.nextTick(frame)

From f5df8f6599c4dbc80f222f790beb48ed18ec395e Mon Sep 17 00:00:00 2001
From: Alessio Caiazza <ac@magentalab.it>
Date: Thu, 9 May 2013 18:03:38 +0200
Subject: [PATCH 6/9] meanStdDev for Matrix

---
 src/Matrix.cc | 21 +++++++++++++++++++++
 src/Matrix.h  |  2 ++
 2 files changed, 23 insertions(+)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 1f13c9d..f8999b3 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -75,6 +75,8 @@ Matrix::Init(Handle<Object> target) {
 	NODE_SET_PROTOTYPE_METHOD(constructor, "adjustROI", AdjustROI);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "locateROI", LocateROI);
 
+	NODE_SET_PROTOTYPE_METHOD(constructor, "meanStdDev", MeanStdDev);
+
 	NODE_SET_METHOD(constructor, "Eye", Eye);
 
 
@@ -1074,3 +1076,22 @@ Matrix::LocateROI(const v8::Arguments& args) {
 
 	return scope.Close(arr);
 }
+
+Handle<Value>
+Matrix::MeanStdDev(const v8::Arguments& args) {
+	HandleScope scope;
+
+	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+
+	Local<Object> mean = Matrix::constructor->GetFunction()->NewInstance();
+	Matrix *m_mean = ObjectWrap::Unwrap<Matrix>(mean);
+	Local<Object> stddev = Matrix::constructor->GetFunction()->NewInstance();
+	Matrix *m_stddev = ObjectWrap::Unwrap<Matrix>(stddev);
+
+	cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat);
+
+	Local<Object> data = Object::New();
+	data->Set(String::NewSymbol("mean"), mean);
+	data->Set(String::NewSymbol("stddev"), stddev);
+	return scope.Close(data);
+}
diff --git a/src/Matrix.h b/src/Matrix.h
index fde09c3..037952a 100755
--- a/src/Matrix.h
+++ b/src/Matrix.h
@@ -71,6 +71,8 @@ class Matrix: public node::ObjectWrap {
 
     JSFUNC(LocateROI)
     JSFUNC(AdjustROI)
+
+    JSFUNC(MeanStdDev)
 /*
 	static Handle<Value> Val(const Arguments& args);
 	static Handle<Value> RowRange(const Arguments& args);

From bce9d95c291687fd1bda0187596796b6d7abf8b1 Mon Sep 17 00:00:00 2001
From: Brandon Cheng <bcheng.gt@gmail.com>
Date: Mon, 13 May 2013 17:00:42 -0400
Subject: [PATCH 7/9] use github flavored markdown for javascript and bash

---
 README.md | 180 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 101 insertions(+), 79 deletions(-)

diff --git a/README.md b/README.md
index cbfb31f..ca3578d 100755
--- a/README.md
+++ b/README.md
@@ -13,31 +13,31 @@ You'll need OpenCV 2.3.1 installed.
 
 Then:
 
-
-        npm install opencv
-
+```bash
+$ npm install opencv
+```
 
 Or to build the repo:
 
-
-        node-gyp rebuild
-
+```bash
+$ node-gyp rebuild
+```
 
 ## Examples
 
 ### Face Detection
 
-
-        cv.readImage("./examples/test.jpg", function(err, im){
-          im.detectObject(cv.FACE_CASCADE, {}, function(err, faces){
-            for (var i=0;i<faces.length; i++){
-              var x = faces[i]
-              im.ellipse(x.x + x.width/2, x.y + x.height/2, x.width/2, x.height/2);
-            }
-            im.save('./out.jpg');
-          });
-        })
-
+```javascript
+cv.readImage("./examples/test.jpg", function(err, im){
+  im.detectObject(cv.FACE_CASCADE, {}, function(err, faces){
+    for (var i=0;i<faces.length; i++){
+      var x = faces[i]
+      im.ellipse(x.x + x.width/2, x.y + x.height/2, x.width/2, x.height/2);
+    }
+    im.save('./out.jpg');
+  });
+})
+```
 
 
 ## API Documentation
@@ -49,42 +49,52 @@ base datastructure in OpenCV. Things like images are just matrices of pixels.
 
 #### Creation
 
-        new Matrix(rows, cols)
+```javascript
+new Matrix(rows, cols)
+```
 
 Or if you're thinking of a Matrix as an image:
 
-        new Matrix(height, width)
+```javascript
+new Matrix(height, width)
+```
 
 Or you can use opencv to read in image files. Supported formats are in the OpenCV docs, but jpgs etc are supported.
 
-        cv.readImage(filename, function(mat){
-          ...
-        })
+```javascript
+cv.readImage(filename, function(mat){
+  ...
+})
 
-        cv.readImage(buffer, function(mat){
-          ...
-        })
+cv.readImage(buffer, function(mat){
+  ...
+})
+```
 
 If you need to pipe data into an image, you can use an ImageDataStream:
 
-        var s = new cv.ImageDataStream()
+```javascript
+var s = new cv.ImageDataStream()
 
-        s.on('load', function(matrix){
-          ...
-        })
+s.on('load', function(matrix){
+  ...
+})
 
-        fs.createReadStream('./examples/test.jpg').pipe(s);
+fs.createReadStream('./examples/test.jpg').pipe(s);
+```
 
 If however, you have a series of images, and you wish to stream them into a
 stream of Matrices, you can use an ImageStream. Thus:
 
-        var s = new cv.ImageStream()
+```javascript
+var s = new cv.ImageStream()
 
-        s.on('data', function(matrix){
-           ...
-        })
+s.on('data', function(matrix){
+   ...
+})
 
-        ardrone.createPngStream().pipe(s);
+ardrone.createPngStream().pipe(s);
+```
 
 Note: Each 'data' event into the ImageStream should be a complete image buffer.
 
@@ -92,36 +102,42 @@ Note: Each 'data' event into the ImageStream should be a complete image buffer.
 
 #### Accessing Data
 
-        var mat = new cv.Matrix.Eye(4,4); // Create identity matrix
+```javascript
+var mat = new cv.Matrix.Eye(4,4); // Create identity matrix
 
-        mat.get(0,0) // 1
-
-        mat.row(0)  // [1,0,0,0]
-        mat.col(4)  // [0,0,0,1]
+mat.get(0,0) // 1
 
+mat.row(0)  // [1,0,0,0]
+mat.col(4)  // [0,0,0,1]
+```
 
 ##### Save
 
-        mat.save('./pic.jpg')
+```javascript
+mat.save('./pic.jpg')
+```
 
 or:
 
-        var buff = mat.toBuffer()
-
+```javascript
+var buff = mat.toBuffer()
+```
 
 #### Image Processing
 
-        im.convertGrayscale()
-        im.canny(5, 300)
-        im.houghLinesP()
-
+```javascript
+im.convertGrayscale()
+im.canny(5, 300)
+im.houghLinesP()
+```
 
 
 #### Simple Drawing
 
-        im.ellipse(x, y)
-        im.line([x1,y1], [x2, y2])
-
+```javascript
+im.ellipse(x, y)
+im.line([x1,y1], [x2, y2])
+```
 
 #### Object Detection
 
@@ -129,21 +145,25 @@ There is a shortcut method for
 [Viola-Jones Haar Cascade](http://www.cognotics.com/opencv/servo_2007_series/part_2/sidebar.html) object 
 detection. This can be used for face detection etc.
 
-
-        mat.detectObject(haar_cascade_xml, opts, function(err, matches){})
+```javascript
+mat.detectObject(haar_cascade_xml, opts, function(err, matches){})
+```
 
 For convenience in face recognition, cv.FACE_CASCADE is a cascade that can be used for frontal face recognition.
 
 Also:
 
-        mat.goodFeaturesToTrack
-
+```javascript
+mat.goodFeaturesToTrack
+```
 
 #### Contours
 
-        mat.findCountours
-        mat.drawContour
-        mat.drawAllContours
+```javascript
+mat.findCountours
+mat.drawContour
+mat.drawAllContours
+```
 
 ### Using Contours
 
@@ -151,33 +171,35 @@ Also:
 functions for accessing, computing with, and altering the contours contained in it.
 See [relevant source code](src/Contours.cc) and [examples](examples/)
 
-        var contours = im.findContours;
+```javascript
+var contours = im.findContours;
 
-        # Count of contours in the Contours object
-        contours.size();
+# Count of contours in the Contours object
+contours.size();
 
-        # Count of corners(verticies) of contour `index`
-        contours.cornerCount(index);
+# Count of corners(verticies) of contour `index`
+contours.cornerCount(index);
 
-        # Access vertex data of contours
-        for(var c = 0; c < contours.size(); ++c) {
-          console.log("Contour " + c);
-          for(var i = 0; i < contours.cornerCount(c); ++i) {
-            var point = contours.point(c, i);
-            console.log("(" + point.x + "," + point.y + ")");"
-          }
-        }
+# Access vertex data of contours
+for(var c = 0; c < contours.size(); ++c) {
+  console.log("Contour " + c);
+  for(var i = 0; i < contours.cornerCount(c); ++i) {
+    var point = contours.point(c, i);
+    console.log("(" + point.x + "," + point.y + ")");"
+  }
+}
 
-        # Computations of contour `index`
-        contours.area(index);
-        contours.arcLength(index, isClosed);
-        contours.boundingRect(index);
-        contours.minAreaRect(index);
-        contours.isConvex(index);
+# Computations of contour `index`
+contours.area(index);
+contours.arcLength(index, isClosed);
+contours.boundingRect(index);
+contours.minAreaRect(index);
+contours.isConvex(index);
 
-        # Destructively alter contour `index`
-        contours.approxPolyDP(index, epsilon, isClosed);
-        contours.convexHull(index, clockwise);
+# Destructively alter contour `index`
+contours.approxPolyDP(index, epsilon, isClosed);
+contours.convexHull(index, clockwise);
+```
 
 ## MIT License
 The library is distributed under the MIT License - if for some reason that 

From 4cc5eff25bf70d8ba323d787925f192dd34d99ba Mon Sep 17 00:00:00 2001
From: Ray Smoodiver <me@clear.net.nz>
Date: Sun, 9 Jun 2013 18:16:03 +1200
Subject: [PATCH 8/9] Added err arguments

OpenCV functions now seem to return (err, val) style arguments. Updated example to handle
---
 examples/motion-track.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/motion-track.js b/examples/motion-track.js
index fca53ba..4aa43f6 100644
--- a/examples/motion-track.js
+++ b/examples/motion-track.js
@@ -3,13 +3,13 @@ var cv = require('../lib/opencv')
 
 var vid = new cv.VideoCapture("/Users/peterbraden/Desktop/repos/node-opencv/examples/motion.avi")
 
-vid.read(function(mat){
+vid.read(function(err, mat){
   var track = new cv.TrackedObject(mat, [420, 110, 490, 170], {channel: "value"});
   var x = 0;
   var iter = function(){
     vid.read(function(m2){
       x++;
-      var rec = track.track(m2)
+      var rec = track.track(err, m2)
       console.log(">>", x, ":" , rec)
       if (x % 10 == 0){
         m2.rectangle([rec[0], rec[1]], [rec[2], rec[3]])

From 1e5a0f2a23f0922c397c9d8950ebea3922c999b2 Mon Sep 17 00:00:00 2001
From: Ray Smoodiver <me@clear.net.nz>
Date: Sun, 9 Jun 2013 18:19:06 +1200
Subject: [PATCH 9/9] Added err arguments

Added err arguments to callback functions
---
 examples/take-face-pics.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/take-face-pics.js b/examples/take-face-pics.js
index 616a02d..419bfdf 100644
--- a/examples/take-face-pics.js
+++ b/examples/take-face-pics.js
@@ -4,7 +4,7 @@ var vid = new cv.VideoCapture(0)
 
 
 var snap = function(){
-  vid.read(function(im){
+  vid.read(function(err, im){
     im.detectObject(cv.FACE_CASCADE, {}, function(err, faces){
       if (!faces){
         console.log("No Faces")