From c6319937e0001725041a910a9f7d4479890b2af8 Mon Sep 17 00:00:00 2001
From: madshall <madshall.md@gmail.com>
Date: Wed, 22 Oct 2014 20:16:22 -0400
Subject: [PATCH 01/35] - findContours() fixed - bitwiseAnd(), bitwiseNot(),
 bitwiseXor() may accept mask as the last argument since now

---
 src/Matrix.cc | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 4978953..0ad3045 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -1027,7 +1027,12 @@ NAN_METHOD(Matrix::BitwiseXor) {
 	Matrix *src1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
 	Matrix *src2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
 
-	cv::bitwise_xor(src1->mat, src2->mat, self->mat);
+    if(args.Length() == 3){
+    	Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+		cv::bitwise_xor(src1->mat, src2->mat, self->mat, mask->mat);
+    }else{
+		cv::bitwise_xor(src1->mat, src2->mat, self->mat);
+    }	
 
 	NanReturnNull();
 }
@@ -1039,6 +1044,12 @@ NAN_METHOD(Matrix::BitwiseNot) {
 
     Matrix *dst = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
 
+    if(args.Length() == 2){
+    	Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+    	cv::bitwise_not(self->mat, dst->mat, mask->mat);
+    }else{
+    	cv::bitwise_not(self->mat, dst->mat);
+    }	
     cv::bitwise_not(self->mat, dst->mat);
 
     NanReturnNull();
@@ -1052,7 +1063,12 @@ NAN_METHOD(Matrix::BitwiseAnd) {
     Matrix *src1 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
     Matrix *src2 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
 
-    cv::bitwise_and(src1->mat, src2->mat, self->mat);
+    if(args.Length() == 3){
+    	Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+	    cv::bitwise_and(src1->mat, src2->mat, self->mat, mask->mat);
+    }else{
+	    cv::bitwise_and(src1->mat, src2->mat, self->mat);
+    }	
 
     NanReturnNull();
 }
@@ -1125,7 +1141,11 @@ NAN_METHOD(Matrix::FindContours) {
     if (args[1]->IsNumber()) chain = args[1]->IntegerValue();
   }
 
+	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
 	Local<Object> conts_to_return= NanNew(Contour::constructor)->GetFunction()->NewInstance();
+	Contour *contours = ObjectWrap::Unwrap<Contour>(conts_to_return);
+
+	cv::findContours(self->mat, contours->contours, contours->hierarchy, mode, chain);
 
 	NanReturnValue(conts_to_return);
 

From 4860f875c96ff7631b728bef2d08319fe65076ee Mon Sep 17 00:00:00 2001
From: madshall <madshall.md@gmail.com>
Date: Wed, 22 Oct 2014 21:26:52 -0400
Subject: [PATCH 02/35] oops, bitwiseNot() hotfix

---
 src/Matrix.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 0ad3045..5df1b19 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -1050,7 +1050,6 @@ NAN_METHOD(Matrix::BitwiseNot) {
     }else{
     	cv::bitwise_not(self->mat, dst->mat);
     }	
-    cv::bitwise_not(self->mat, dst->mat);
 
     NanReturnNull();
 }

From 23fc1c04edcf6fa20a090a8d6d7c7dd25288ee0c Mon Sep 17 00:00:00 2001
From: Dmitry Ivanov <madshall.md@gmail.com>
Date: Thu, 23 Oct 2014 15:50:05 -0400
Subject: [PATCH 03/35] HoughCircles added

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

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 5df1b19..4e97c64 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -68,6 +68,7 @@ Matrix::Init(Handle<Object> target) {
 	NODE_SET_PROTOTYPE_METHOD(ctor, "drawAllContours", DrawAllContours);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "goodFeaturesToTrack", GoodFeaturesToTrack);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "houghLinesP", HoughLinesP);
+	NODE_SET_PROTOTYPE_METHOD(ctor, "houghCircles", HoughCircles);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "inRange", inRange);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "adjustROI", AdjustROI);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "locateROI", LocateROI);
@@ -1257,6 +1258,41 @@ NAN_METHOD(Matrix::HoughLinesP) {
 
 }
 
+NAN_METHOD(Matrix::HoughCircles) {
+	NanScope();
+
+	Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
+
+  double dp = args.Length() < 1 ? 1 : args[0]->NumberValue();
+  double minDist = args.Length() < 2 ? 1 : args[1]->NumberValue();
+  double higherThreshold = args.Length() < 3 ? 100 : args[2]->NumberValue();
+  double accumulatorThreshold = args.Length() < 4 ? 100 : args[3]->NumberValue();
+  int minRadius = args.Length() < 5 ? 0 : args[4]->Uint32Value();
+  int maxRadius = args.Length() < 6 ? 0 : args[5]->Uint32Value();
+  std::vector<cv::Vec3f> circles;
+
+  cv::Mat gray;
+
+
+  equalizeHist(self->mat, gray);
+  
+  cv::HoughCircles(gray, circles, CV_HOUGH_GRADIENT, dp, minDist, higherThreshold, accumulatorThreshold, minRadius, maxRadius);
+
+  v8::Local<v8::Array> arr = NanNew<Array>(circles.size());
+
+
+  for (unsigned int i=0; i < circles.size(); i++){
+    v8::Local<v8::Array> pt = NanNew<Array>(3);
+    pt->Set(0, NanNew<Number>((double) circles[i][0]));// center x
+    pt->Set(1, NanNew<Number>((double) circles[i][1]));// center y
+    pt->Set(2, NanNew<Number>((double) circles[i][2]));// radius
+    arr->Set(i, pt);
+  }
+
+  NanReturnValue(arr);
+
+}
+
 cv::Scalar setColor(Local<Object> objColor) {
 
 	Local<Value> valB = objColor->Get(0);
diff --git a/src/Matrix.h b/src/Matrix.h
index 535134f..f041bca 100755
--- a/src/Matrix.h
+++ b/src/Matrix.h
@@ -74,6 +74,7 @@ class Matrix: public node::ObjectWrap {
     // Feature Detection
     JSFUNC(GoodFeaturesToTrack)
     JSFUNC(HoughLinesP)
+    JSFUNC(HoughCircles)
 
     JSFUNC(Crop)
 

From f90d623adc65bfda240446b502894f83c894c942 Mon Sep 17 00:00:00 2001
From: Pieter De Bruyne <pieter.debruyne@kahosl.be>
Date: Tue, 9 Dec 2014 19:59:56 +0100
Subject: [PATCH 04/35] fixed Crop prototype

---
 src/Matrix.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 4e97c64..4cad417 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -32,6 +32,7 @@ Matrix::Init(Handle<Object> target) {
 	NODE_SET_PROTOTYPE_METHOD(ctor, "height", Height);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "size", Size);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "clone", Clone);
+	NODE_SET_PROTOTYPE_METHOD(ctor, "crop", Crop);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "toBuffer", ToBuffer);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "toBufferAsync", ToBufferAsync);
 	NODE_SET_PROTOTYPE_METHOD(ctor, "ellipse", Ellipse);

From 73cddc81de423cc44943169aaf737ebd59d99ac7 Mon Sep 17 00:00:00 2001
From: Micah Elizabeth Scott <micah@misc.name>
Date: Fri, 16 Jan 2015 12:11:05 -0800
Subject: [PATCH 05/35] In setRect(), don't return a pointer to stack memory

Noticed a compiler warning for this during build, and the code looks
like the sort of thing that may often work accidentally, but is not
at all guaranteed to work.

This is the simplest fix I could imagine; keep the logic about whether
to return NULL or not in setRect(), but pass it a reference to some
memory in the caller's stack frame to use for the result.

This fixes the warning, but I haven't had a chance to verify functionality.
---
 src/Matrix.cc | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index 4cad417..fbee02c 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -7,7 +7,7 @@ v8::Persistent<FunctionTemplate> Matrix::constructor;
 
 cv::Scalar setColor(Local<Object> objColor);
 cv::Point setPoint(Local<Object> objPoint);
-cv::Rect* setRect(Local<Object> objRect);
+cv::Rect* setRect(Local<Object> objRect, cv::Rect &result);
 
 void
 Matrix::Init(Handle<Object> target) {
@@ -1310,7 +1310,7 @@ cv::Point setPoint(Local<Object> objPoint) {
 	return  cv::Point( objPoint->Get(0)->IntegerValue(),  objPoint->Get(1)->IntegerValue() );
 }
 
-cv::Rect* setRect(Local<Object> objRect) {
+cv::Rect* setRect(Local<Object> objRect, cv::Rect &result) {
 
 	if(!objRect->IsArray() || !objRect->Get(0)->IsArray() || !objRect->Get(0)->IsArray() ){
 		printf("error");
@@ -1319,14 +1319,13 @@ cv::Rect* setRect(Local<Object> objRect) {
 
 	Local<Object> point = objRect->Get(0)->ToObject();
 	Local<Object> size = objRect->Get(1)->ToObject();
-	cv::Rect ret;
 
-	ret.x = point->Get(0)->IntegerValue();
-	ret.y = point->Get(1)->IntegerValue();
-	ret.width = size->Get(0)->IntegerValue();
-	ret.height = size->Get(1)->IntegerValue();
+	result.x = point->Get(0)->IntegerValue();
+	result.y = point->Get(1)->IntegerValue();
+	result.width = size->Get(0)->IntegerValue();
+	result.height = size->Get(1)->IntegerValue();
 
-	return (cv::Rect*) &ret;
+	return &result;
 }
 
 
@@ -1714,10 +1713,11 @@ NAN_METHOD(Matrix::FloodFill){
 
 
 	Local<Object> obj = args[0]->ToObject();
+	cv::Rect rect;
 
 	int  ret = cv::floodFill(self->mat, setPoint(obj->Get(NanNew<String>("seedPoint"))->ToObject())
 			, setColor(obj->Get(NanNew<String>("newColor"))->ToObject())
-			, obj->Get(NanNew<String>("rect"))->IsUndefined() ? 0 : setRect(obj->Get(NanNew<String>("rect"))->ToObject())
+			, obj->Get(NanNew<String>("rect"))->IsUndefined() ? 0 : setRect(obj->Get(NanNew<String>("rect"))->ToObject(), rect)
 			, setColor(obj->Get(NanNew<String>("loDiff"))->ToObject())
 			, setColor(obj->Get(NanNew<String>("upDiff"))->ToObject())
 			, 4 );

From 85c3a90db71d8498c3728e3b4244da0fd20f6737 Mon Sep 17 00:00:00 2001
From: Micah Elizabeth Scott <micah@misc.name>
Date: Fri, 16 Jan 2015 12:13:45 -0800
Subject: [PATCH 06/35] Fix compile errors with ambiguous signedness in NanNew
 param

This fixes two instances of a compile error I'd been getting with
OpenCV 2.4.9 (via Homebrew) on Mac OS:

../node_modules/nan/nan_new.h:184:10: error: call to 'New' is ambiguous
  return NanIntern::Factory<T>::New(arg0);
         ^~~~~~~~~~~~~~~~~~~~~~~~~~
../src/Matrix.cc:453:51: note: in instantiation of function template specialization 'NanNew<v8::Integer, unsigned long>' requested here
        v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>(vec.size()), NanNew<v8::Integer>(0)};
                                                         ^
../node_modules/nan/nan_new.h:86:26: note: candidate function
  static inline return_t New(int32_t value);
                         ^
../node_modules/nan/nan_new.h:87:26: note: candidate function
  static inline return_t New(uint32_t value);
---
 src/Matrix.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Matrix.cc b/src/Matrix.cc
index fbee02c..91faa07 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -452,7 +452,7 @@ NAN_METHOD(Matrix::ToBuffer){
   
 	v8::Local<v8::Object> globalObj = NanGetCurrentContext()->Global();
 	v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(NanNew<String>("Buffer")));
-	v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>(vec.size()), NanNew<v8::Integer>(0)};
+	v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>((unsigned)vec.size()), NanNew<v8::Integer>(0)};
 	v8::Local<v8::Object> actualBuffer = bufferConstructor->NewInstance(3, constructorArgs);
 
 	NanReturnValue(actualBuffer);
@@ -485,7 +485,7 @@ class AsyncToBufferWorker : public NanAsyncWorker {
   
 	  v8::Local<v8::Object> globalObj = NanGetCurrentContext()->Global();
 	  v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(NanNew<String>("Buffer")));
-	  v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>(res.size()), NanNew<v8::Integer>(0)};
+	  v8::Handle<v8::Value> constructorArgs[3] = {buf, NanNew<v8::Integer>((unsigned)res.size()), NanNew<v8::Integer>(0)};
 	  v8::Local<v8::Object> actualBuffer = bufferConstructor->NewInstance(3, constructorArgs);
 
 

From 702cd7a992f49d5d6356b75e5d64c893056a37b9 Mon Sep 17 00:00:00 2001
From: Fille <bobmoff@gmail.com>
Date: Sat, 17 Jan 2015 23:08:18 +0100
Subject: [PATCH 07/35] Forced nan to 1.4.3

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 4405141..7ce4b0a 100755
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
   "author": "Peter Braden <peterbraden@peterbraden.co.uk>",
   "dependencies": {
     "buffers": "0.1.1",
-    "nan": "^1.3.0"
+    "nan": "1.4.3"
   },
   "version": "1.0.0",
   "devDependencies": {

From 97715a8048aa8be714451d578cc29cbf0190eff6 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Mon, 19 Jan 2015 15:15:05 -0500
Subject: [PATCH 08/35] Added findChessboardCorners function

---
 src/OpenCV.cc | 94 +++++++++++++++++++++++++++++++++++++++++++++------
 src/OpenCV.h  |  3 +-
 2 files changed, 86 insertions(+), 11 deletions(-)

diff --git a/src/OpenCV.cc b/src/OpenCV.cc
index 4ed6c43..24f594b 100755
--- a/src/OpenCV.cc
+++ b/src/OpenCV.cc
@@ -5,48 +5,49 @@
 void
 OpenCV::Init(Handle<Object> target) {
   NanScope();
-  
+
   // Version string.
   char out [21];
   int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION);
   target->Set(NanNew<String>("version"), NanNew<String>(out, n));
 
   NODE_SET_METHOD(target, "readImage", ReadImage);
+  NODE_SET_METHOD(target, "findChessboardCorners", FindChessboardCorners);
 
-}  
+}
 
 
 NAN_METHOD(OpenCV::ReadImage) {
   NanEscapableScope();
 
   try{
-    
+
     Local<Object> im_h = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
     Matrix *img = ObjectWrap::Unwrap<Matrix>(im_h);
-    
+
     cv::Mat mat;
 
     REQ_FUN_ARG(1, cb);
-    
+
     if (args[0]->IsNumber() && args[1]->IsNumber()){
       int width, height;
 
       width = args[0]->Uint32Value();
-      height = args[1]->Uint32Value();    
+      height = args[1]->Uint32Value();
       mat = *(new cv::Mat(width, height, CV_64FC1));
 
     } else if (args[0]->IsString()) {
-      
+
       std::string filename = std::string(*NanAsciiString(args[0]->ToString()));
       mat = cv::imread(filename);
 
     } else if (Buffer::HasInstance(args[0])){
      	uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject());
      	unsigned len = Buffer::Length(args[0]->ToObject());
-      
+
   	 	cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf);
       mat = cv::imdecode(*mbuf, -1);
-            
+
       if (mat.empty()){
         NanThrowTypeError("Error loading file");
       }
@@ -74,4 +75,77 @@ NAN_METHOD(OpenCV::ReadImage) {
       NanThrowError(err_msg);
       NanReturnUndefined();
   }
-};    
+};
+
+NAN_METHOD(OpenCV::FindChessboardCorners) {
+    NanEscapableScope();
+
+    try {
+        // Get the arguments from javascript
+
+        // Arg 0 is the image
+        Matrix* m = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat mat = m->mat;
+
+        // Arg 1 is the pattern size
+        cv::Size patternSize;
+        if (args[1]->IsArray()) {
+            Local<Object> v8sz = args[1]->ToObject();
+
+            patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 2 would normally be the flags, ignoring this for now and using the default flags
+
+        // Final argument is the callback function
+        REQ_FUN_ARG(2, cb);
+
+        // Find the corners
+        std::vector<cv::Point2f> corners;
+        bool found = cv::findChessboardCorners(mat, patternSize, corners);
+
+        // Make the callback arguments
+        Local<Value> argv[2];
+
+        argv[0] = NanNull();
+        argv[1] = NanNull(); // This will be replaced by the corners array if corners were found
+
+        // Further processing if we found corners
+        Local<Array> cornersArray;
+        if(found)
+        {
+            // Convert the return value to a javascript array
+            cornersArray = Array::New(corners.size());
+            for(int i = 0; i < corners.size(); i++)
+            {
+                Local<Object> point_data = NanNew<Object>();
+                point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
+                point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
+
+                cornersArray->Set(Number::New(i), point_data);
+            }
+
+            argv[1] = cornersArray;
+        }
+
+        // Callback
+        TryCatch try_catch;
+
+        cb->Call(NanGetCurrentContext()->Global(), 2, argv);
+
+        if(try_catch.HasCaught()) {
+            FatalException(try_catch);
+        }
+
+        NanReturnUndefined();
+
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+
+};
diff --git a/src/OpenCV.h b/src/OpenCV.h
index ea1ca83..b8a53ab 100755
--- a/src/OpenCV.h
+++ b/src/OpenCV.h
@@ -50,9 +50,10 @@ class OpenCV: public node::ObjectWrap{
     static void Init(Handle<Object> target);
 
     static NAN_METHOD(ReadImage);
+
+    static NAN_METHOD(FindChessboardCorners);
 };
 
 
 
 #endif
-

From e35698ac16913569c7daf05b09f68ec1c771acdb Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 20 Jan 2015 09:37:52 -0500
Subject: [PATCH 09/35] Moved findChessboardCorners to calib3d source file

---
 binding.gyp    |  1 +
 src/Calib3D.cc | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/Calib3D.h  | 15 +++++++++
 src/OpenCV.cc  | 75 ------------------------------------------
 src/OpenCV.h   |  2 --
 src/init.cc    |  7 ++--
 6 files changed, 108 insertions(+), 80 deletions(-)
 create mode 100644 src/Calib3D.cc
 create mode 100644 src/Calib3D.h

diff --git a/binding.gyp b/binding.gyp
index aa089a6..6e56fc9 100755
--- a/binding.gyp
+++ b/binding.gyp
@@ -14,6 +14,7 @@
         , "src/FaceRecognizer.cc"
         , "src/BackgroundSubtractor.cc"
         , "src/Constants.cc"
+        , "src/Calib3D.cc"
         ]
       , 'libraries': [
           '<!@(pkg-config --libs opencv)'
diff --git a/src/Calib3D.cc b/src/Calib3D.cc
new file mode 100644
index 0000000..240c431
--- /dev/null
+++ b/src/Calib3D.cc
@@ -0,0 +1,88 @@
+#include "Calib3D.h"
+#include "Matrix.h"
+
+void Calib3D::Init(Handle<Object> target)
+{
+    Persistent<Object> inner;
+    Local<Object> obj = NanNew<Object>();
+    NanAssignPersistent(inner, obj);
+
+    NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners);
+
+    target->Set(NanNew("calib3d"), obj);
+}
+
+// cv::findChessboardCorners
+NAN_METHOD(Calib3D::FindChessboardCorners)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments from javascript
+
+        // Arg 0 is the image
+        Matrix* m = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat mat = m->mat;
+
+        // Arg 1 is the pattern size
+        cv::Size patternSize;
+        if (args[1]->IsArray()) {
+            Local<Object> v8sz = args[1]->ToObject();
+
+            patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 2 would normally be the flags, ignoring this for now and using the default flags
+
+        // Final argument is the callback function
+        REQ_FUN_ARG(2, cb);
+
+        // Find the corners
+        std::vector<cv::Point2f> corners;
+        bool found = cv::findChessboardCorners(mat, patternSize, corners);
+
+        // Make the callback arguments
+        Local<Value> argv[2];
+
+        argv[0] = NanNull();
+        argv[1] = NanNull(); // This will be replaced by the corners array if corners were found
+
+        // Further processing if we found corners
+        Local<Array> cornersArray;
+        if(found)
+        {
+            // Convert the return value to a javascript array
+            cornersArray = Array::New(corners.size());
+            for(unsigned int i = 0; i < corners.size(); i++)
+            {
+                Local<Object> point_data = NanNew<Object>();
+                point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
+                point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
+
+                cornersArray->Set(Number::New(i), point_data);
+            }
+
+            argv[1] = cornersArray;
+        }
+
+        // Callback
+        TryCatch try_catch;
+
+        cb->Call(NanGetCurrentContext()->Global(), 2, argv);
+
+        if(try_catch.HasCaught()) {
+            FatalException(try_catch);
+        }
+
+        NanReturnUndefined();
+
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+
+};
diff --git a/src/Calib3D.h b/src/Calib3D.h
new file mode 100644
index 0000000..e8bba46
--- /dev/null
+++ b/src/Calib3D.h
@@ -0,0 +1,15 @@
+#ifndef __NODE_CALIB3D_H
+#define __NODE_CALIB3D_H
+
+#include "OpenCV.h"
+
+// Implementation of calib3d.hpp functions
+
+class Calib3D: public node::ObjectWrap {
+public:
+    static void Init(Handle<Object> target);
+
+    static NAN_METHOD(FindChessboardCorners);
+};
+
+#endif
diff --git a/src/OpenCV.cc b/src/OpenCV.cc
index 24f594b..6ebdf01 100755
--- a/src/OpenCV.cc
+++ b/src/OpenCV.cc
@@ -12,8 +12,6 @@ OpenCV::Init(Handle<Object> target) {
   target->Set(NanNew<String>("version"), NanNew<String>(out, n));
 
   NODE_SET_METHOD(target, "readImage", ReadImage);
-  NODE_SET_METHOD(target, "findChessboardCorners", FindChessboardCorners);
-
 }
 
 
@@ -76,76 +74,3 @@ NAN_METHOD(OpenCV::ReadImage) {
       NanReturnUndefined();
   }
 };
-
-NAN_METHOD(OpenCV::FindChessboardCorners) {
-    NanEscapableScope();
-
-    try {
-        // Get the arguments from javascript
-
-        // Arg 0 is the image
-        Matrix* m = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
-        cv::Mat mat = m->mat;
-
-        // Arg 1 is the pattern size
-        cv::Size patternSize;
-        if (args[1]->IsArray()) {
-            Local<Object> v8sz = args[1]->ToObject();
-
-            patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
-        } else {
-            JSTHROW_TYPE("Must pass pattern size");
-        }
-
-        // Arg 2 would normally be the flags, ignoring this for now and using the default flags
-
-        // Final argument is the callback function
-        REQ_FUN_ARG(2, cb);
-
-        // Find the corners
-        std::vector<cv::Point2f> corners;
-        bool found = cv::findChessboardCorners(mat, patternSize, corners);
-
-        // Make the callback arguments
-        Local<Value> argv[2];
-
-        argv[0] = NanNull();
-        argv[1] = NanNull(); // This will be replaced by the corners array if corners were found
-
-        // Further processing if we found corners
-        Local<Array> cornersArray;
-        if(found)
-        {
-            // Convert the return value to a javascript array
-            cornersArray = Array::New(corners.size());
-            for(int i = 0; i < corners.size(); i++)
-            {
-                Local<Object> point_data = NanNew<Object>();
-                point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
-                point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
-
-                cornersArray->Set(Number::New(i), point_data);
-            }
-
-            argv[1] = cornersArray;
-        }
-
-        // Callback
-        TryCatch try_catch;
-
-        cb->Call(NanGetCurrentContext()->Global(), 2, argv);
-
-        if(try_catch.HasCaught()) {
-            FatalException(try_catch);
-        }
-
-        NanReturnUndefined();
-
-
-    } catch (cv::Exception &e) {
-        const char *err_msg = e.what();
-        NanThrowError(err_msg);
-        NanReturnUndefined();
-    }
-
-};
diff --git a/src/OpenCV.h b/src/OpenCV.h
index b8a53ab..2dc32e5 100755
--- a/src/OpenCV.h
+++ b/src/OpenCV.h
@@ -50,8 +50,6 @@ class OpenCV: public node::ObjectWrap{
     static void Init(Handle<Object> target);
 
     static NAN_METHOD(ReadImage);
-
-    static NAN_METHOD(FindChessboardCorners);
 };
 
 
diff --git a/src/init.cc b/src/init.cc
index eb8b79a..2486e07 100755
--- a/src/init.cc
+++ b/src/init.cc
@@ -9,21 +9,22 @@
 #include "HighGUI.h"
 #include "FaceRecognizer.h"
 #include "Constants.h"
-
+#include "Calib3D.h"
 
 extern "C" void
 init(Handle<Object> target) {
     NanScope();
     OpenCV::Init(target);
-    
+
     Point::Init(target);
     Matrix::Init(target);
     CascadeClassifierWrap::Init(target);
     VideoCaptureWrap::Init(target);
     Contour::Init(target);
-	  TrackedObject::Init(target);
+	TrackedObject::Init(target);
     NamedWindow::Init(target);
     Constants::Init(target);
+    Calib3D::Init(target);
 
 
    #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4

From 088b44bdeb31d780defc23304e4cc0aac1ac1c30 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 20 Jan 2015 10:19:28 -0500
Subject: [PATCH 10/35] Added drawChessboardCorners

---
 src/Calib3D.cc | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/Calib3D.h  |  2 ++
 2 files changed, 72 insertions(+)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index 240c431..512b524 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -8,6 +8,7 @@ void Calib3D::Init(Handle<Object> target)
     NanAssignPersistent(inner, obj);
 
     NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners);
+    NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners);
 
     target->Set(NanNew("calib3d"), obj);
 }
@@ -86,3 +87,72 @@ NAN_METHOD(Calib3D::FindChessboardCorners)
     }
 
 };
+
+// cv::drawChessboardCorners
+NAN_METHOD(Calib3D::DrawChessboardCorners)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments
+
+        // Arg 0 is the image
+        Matrix* m = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat mat = m->mat;
+
+        // Arg 1 is the pattern size
+        cv::Size patternSize;
+        if (args[1]->IsArray()) {
+            Local<Object> v8sz = args[1]->ToObject();
+
+            patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 2 is the corners array
+        std::vector<cv::Point2f> corners;
+        if(args[2]->IsArray()) {
+            Local<Array> cornersArray = Local<Array>::Cast(args[2]);
+
+            for(unsigned int i = 0; i < cornersArray->Length(); i++)
+            {
+                Local<Object> pt = cornersArray->Get(i)->ToObject();
+                corners.push_back(cv::Point2f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
+                                              pt->Get(NanNew<String>("y"))->ToNumber()->Value()));
+            }
+        } else {
+            JSTHROW_TYPE("Must pass corners array");
+        }
+
+        // Arg 3, pattern found boolean
+        bool patternWasFound = args[3]->ToBoolean()->Value();
+
+        // Final argument is the callback
+        REQ_FUN_ARG(4, cb);
+
+        // Draw the corners
+        cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound);
+
+        // Make the callback arguments (same image that was passed, now with corners drawn on it)
+        Local<Value> argv[2];
+        argv[0] = NanNull();
+        argv[1] = args[0];
+
+        // Callback
+        TryCatch try_catch;
+
+        cb->Call(NanGetCurrentContext()->Global(), 2, argv);
+
+        if(try_catch.HasCaught()) {
+            FatalException(try_catch);
+        }
+
+        NanReturnUndefined();
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/Calib3D.h b/src/Calib3D.h
index e8bba46..14ecc99 100644
--- a/src/Calib3D.h
+++ b/src/Calib3D.h
@@ -10,6 +10,8 @@ public:
     static void Init(Handle<Object> target);
 
     static NAN_METHOD(FindChessboardCorners);
+
+    static NAN_METHOD(DrawChessboardCorners);
 };
 
 #endif

From 0c3597695005055f608ae1e80c4eaa699e979cef Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 20 Jan 2015 13:04:22 -0500
Subject: [PATCH 11/35] Added calibrateCamera function

---
 src/Calib3D.cc | 108 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/Calib3D.h  |   2 +
 2 files changed, 110 insertions(+)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index 512b524..f8a1fcc 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -9,6 +9,7 @@ void Calib3D::Init(Handle<Object> target)
 
     NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners);
     NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners);
+    NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera);
 
     target->Set(NanNew("calib3d"), obj);
 }
@@ -156,3 +157,110 @@ NAN_METHOD(Calib3D::DrawChessboardCorners)
         NanReturnUndefined();
     }
 }
+
+// cv::calibrateCamera
+NAN_METHOD(Calib3D::CalibrateCamera)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments
+
+        // Arg 0, the array of object points, an array of arrays
+        std::vector<std::vector<cv::Point3f> > objectPoints;
+        if(args[0]->IsArray()) {
+            Local<Array> objectPointsArray = Local<Array>::Cast(args[0]);
+
+            for(unsigned int i = 0; i < objectPointsArray->Length(); i++)
+            {
+                std::vector<cv::Point3f> points;
+
+                Local<Array> pointsArray = Local<Array>::Cast(objectPointsArray->Get(i));
+                for(unsigned int j = 0; j < pointsArray->Length(); j++)
+                {
+                    Local<Object> pt = pointsArray->Get(j)->ToObject();
+                    points.push_back(cv::Point3f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
+                                                 pt->Get(NanNew<String>("y"))->ToNumber()->Value(),
+                                                 pt->Get(NanNew<String>("z"))->ToNumber()->Value()));
+                }
+
+                objectPoints.push_back(points);
+            }
+        } else {
+            JSTHROW_TYPE("Must pass array of object points for each frame")
+        }
+
+        // Arg 1, the image points, another array of arrays =(
+        std::vector<std::vector<cv::Point2f> > imagePoints;
+        if(args[1]->IsArray()) {
+            Local<Array> imagePointsArray = Local<Array>::Cast(args[1]);
+
+            for(unsigned int i = 0; i < imagePointsArray->Length(); i++)
+            {
+                std::vector<cv::Point2f> points;
+
+                Local<Array> pointsArray = Local<Array>::Cast(imagePointsArray->Get(i));
+                for(unsigned int j = 0; j < pointsArray->Length(); j++)
+                {
+                    Local<Object> pt = pointsArray->Get(j)->ToObject();
+                    points.push_back(cv::Point2f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
+                                                 pt->Get(NanNew<String>("y"))->ToNumber()->Value()));
+                }
+
+                imagePoints.push_back(points);
+            }
+        } else {
+            JSTHROW_TYPE("Must pass array of object points for each frame")
+        }
+
+        // Arg 2, the image size
+        cv::Size imageSize;
+        if (args[2]->IsArray()) {
+            Local<Object> v8sz = args[2]->ToObject();
+
+            imageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, skipping for now
+        cv::Mat K, dist;
+
+        // Arg 5, 6 flags and termination criteria, skipping for now
+
+        // Calibrate the camera
+        std::vector<cv::Mat> rvecs, tvecs;
+
+        double error = cv::calibrateCamera(objectPoints, imagePoints, imageSize, K, dist, rvecs, tvecs);
+
+        // make the return values
+        Local<Object> ret = NanNew<Object>();
+
+        // Reprojection error
+        ret->Set(NanNew<String>("reprojectionError"), NanNew<Number>(error));
+
+        // K
+        Local<Object> KMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *KMatrix = ObjectWrap::Unwrap<Matrix>(KMatrixWrap);
+        KMatrix->mat = K;
+
+        ret->Set(NanNew<String>("K"), KMatrixWrap);
+
+        // dist
+        Local<Object> distMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *distMatrix = ObjectWrap::Unwrap<Matrix>(distMatrixWrap);
+        distMatrix->mat = dist;
+
+        ret->Set(NanNew<String>("distortion"), distMatrixWrap);
+
+        // Per frame R and t, skiping for now
+
+        // Return
+        NanReturnValue(ret);
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/Calib3D.h b/src/Calib3D.h
index 14ecc99..e42df5c 100644
--- a/src/Calib3D.h
+++ b/src/Calib3D.h
@@ -12,6 +12,8 @@ public:
     static NAN_METHOD(FindChessboardCorners);
 
     static NAN_METHOD(DrawChessboardCorners);
+
+    static NAN_METHOD(CalibrateCamera);
 };
 
 #endif

From 024d8e5ee55cfc63c91dad7e4d1f44eac7a4d0e8 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 20 Jan 2015 13:26:37 -0500
Subject: [PATCH 12/35] Changed to non-callback API since all methods are
 synchronous

---
 src/Calib3D.cc | 62 +++++++++++---------------------------------------
 1 file changed, 13 insertions(+), 49 deletions(-)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index f8a1fcc..3519470 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -38,47 +38,27 @@ NAN_METHOD(Calib3D::FindChessboardCorners)
 
         // Arg 2 would normally be the flags, ignoring this for now and using the default flags
 
-        // Final argument is the callback function
-        REQ_FUN_ARG(2, cb);
-
         // Find the corners
         std::vector<cv::Point2f> corners;
         bool found = cv::findChessboardCorners(mat, patternSize, corners);
 
-        // Make the callback arguments
-        Local<Value> argv[2];
+        // Make the return value
+        Local<Object> ret = NanNew<Object>();
+        ret->Set(NanNew<String>("found"), NanNew<Boolean>(found));
 
-        argv[0] = NanNull();
-        argv[1] = NanNull(); // This will be replaced by the corners array if corners were found
-
-        // Further processing if we found corners
-        Local<Array> cornersArray;
-        if(found)
+        Local<Array> cornersArray = Array::New(corners.size());
+        for(unsigned int i = 0; i < corners.size(); i++)
         {
-            // Convert the return value to a javascript array
-            cornersArray = Array::New(corners.size());
-            for(unsigned int i = 0; i < corners.size(); i++)
-            {
-                Local<Object> point_data = NanNew<Object>();
-                point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
-                point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
+            Local<Object> point_data = NanNew<Object>();
+            point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
+            point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
 
-                cornersArray->Set(Number::New(i), point_data);
-            }
-
-            argv[1] = cornersArray;
+            cornersArray->Set(Number::New(i), point_data);
         }
 
-        // Callback
-        TryCatch try_catch;
+        ret->Set(NanNew<String>("corners"), cornersArray);
 
-        cb->Call(NanGetCurrentContext()->Global(), 2, argv);
-
-        if(try_catch.HasCaught()) {
-            FatalException(try_catch);
-        }
-
-        NanReturnUndefined();
+        NanReturnValue(ret);
 
 
     } catch (cv::Exception &e) {
@@ -129,27 +109,11 @@ NAN_METHOD(Calib3D::DrawChessboardCorners)
         // Arg 3, pattern found boolean
         bool patternWasFound = args[3]->ToBoolean()->Value();
 
-        // Final argument is the callback
-        REQ_FUN_ARG(4, cb);
-
         // Draw the corners
         cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound);
 
-        // Make the callback arguments (same image that was passed, now with corners drawn on it)
-        Local<Value> argv[2];
-        argv[0] = NanNull();
-        argv[1] = args[0];
-
-        // Callback
-        TryCatch try_catch;
-
-        cb->Call(NanGetCurrentContext()->Global(), 2, argv);
-
-        if(try_catch.HasCaught()) {
-            FatalException(try_catch);
-        }
-
-        NanReturnUndefined();
+        // Return the passed image, now with corners drawn on it
+        NanReturnValue(args[0]);
 
     } catch (cv::Exception &e) {
         const char *err_msg = e.what();

From 9e04f9570371bbd30ff196eeb085c4ff1571c53d Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 20 Jan 2015 14:05:58 -0500
Subject: [PATCH 13/35] Added solvePnP

---
 src/Calib3D.cc | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/Calib3D.h  |  2 ++
 2 files changed, 86 insertions(+)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index 3519470..b031965 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -10,6 +10,7 @@ void Calib3D::Init(Handle<Object> target)
     NODE_SET_METHOD(obj, "findChessboardCorners", FindChessboardCorners);
     NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners);
     NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera);
+    NODE_SET_METHOD(obj, "solvePnP", SolvePnP);
 
     target->Set(NanNew("calib3d"), obj);
 }
@@ -228,3 +229,86 @@ NAN_METHOD(Calib3D::CalibrateCamera)
         NanReturnUndefined();
     }
 }
+
+// cv::solvePnP
+NAN_METHOD(Calib3D::SolvePnP)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments
+
+        // Arg 0, the array of object points
+        std::vector<cv::Point3f> objectPoints;
+        if(args[0]->IsArray()) {
+            Local<Array> objectPointsArray = Local<Array>::Cast(args[0]);
+
+            for(unsigned int i = 0; i < objectPointsArray->Length(); i++)
+            {
+                Local<Object> pt = objectPointsArray->Get(i)->ToObject();
+                objectPoints.push_back(cv::Point3f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
+                                             pt->Get(NanNew<String>("y"))->ToNumber()->Value(),
+                                             pt->Get(NanNew<String>("z"))->ToNumber()->Value()));
+            }
+        } else {
+            JSTHROW_TYPE("Must pass array of object points for each frame")
+        }
+
+        // Arg 1, the image points
+        std::vector<cv::Point2f> imagePoints;
+        if(args[1]->IsArray()) {
+            Local<Array> imagePointsArray = Local<Array>::Cast(args[1]);
+
+            for(unsigned int i = 0; i < imagePointsArray->Length(); i++)
+            {
+                Local<Object> pt = imagePointsArray->Get(i)->ToObject();
+                imagePoints.push_back(cv::Point2f(pt->Get(NanNew<String>("x"))->ToNumber()->Value(),
+                                                  pt->Get(NanNew<String>("y"))->ToNumber()->Value()));
+            }
+        } else {
+            JSTHROW_TYPE("Must pass array of object points for each frame")
+        }
+
+        // Arg 2, the camera matrix
+        Matrix* kWrap = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+        cv::Mat K = kWrap->mat;
+
+        // Arg 3, the distortion coefficients
+        Matrix* distWrap = ObjectWrap::Unwrap<Matrix>(args[3]->ToObject());
+        cv::Mat dist = distWrap->mat;
+
+        // Arg 4, use extrinsic guess, skipped for now
+
+        // Arg 5, flags, skip for now
+
+        // solve for r and t
+        cv::Mat rvec, tvec;
+
+        cv::solvePnP(objectPoints, imagePoints, K, dist, rvec, tvec);
+
+        // make the return values
+        Local<Object> ret = NanNew<Object>();
+
+        // rvec
+        Local<Object> rMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *rMatrix = ObjectWrap::Unwrap<Matrix>(rMatrixWrap);
+        rMatrix->mat = rvec;
+
+        ret->Set(NanNew<String>("rvec"), rMatrixWrap);
+
+        // tvec
+        Local<Object> tMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *tMatrix = ObjectWrap::Unwrap<Matrix>(tMatrixWrap);
+        tMatrix->mat = tvec;
+
+        ret->Set(NanNew<String>("tvec"), tMatrixWrap);
+
+        // Return
+        NanReturnValue(ret);
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/Calib3D.h b/src/Calib3D.h
index e42df5c..67bf2c7 100644
--- a/src/Calib3D.h
+++ b/src/Calib3D.h
@@ -14,6 +14,8 @@ public:
     static NAN_METHOD(DrawChessboardCorners);
 
     static NAN_METHOD(CalibrateCamera);
+
+    static NAN_METHOD(SolvePnP);
 };
 
 #endif

From 9e9bf23e95134f4ed11bd23c3eee2bb9d5876349 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Wed, 21 Jan 2015 10:56:16 -0500
Subject: [PATCH 14/35] Switched to NaNNew functions to avoid compile errors on
 differing node versions

---
 src/Calib3D.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index b031965..6f078a8 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -47,14 +47,14 @@ NAN_METHOD(Calib3D::FindChessboardCorners)
         Local<Object> ret = NanNew<Object>();
         ret->Set(NanNew<String>("found"), NanNew<Boolean>(found));
 
-        Local<Array> cornersArray = Array::New(corners.size());
+        Local<Array> cornersArray = NanNew<Array>(corners.size());
         for(unsigned int i = 0; i < corners.size(); i++)
         {
             Local<Object> point_data = NanNew<Object>();
             point_data->Set(NanNew<String>("x"), NanNew<Number>(corners[i].x));
             point_data->Set(NanNew<String>("y"), NanNew<Number>(corners[i].y));
 
-            cornersArray->Set(Number::New(i), point_data);
+            cornersArray->Set(NanNew<Number>(i), point_data);
         }
 
         ret->Set(NanNew<String>("corners"), cornersArray);

From 176887e3ba8c9a7a98b2f7e1ac408e8a7560a1d6 Mon Sep 17 00:00:00 2001
From: Peter Braden <peterbraden@peterbraden.co.uk>
Date: Mon, 26 Jan 2015 17:41:14 +0100
Subject: [PATCH 15/35] Update README.md

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 8060758..a698e34 100755
--- a/README.md
+++ b/README.md
@@ -172,13 +172,13 @@ See [relevant source code](src/Contours.cc) and [examples](examples/)
 ```javascript
 var contours = im.findContours;
 
-# Count of contours in the Contours object
+// Count of contours in the Contours object
 contours.size();
 
-# Count of corners(verticies) of contour `index`
+// Count of corners(verticies) of contour `index`
 contours.cornerCount(index);
 
-# Access vertex data of contours
+// 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) {
@@ -187,14 +187,14 @@ for(var c = 0; c < contours.size(); ++c) {
   }
 }
 
-# Computations of contour `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`
+// Destructively alter contour `index`
 contours.approxPolyDP(index, epsilon, isClosed);
 contours.convexHull(index, clockwise);
 ```

From 52a45179267abcbe1e609c3cd1eb9eb1c749eeb7 Mon Sep 17 00:00:00 2001
From: Peter Braden <peterbraden@peterbraden.co.uk>
Date: Mon, 26 Jan 2015 17:42:14 +0100
Subject: [PATCH 16/35] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a698e34..37d61ef 100755
--- a/README.md
+++ b/README.md
@@ -183,7 +183,7 @@ 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 + ")");"
+    console.log("(" + point.x + "," + point.y + ")");
   }
 }
 

From 96068dd7a935f37bac8a42fef31dc6e7fff92e9f Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 10:53:06 -0500
Subject: [PATCH 17/35] Added stub imgproc source file

---
 binding.gyp    |  1 +
 src/ImgProc.cc | 10 ++++++++++
 src/ImgProc.h  | 13 +++++++++++++
 src/init.cc    |  2 ++
 4 files changed, 26 insertions(+)
 create mode 100644 src/ImgProc.cc
 create mode 100644 src/ImgProc.h

diff --git a/binding.gyp b/binding.gyp
index 6e56fc9..449c088 100755
--- a/binding.gyp
+++ b/binding.gyp
@@ -15,6 +15,7 @@
         , "src/BackgroundSubtractor.cc"
         , "src/Constants.cc"
         , "src/Calib3D.cc"
+        , "src/ImgProc.cc"
         ]
       , 'libraries': [
           '<!@(pkg-config --libs opencv)'
diff --git a/src/ImgProc.cc b/src/ImgProc.cc
new file mode 100644
index 0000000..7945d93
--- /dev/null
+++ b/src/ImgProc.cc
@@ -0,0 +1,10 @@
+#include "ImgProc.h"
+
+void ImgProc::Init(Handle<Object> target)
+{
+    Persistent<Object> inner;
+    Local<Object> obj = NanNew<Object>();
+    NanAssignPersistent(inner, obj);
+
+    target->Set(NanNew("imgproc"), obj);
+}
diff --git a/src/ImgProc.h b/src/ImgProc.h
new file mode 100644
index 0000000..140b056
--- /dev/null
+++ b/src/ImgProc.h
@@ -0,0 +1,13 @@
+#ifndef __NODE_IMGPROC_H
+#define __NODE_IMGPROC_H
+
+#include "OpenCV.h"
+
+// Implementation of imgproc.hpp functions
+
+class ImgProc: public node::ObjectWrap {
+public:
+    static void Init(Handle<Object> target);
+};
+
+#endif
diff --git a/src/init.cc b/src/init.cc
index 2486e07..95eef1a 100755
--- a/src/init.cc
+++ b/src/init.cc
@@ -10,6 +10,7 @@
 #include "FaceRecognizer.h"
 #include "Constants.h"
 #include "Calib3D.h"
+#include "ImgProc.h"
 
 extern "C" void
 init(Handle<Object> target) {
@@ -25,6 +26,7 @@ init(Handle<Object> target) {
     NamedWindow::Init(target);
     Constants::Init(target);
     Calib3D::Init(target);
+    ImgProc::Init(target);
 
 
    #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4

From 92f0bf80e575376b74d766d2699baef81d37be96 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 11:16:36 -0500
Subject: [PATCH 18/35] Added cv::undistort

---
 src/ImgProc.cc | 44 ++++++++++++++++++++++++++++++++++++++++++++
 src/ImgProc.h  |  2 ++
 2 files changed, 46 insertions(+)

diff --git a/src/ImgProc.cc b/src/ImgProc.cc
index 7945d93..d0b1ea6 100644
--- a/src/ImgProc.cc
+++ b/src/ImgProc.cc
@@ -1,4 +1,5 @@
 #include "ImgProc.h"
+#include "Matrix.h"
 
 void ImgProc::Init(Handle<Object> target)
 {
@@ -6,5 +7,48 @@ void ImgProc::Init(Handle<Object> target)
     Local<Object> obj = NanNew<Object>();
     NanAssignPersistent(inner, obj);
 
+    NODE_SET_METHOD(obj, "undistort", Undistort);
+
     target->Set(NanNew("imgproc"), obj);
 }
+
+// cv::undistort
+NAN_METHOD(ImgProc::Undistort)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments
+
+        // Arg 0 is the image
+        Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat inputImage = m0->mat;
+
+        // Arg 1 is the camera matrix
+        Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+        cv::Mat K = m1->mat;
+
+        // Arg 2 is the distortion coefficents
+        Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+        cv::Mat dist = m2->mat;
+
+        // Make an mat to hold the result image
+        cv::Mat outputImage;
+
+        // Undistort
+        cv::undistort(inputImage, outputImage, K, dist);
+
+        // Wrap the output image
+        Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
+        outMatrix->mat = outputImage;
+
+        // Return the output image
+        NanReturnValue(outMatrixWrap);
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/ImgProc.h b/src/ImgProc.h
index 140b056..c00393f 100644
--- a/src/ImgProc.h
+++ b/src/ImgProc.h
@@ -8,6 +8,8 @@
 class ImgProc: public node::ObjectWrap {
 public:
     static void Init(Handle<Object> target);
+
+    static NAN_METHOD(Undistort);
 };
 
 #endif

From b76c39a42e090d6adaf951f4d6c00250bbe5396a Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 11:49:01 -0500
Subject: [PATCH 19/35] Added getOptimalNewCameraMatrix

---
 src/Calib3D.cc | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/Calib3D.h  |  2 ++
 2 files changed, 63 insertions(+)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index 6f078a8..274844e 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -11,6 +11,7 @@ void Calib3D::Init(Handle<Object> target)
     NODE_SET_METHOD(obj, "drawChessboardCorners", DrawChessboardCorners);
     NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera);
     NODE_SET_METHOD(obj, "solvePnP", SolvePnP);
+    NODE_SET_METHOD(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix);
 
     target->Set(NanNew("calib3d"), obj);
 }
@@ -312,3 +313,63 @@ NAN_METHOD(Calib3D::SolvePnP)
         NanReturnUndefined();
     }
 }
+
+// cv::solvePnP
+NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments
+
+        // Arg 0 is the original camera matrix
+        Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat Kin = m0->mat;
+
+        // Arg 1 is the distortion coefficients
+        Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+        cv::Mat dist = m1->mat;
+
+        // Arg 2, the image size
+        cv::Size imageSize;
+        if (args[2]->IsArray()) {
+            Local<Object> v8sz = args[2]->ToObject();
+
+            imageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 3 is the alpha free scaling parameter
+        double alpha = args[3]->ToNumber()->Value();
+
+        // Arg 4, the new image size
+        cv::Size newImageSize;
+        if (args[4]->IsArray()) {
+            Local<Object> v8sz = args[4]->ToObject();
+
+            newImageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 5, valid ROI, skip for now
+        // Arg 6, center principal point, skip for now
+
+        // Get the optimal new camera matrix
+        cv::Mat Kout = cv::getOptimalNewCameraMatrix(Kin, dist, imageSize, alpha, newImageSize);
+
+        // Wrap the output K
+        Local<Object> KMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *KMatrix = ObjectWrap::Unwrap<Matrix>(KMatrixWrap);
+        KMatrix->mat = Kout;
+
+        // Return the new K matrix
+        NanReturnValue(KMatrixWrap);
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/Calib3D.h b/src/Calib3D.h
index 67bf2c7..ab5669e 100644
--- a/src/Calib3D.h
+++ b/src/Calib3D.h
@@ -16,6 +16,8 @@ public:
     static NAN_METHOD(CalibrateCamera);
 
     static NAN_METHOD(SolvePnP);
+
+    static NAN_METHOD(GetOptimalNewCameraMatrix);
 };
 
 #endif

From a66d95b53715e1bdf10ca3b49f23f29516d01af7 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 12:02:08 -0500
Subject: [PATCH 20/35] Added initUndistortRectifyMap

---
 src/ImgProc.cc | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/ImgProc.h  |  2 ++
 2 files changed, 70 insertions(+)

diff --git a/src/ImgProc.cc b/src/ImgProc.cc
index d0b1ea6..4291e17 100644
--- a/src/ImgProc.cc
+++ b/src/ImgProc.cc
@@ -8,6 +8,7 @@ void ImgProc::Init(Handle<Object> target)
     NanAssignPersistent(inner, obj);
 
     NODE_SET_METHOD(obj, "undistort", Undistort);
+    NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
 
     target->Set(NanNew("imgproc"), obj);
 }
@@ -52,3 +53,70 @@ NAN_METHOD(ImgProc::Undistort)
         NanReturnUndefined();
     }
 }
+
+// cv::initUndistortRectifyMap
+NAN_METHOD(ImgProc::InitUndistortRectifyMap)
+{
+    NanEscapableScope();
+
+    try {
+
+        // Arg 0 is the camera matrix
+        Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat K = m0->mat;
+
+        // Arg 1 is the distortion coefficents
+        Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+        cv::Mat dist = m1->mat;
+
+        // Arg 2 is the recification transformation
+        Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+        cv::Mat R = m2->mat;
+
+        // Arg 3 is the new camera matrix
+        Matrix* m3 = ObjectWrap::Unwrap<Matrix>(args[3]->ToObject());
+        cv::Mat newK = m3->mat;
+
+        // Arg 4 is the image size
+        cv::Size imageSize;
+        if (args[4]->IsArray()) {
+            Local<Object> v8sz = args[4]->ToObject();
+
+            imageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass pattern size");
+        }
+
+        // Arg 5 is the first map type, skip for now
+        int m1type = CV_16SC2;
+
+        // Make matrices to hold the output maps
+        cv::Mat map1, map2;
+
+        // Compute the rectification map
+        cv::initUndistortRectifyMap(K, dist, R, newK, imageSize, m1type, map1, map2);
+
+        // Wrap the output maps
+        Local<Object> map1Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *map1Matrix = ObjectWrap::Unwrap<Matrix>(map1Wrap);
+        map1Matrix->mat = map1;
+
+        Local<Object> map2Wrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *map2Matrix = ObjectWrap::Unwrap<Matrix>(map2Wrap);
+        map2Matrix->mat = map2;
+
+        // Make a return object with the two maps
+        Local<Object> ret = NanNew<Object>();
+        ret->Set(NanNew<String>("map1"), map1Wrap);
+        ret->Set(NanNew<String>("map2"), map2Wrap);
+
+        // Return the maps
+        NanReturnValue(ret);
+
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/ImgProc.h b/src/ImgProc.h
index c00393f..9689403 100644
--- a/src/ImgProc.h
+++ b/src/ImgProc.h
@@ -10,6 +10,8 @@ public:
     static void Init(Handle<Object> target);
 
     static NAN_METHOD(Undistort);
+
+    static NAN_METHOD(InitUndistortRectifyMap);
 };
 
 #endif

From 51be174b6e5056004f70a866d6346f50ad615718 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 12:22:05 -0500
Subject: [PATCH 21/35] Added interpolation constants

---
 src/Constants.cc | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/Constants.cc b/src/Constants.cc
index e5b3b68..1d9696b 100644
--- a/src/Constants.cc
+++ b/src/Constants.cc
@@ -4,6 +4,9 @@
 #define CONST(C) \
   obj->Set(NanNew<String>(#C), NanNew<Integer>(C));
 
+#define CONST_ENUM(C) \
+    obj->Set(NanNew<String>(#C), NanNew<Integer>((int)(cv::C)));
+
 void
 Constants::Init(Handle<Object> target) {
   Persistent<Object> inner;
@@ -54,6 +57,12 @@ Constants::Init(Handle<Object> target) {
   CONST(CV_64FC3);
   CONST(CV_64FC4);
 
+  CONST_ENUM(INTER_NEAREST);
+  CONST_ENUM(INTER_LINEAR);
+  CONST_ENUM(INTER_AREA);
+  CONST_ENUM(INTER_CUBIC);
+  CONST_ENUM(INTER_LANCZOS4);
+
   target->Set(NanNew("Constants"), obj);
 }
 

From 3d09bb30ea87bdd11f7fa3a30f30acc8777e57a5 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 12:55:32 -0500
Subject: [PATCH 22/35] Added remap

---
 src/ImgProc.cc | 51 ++++++++++++++++++++++++++++++++++++++++++++++++--
 src/ImgProc.h  |  2 ++
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/src/ImgProc.cc b/src/ImgProc.cc
index 4291e17..4c090a6 100644
--- a/src/ImgProc.cc
+++ b/src/ImgProc.cc
@@ -9,6 +9,7 @@ void ImgProc::Init(Handle<Object> target)
 
     NODE_SET_METHOD(obj, "undistort", Undistort);
     NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
+    NODE_SET_METHOD(obj, "remap", Remap);
 
     target->Set(NanNew("imgproc"), obj);
 }
@@ -82,9 +83,9 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap)
         if (args[4]->IsArray()) {
             Local<Object> v8sz = args[4]->ToObject();
 
-            imageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+            imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
         } else {
-            JSTHROW_TYPE("Must pass pattern size");
+            JSTHROW_TYPE("Must pass image size");
         }
 
         // Arg 5 is the first map type, skip for now
@@ -120,3 +121,49 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap)
         NanReturnUndefined();
     }
 }
+
+// cv::remap
+NAN_METHOD(ImgProc::Remap)
+{
+    NanEscapableScope();
+
+    try {
+        // Get the arguments
+
+        // Arg 0 is the image
+        Matrix* m0 = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
+        cv::Mat inputImage = m0->mat;
+
+        // Arg 1 is the first map
+        Matrix* m1 = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
+        cv::Mat map1 = m1->mat;
+
+        // Arg 2 is the second map
+        Matrix* m2 = ObjectWrap::Unwrap<Matrix>(args[2]->ToObject());
+        cv::Mat map2 = m2->mat;
+
+        // Arg 3 is the interpolation mode
+        int interpolation = args[3]->IntegerValue();
+
+        // Args 4, 5 border settings, skipping for now
+
+        // Output image
+        cv::Mat outputImage;
+
+        // Remap
+        cv::remap(inputImage, outputImage, map1, map2, interpolation);
+
+        // Wrap the output image
+        Local<Object> outMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
+        Matrix *outMatrix = ObjectWrap::Unwrap<Matrix>(outMatrixWrap);
+        outMatrix->mat = outputImage;
+
+        // Return the image
+        NanReturnValue(outMatrixWrap);
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+}
diff --git a/src/ImgProc.h b/src/ImgProc.h
index 9689403..6d26458 100644
--- a/src/ImgProc.h
+++ b/src/ImgProc.h
@@ -12,6 +12,8 @@ public:
     static NAN_METHOD(Undistort);
 
     static NAN_METHOD(InitUndistortRectifyMap);
+
+    static NAN_METHOD(Remap);
 };
 
 #endif

From d9aaf529f85e913de51c7ae26ae2d032acb54149 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 12:55:42 -0500
Subject: [PATCH 23/35] Fixed bug causing image sizes to be transposed

---
 src/Calib3D.cc | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index 274844e..f223fef 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -184,7 +184,7 @@ NAN_METHOD(Calib3D::CalibrateCamera)
         if (args[2]->IsArray()) {
             Local<Object> v8sz = args[2]->ToObject();
 
-            imageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+            imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
         } else {
             JSTHROW_TYPE("Must pass pattern size");
         }
@@ -335,9 +335,9 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix)
         if (args[2]->IsArray()) {
             Local<Object> v8sz = args[2]->ToObject();
 
-            imageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+            imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
         } else {
-            JSTHROW_TYPE("Must pass pattern size");
+            JSTHROW_TYPE("Must pass original image size");
         }
 
         // Arg 3 is the alpha free scaling parameter
@@ -348,9 +348,9 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix)
         if (args[4]->IsArray()) {
             Local<Object> v8sz = args[4]->ToObject();
 
-            newImageSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue());
+            newImageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
         } else {
-            JSTHROW_TYPE("Must pass pattern size");
+            JSTHROW_TYPE("Must pass new image size");
         }
 
         // Arg 5, valid ROI, skip for now

From 8ed5177c34f5942352e2e43be65ebd34909f31c1 Mon Sep 17 00:00:00 2001
From: Max Ehrlich <max.ehr@gmail.com>
Date: Tue, 27 Jan 2015 12:59:51 -0500
Subject: [PATCH 24/35] Added map1 type paramter to initUndistortRectifyMap

---
 src/ImgProc.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ImgProc.cc b/src/ImgProc.cc
index 4c090a6..d3210fd 100644
--- a/src/ImgProc.cc
+++ b/src/ImgProc.cc
@@ -89,7 +89,7 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap)
         }
 
         // Arg 5 is the first map type, skip for now
-        int m1type = CV_16SC2;
+        int m1type = args[5]->IntegerValue();
 
         // Make matrices to hold the output maps
         cv::Mat map1, map2;

From 4bc20cda6f12b799b3660c3722eefd0ad1c7b8fb Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Wed, 4 Feb 2015 11:22:09 -0600
Subject: [PATCH 25/35] Fix issue with different versions of opencv installed
 in different OSs, updated cflags opencv version in bindings.gyp

---
 binding.gyp | 120 +++++++++++++++++++++++++++-------------------------
 1 file changed, 63 insertions(+), 57 deletions(-)

diff --git a/binding.gyp b/binding.gyp
index 3d16eed..e13a62b 100755
--- a/binding.gyp
+++ b/binding.gyp
@@ -1,72 +1,78 @@
 {
   "targets": [{
-      "target_name": "opencv"
-      , "sources": [
-          "src/init.cc"
-        , "src/Matrix.cc"
-        , "src/OpenCV.cc"
-        , "src/CascadeClassifierWrap.cc"
-        , "src/Contours.cc"
-        , "src/Point.cc"
-        , "src/VideoCaptureWrap.cc"
-        , "src/CamShift.cc"
-        , "src/HighGUI.cc"
-        , "src/FaceRecognizer.cc"
-        , "src/BackgroundSubtractor.cc"
-        , "src/Constants.cc"
-        ]
-      , 'libraries': [
-          '<!@(pkg-config --libs opencv)'
-        ]
+    "target_name": "opencv",
+      "sources": [
+        "src/init.cc",
+        "src/Matrix.cc",
+        "src/OpenCV.cc",
+        "src/CascadeClassifierWrap.cc",
+        "src/Contours.cc",
+        "src/Point.cc",
+        "src/VideoCaptureWrap.cc",
+        "src/CamShift.cc",
+        "src/HighGUI.cc",
+        "src/FaceRecognizer.cc",
+        "src/BackgroundSubtractor.cc",
+        "src/Constants.cc"
+      ],
+
+      "libraries": [
+        "<!@(pkg-config --libs opencv)"
+      ],
 
       # For windows
-      ,'include_dirs': [
-          '<!@(pkg-config --cflags opencv)',
-          "<!(node -e \"require('nan')\")"
-          ]
 
-      , 'cflags': [
-            '<!@(pkg-config --cflags "opencv >= 2.4.9" )'
-            , '-Wall'
-          ]
-      , 'cflags!' : [ '-fno-exceptions']
-      , 'cflags_cc!': [ '-fno-rtti',  '-fno-exceptions']
-      , "conditions": [
-        ['OS=="win"',
-          {
-            'msvs_settings': {
-              'VCCLCompilerTool': {
-                'ExceptionHandling': '2',
-                'DisableSpecificWarnings': [ '4530', '4506', '4244' ],
-              },
-            },
-          },
-        ],
-        ['OS=="mac"', {
-          # cflags on OS X are stupid and have to be defined like this
-          'xcode_settings': {
-            'OTHER_CFLAGS': [
-              "-mmacosx-version-min=10.7",
-              "-std=c++11",
-              "-stdlib=libc++",
-              '<!@(pkg-config --cflags opencv)'
+      "include_dirs": [
+        "<!@(pkg-config --cflags opencv)",
+        "<!(node -e \"require('nan')\")"
+      ],
+
+      "cflags!" : [ "-fno-exceptions"],
+      "cflags_cc!": [ "-fno-rtti",  "-fno-exceptions"],
+
+      "conditions": [
+        [ "OS==\"linux\"", {
+            "cflags": [
+              "<!@(pkg-config --cflags \"opencv >= 2.3.1\" )",
+              "-Wall"
             ]
-            , "GCC_ENABLE_CPP_RTTI": "YES"
-            , "GCC_ENABLE_CPP_EXCEPTIONS": "YES"
+        }],
+        [ "OS==\"win\"", {
+            "cflags": [
+              "<!@(pkg-config --cflags \"opencv >= 2.4.9\" )",
+              "-Wall"
+            ],
+            "msvs_settings": {
+              "VCCLCompilerTool": {
+                "ExceptionHandling": "2",
+                "DisableSpecificWarnings": [ "4530", "4506", "4244" ],
+              },
+            }
+        }],
+        [ # cflags on OS X are stupid and have to be defined like this
+          "OS==\"mac\"", {
+            "xcode_settings": {
+            "OTHER_CFLAGS": [
+              "-mmacosx-version-min=10.7",
+            "-std=c++11",
+            "-stdlib=libc++",
+            "<!@(pkg-config --cflags opencv)"
+              ],
+            "GCC_ENABLE_CPP_RTTI": "YES",
+            "GCC_ENABLE_CPP_EXCEPTIONS": "YES"
           }
         }]
-
     ]
   },
-  {
-    "target_name": "action_after_build",
-    "type": "none",
-    "dependencies": [ "<(module_name)" ],
-    "copies": [
+    {
+      "target_name": "action_after_build",
+      "type": "none",
+      "dependencies": [ "<(module_name)" ],
+      "copies": [
       {
         "files": [ "<(PRODUCT_DIR)/<(module_name).node" ],
         "destination": "<(module_path)"
       }
-    ]
-  }]
+      ]
+    }]
 }

From aeff4d10f6955d6dc3b1cbfc59fb8653d01bde43 Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Wed, 4 Feb 2015 11:51:29 -0600
Subject: [PATCH 26/35] Update travis opencv version.

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index d9cfb7c..6455591 100755
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,6 +13,7 @@ env:
 
 before_install:
   # Fix a problem with apt-get failing later, see http://docs.travis-ci.com/user/installing-dependencies/#Installing-Ubuntu-packages
+  - sudo add-apt-repository -y ppa:kubuntu-ppa/backports
   - sudo apt-get update -qq
   - sudo apt-get install libcv-dev
   - sudo apt-get install libopencv-dev

From 37bda024c28b95eff31668728577215be2c5569a Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Wed, 4 Feb 2015 11:56:12 -0600
Subject: [PATCH 27/35] Force ppa update to get newer version of opencv.

---
 .travis.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 6455591..ff7cf32 100755
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,8 +13,9 @@ env:
 
 before_install:
   # Fix a problem with apt-get failing later, see http://docs.travis-ci.com/user/installing-dependencies/#Installing-Ubuntu-packages
-  - sudo add-apt-repository -y ppa:kubuntu-ppa/backports
   - sudo apt-get update -qq
+  - sudo add-apt-repository -y ppa:kubuntu-ppa/backports
+  - sudo apt-get update
   - sudo apt-get install libcv-dev
   - sudo apt-get install libopencv-dev
   - sudo apt-get install libhighgui-dev

From 7d16f2e0469be04982b0ef8106f41b6576c4afff Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Wed, 4 Feb 2015 12:51:35 -0600
Subject: [PATCH 28/35] Return to old version of opencv to try compilation.

---
 .travis.yml                 |  4 ++--
 smoke/smoketest.js          |  8 ++++----
 src/BackgroundSubtractor.cc | 35 ++++++++++++++++++-----------------
 3 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index ff7cf32..1508190 100755
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,8 +14,8 @@ env:
 before_install:
   # Fix a problem with apt-get failing later, see http://docs.travis-ci.com/user/installing-dependencies/#Installing-Ubuntu-packages
   - sudo apt-get update -qq
-  - sudo add-apt-repository -y ppa:kubuntu-ppa/backports
-  - sudo apt-get update
+  # - sudo add-apt-repository -y ppa:kubuntu-ppa/backports
+  # - sudo apt-get update
   - sudo apt-get install libcv-dev
   - sudo apt-get install libopencv-dev
   - sudo apt-get install libhighgui-dev
diff --git a/smoke/smoketest.js b/smoke/smoketest.js
index d26d474..a34295e 100755
--- a/smoke/smoketest.js
+++ b/smoke/smoketest.js
@@ -1,6 +1,6 @@
-var cv = require('../lib/opencv')
+var cv = require('../lib/opencv');
 
-var trainingData = []
+var trainingData = [];
 /*
 for (var i = 1; i< 41; i++){
   for (var j = 1; j<10; j++){
@@ -22,5 +22,5 @@ cv.readImage("/Users/peterbraden/Downloads/orl_faces/s6/10.pgm", function(e, im)
 */
 cv.readImage("./examples/files/mona.png", function(e, mat){
   var th = mat.threshold(200, 200, "Threshold to Zero Inverted");
-  th.save('./examples/tmp/out.png')
-})
+  th.save('./examples/tmp/out.png');
+});
diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc
index e9de264..b066529 100644
--- a/src/BackgroundSubtractor.cc
+++ b/src/BackgroundSubtractor.cc
@@ -21,7 +21,7 @@ BackgroundSubtractorWrap::Init(Handle<Object> target) {
     NODE_SET_PROTOTYPE_METHOD(ctor, "applyMOG", ApplyMOG);
 
     target->Set(NanNew("BackgroundSubtractor"), ctor->GetFunction());
-    
+
 };
 
 NAN_METHOD(BackgroundSubtractorWrap::New) {
@@ -42,17 +42,17 @@ NAN_METHOD(BackgroundSubtractorWrap::New) {
 NAN_METHOD(BackgroundSubtractorWrap::CreateMOG) {
   NanScope();
 
-  int history = 200;
-  int nmixtures = 5;
-  double backgroundRatio = 0.7;
-  double noiseSigma = 0;
-
-  if(args.Length() > 1){
-    INT_FROM_ARGS(history, 0)
-    INT_FROM_ARGS(nmixtures, 1)
-    DOUBLE_FROM_ARGS(backgroundRatio, 2)
-    DOUBLE_FROM_ARGS(noiseSigma, 3)
-  }
+  // int history = 200;
+  // int nmixtures = 5;
+  // double backgroundRatio = 0.7;
+  // double noiseSigma = 0;
+  //
+  // if(args.Length() > 1){
+  //   INT_FROM_ARGS(history, 0)
+  //   INT_FROM_ARGS(nmixtures, 1)
+  //   DOUBLE_FROM_ARGS(backgroundRatio, 2)
+  //   DOUBLE_FROM_ARGS(noiseSigma, 3)
+  // }
 
   Local<Object> n = NanNew(BackgroundSubtractorWrap::constructor)->GetFunction()->NewInstance();
 
@@ -83,13 +83,13 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) {
 
     Local<Object> fgMask = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
     Matrix *img = ObjectWrap::Unwrap<Matrix>(fgMask);
-    
+
 
     cv::Mat mat;
-    
+
     if(Buffer::HasInstance(args[0])){
       uint8_t *buf = (uint8_t *) Buffer::Data(args[0]->ToObject());
-      unsigned len = Buffer::Length(args[0]->ToObject());  
+      unsigned len = Buffer::Length(args[0]->ToObject());
       cv::Mat *mbuf = new cv::Mat(len, 1, CV_64FC1, buf);
       mat = cv::imdecode(*mbuf, -1);
       //mbuf->release();
@@ -116,13 +116,13 @@ NAN_METHOD(BackgroundSubtractorWrap::ApplyMOG) {
     TryCatch try_catch;
 
     cb->Call(NanGetCurrentContext()->Global(), 2, argv);
-      
+
     if (try_catch.HasCaught()) {
         FatalException(try_catch);
       }
 
       NanReturnUndefined();
-  } 
+  }
   catch( cv::Exception& e ){
     const char* err_msg = e.what();
     NanThrowError(err_msg);
@@ -136,3 +136,4 @@ BackgroundSubtractorWrap::BackgroundSubtractorWrap(cv::Ptr<cv::BackgroundSubtrac
 };
 
 #endif
+

From 16380f445ef60147a7c586b1e81fa6a893ed487d Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Wed, 4 Feb 2015 13:02:09 -0600
Subject: [PATCH 29/35] Fix missing targets from bindings to make tests pass.

---
 binding.gyp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/binding.gyp b/binding.gyp
index e13a62b..ef75193 100755
--- a/binding.gyp
+++ b/binding.gyp
@@ -13,7 +13,9 @@
         "src/HighGUI.cc",
         "src/FaceRecognizer.cc",
         "src/BackgroundSubtractor.cc",
-        "src/Constants.cc"
+        "src/Constants.cc",
+        "src/Calib3D.cc",
+        "src/ImgProc.cc"
       ],
 
       "libraries": [

From 90244f1db2cd2b22482d1c6fbdd2ee723738f9b8 Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Thu, 5 Feb 2015 16:24:18 -0600
Subject: [PATCH 30/35] Print available libraries for opencv.

---
 appveyor.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/appveyor.yml b/appveyor.yml
index 256371e..6559ec1 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -50,6 +50,8 @@ before_build:
   - cmd: SET OPENCV_DIR=%OPENCV_ROOT_PATH%\build\%ARCH%\vc12\bin
   - cmd: SET PATH=%cd%\node_modules\.bin\;C:\MinGW\bin;C:\GTK\bin;C:\msys\1.0\bin;%OPENCV_DIR%;%PATH%
   - cmd: SET PKG_CONFIG_PATH=C:\GTK\lib\pkgconfig
+  - cmd: DIR %OPENCV_ROOT_PATH%\build\%ARCH%\vc12\bin
+  - cmd: DIR %OPENCV_ROOT_PATH%\build\%ARCH%\vc12\lib
   # Here we need to copy the opencv.pc file from the repo into PKG_CONFIG_PATH
   # trick part is to check for the vc12 folder and use that one
   - cmd: copy .\utils\opencv_x64.pc C:\GTK\lib\pkgconfig\opencv.pc

From 081ac43f1ba3cf610554aa5931c3674f5778787e Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Thu, 5 Feb 2015 16:53:02 -0600
Subject: [PATCH 31/35] Added all opencv libraries to opencv.pc file.

---
 utils/opencv_x64.pc | 3 ++-
 utils/opencv_x86.pc | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/utils/opencv_x64.pc b/utils/opencv_x64.pc
index cf1fa63..98b80c0 100644
--- a/utils/opencv_x64.pc
+++ b/utils/opencv_x64.pc
@@ -9,4 +9,5 @@ Description: Open Source Computer Vision Library
 Version: 2.4.9
 
 Cflags: ${includedir} ${includedir}/opencv
-Libs: ${libdir}/opencv_core249 ${libdir}/opencv_imgproc249 ${libdir}/opencv_highgui249 ${libdir}/opencv_ml249 ${libdir}/opencv_video249 ${libdir}/opencv_features2d249 ${libdir}/opencv_calib3d249 ${libdir}/opencv_objdetect249 ${libdir}/opencv_contrib249 ${libdir}/opencv_legacy249 ${libdir}/opencv_flann249 ${libdir}/opencv_core249
+
+Libs: ${libdir}/opencv_calib3d249 ${libdir}/opencv_contrib249 ${libdir}/opencv_core249 ${libdir}/opencv_features2d249 ${libdir}/opencv_flann249 ${libdir}/opencv_gpu249 ${libdir}/opencv_highgui249 ${libdir}/opencv_imgproc249 ${libdir}/opencv_legacy249 ${libdir}/opencv_ml249 ${libdir}/opencv_nonfree249 ${libdir}/opencv_objdetect249 ${libdir}/opencv_ocl249 ${libdir}/opencv_photo249 ${libdir}/opencv_stitching249 ${libdir}/opencv_superres249 ${libdir}/opencv_ts249 ${libdir}/opencv_video249 ${libdir}/opencv_videostab249
diff --git a/utils/opencv_x86.pc b/utils/opencv_x86.pc
index 7b993fc..14026a1 100644
--- a/utils/opencv_x86.pc
+++ b/utils/opencv_x86.pc
@@ -9,4 +9,4 @@ Description: Open Source Computer Vision Library
 Version: 2.4.9
 
 Cflags: ${includedir} ${includedir}/opencv
-Libs: ${libdir}/opencv_core249 ${libdir}/opencv_imgproc249 ${libdir}/opencv_highgui249 ${libdir}/opencv_ml249 ${libdir}/opencv_video249 ${libdir}/opencv_features2d249 ${libdir}/opencv_calib3d249 ${libdir}/opencv_objdetect249 ${libdir}/opencv_contrib249 ${libdir}/opencv_legacy249 ${libdir}/opencv_flann249 ${libdir}/opencv_core249
+Libs: ${libdir}/opencv_calib3d249 ${libdir}/opencv_contrib249 ${libdir}/opencv_core249 ${libdir}/opencv_features2d249 ${libdir}/opencv_flann249 ${libdir}/opencv_gpu249 ${libdir}/opencv_highgui249 ${libdir}/opencv_imgproc249 ${libdir}/opencv_legacy249 ${libdir}/opencv_ml249 ${libdir}/opencv_nonfree249 ${libdir}/opencv_objdetect249 ${libdir}/opencv_ocl249 ${libdir}/opencv_photo249 ${libdir}/opencv_stitching249 ${libdir}/opencv_superres249 ${libdir}/opencv_ts249 ${libdir}/opencv_video249 ${libdir}/opencv_videostab249

From a405869720f1575747773f189c12a20128bb8ac5 Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Thu, 5 Feb 2015 17:31:04 -0600
Subject: [PATCH 32/35] Test node-pre-gyp info for 64 bit.

---
 appveyor.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/appveyor.yml b/appveyor.yml
index 6559ec1..2f463a0 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -65,6 +65,7 @@ build_script:
   - cmd: ECHO "PUBLISH x64 binary package:"
   - cmd: npm install aws-sdk
   - cmd: IF %PUBLISH_BINARY%==true (node-pre-gyp package publish 2>&1)
+  - cmd: node-pre-gyp info
   - cmd: node-pre-gyp clean
   - cmd: node-gyp clean
   - cmd: npm uninstall -g node-gyp

From a04ba455dd00158bcd46427ac2a473bb9c03d0d9 Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Thu, 5 Feb 2015 17:48:44 -0600
Subject: [PATCH 33/35] Remove node-pre-gyp info call, since it is failing on
 windows.

---
 appveyor.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index 2f463a0..0fdf15f 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -65,7 +65,7 @@ build_script:
   - cmd: ECHO "PUBLISH x64 binary package:"
   - cmd: npm install aws-sdk
   - cmd: IF %PUBLISH_BINARY%==true (node-pre-gyp package publish 2>&1)
-  - cmd: node-pre-gyp info
+  #- cmd: node-pre-gyp info
   - cmd: node-pre-gyp clean
   - cmd: node-gyp clean
   - cmd: npm uninstall -g node-gyp
@@ -99,7 +99,7 @@ on_success:
   #- cmd: IF %PUBLISH_BINARY%==true npm install --fallback-to-build=false
   - cmd: npm install --fallback-to-build=false
   # Print Available Binaries
-  - cmd: node-pre-gyp info
+  #- cmd: node-pre-gyp info
 
 test: OFF
 

From 055c7a24052633b259d77bdfefda61911fc0b526 Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Thu, 5 Feb 2015 18:31:13 -0600
Subject: [PATCH 34/35] Bring back node-pre-gyp info to investigate why branch
 passes but not master.

---
 appveyor.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index 0fdf15f..6559ec1 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -65,7 +65,6 @@ build_script:
   - cmd: ECHO "PUBLISH x64 binary package:"
   - cmd: npm install aws-sdk
   - cmd: IF %PUBLISH_BINARY%==true (node-pre-gyp package publish 2>&1)
-  #- cmd: node-pre-gyp info
   - cmd: node-pre-gyp clean
   - cmd: node-gyp clean
   - cmd: npm uninstall -g node-gyp
@@ -99,7 +98,7 @@ on_success:
   #- cmd: IF %PUBLISH_BINARY%==true npm install --fallback-to-build=false
   - cmd: npm install --fallback-to-build=false
   # Print Available Binaries
-  #- cmd: node-pre-gyp info
+  - cmd: node-pre-gyp info
 
 test: OFF
 

From 44695e0c61cb70af9fe10e3aadfec62f96871211 Mon Sep 17 00:00:00 2001
From: edgarsilva <edgar.osc@gmail.com>
Date: Fri, 6 Feb 2015 11:26:46 -0600
Subject: [PATCH 35/35] Test install from pre compiled binaries

---
 appveyor.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index 6559ec1..257ed74 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -59,7 +59,8 @@ before_build:
 # to run your custom scripts instead of automatic MSBuild
 build_script:
   - cmd: ECHO "BUILDING x64 binary package:"
-  - cmd: npm install --build-from-source --msvs_version=2013
+  #- cmd: npm install --build-from-source --msvs_version=2013
+  - cmd: npm install --msvs_version=2013
   - cmd: npm test
   - cmd: node lib/opencv.js
   - cmd: ECHO "PUBLISH x64 binary package:"
@@ -81,7 +82,8 @@ after_build:
   - cmd: npm install -g node-gyp
   - cmd: copy .\utils\opencv_x86.pc C:\GTK\lib\pkgconfig\opencv.pc
   - cmd: ECHO "BUILDING x86 binary package:"
-  - cmd: npm install --build-from-source --msvs_version=2013
+  #- cmd: npm install --build-from-source --msvs_version=2013
+  - cmd: npm install --msvs_version=2013
   - cmd: npm test
   - cmd: node lib/opencv.js
   - cmd: ECHO "PUBLISH x86 binary package:"