Merge pull request #10 from hybridgroup/custom-os-cflags

Custom os cflags, fixes pre compiled binaries

.travis.yml

@@ -14,6 +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 apt-get install libcv-dev
   - sudo apt-get install libopencv-dev
   - sudo apt-get install libhighgui-dev

README.md

@@ -172,29 +172,29 @@ 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) {
     var point = contours.point(c, i);
-    console.log("(" + point.x + "," + point.y + ")");"
+    console.log("(" + point.x + "," + point.y + ")");
   }
 }
 
-# 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);
 ```

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
@@ -57,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:"
@@ -79,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:"

binding.gyp

@@ -1,72 +1,80 @@
 {
   "targets": [{
-      "target_name": "opencv"
+    "target_name": "opencv",
-      , "sources": [
+      "sources": [
-          "src/init.cc"
+        "src/init.cc",
-        , "src/Matrix.cc"
+        "src/Matrix.cc",
-        , "src/OpenCV.cc"
+        "src/OpenCV.cc",
-        , "src/CascadeClassifierWrap.cc"
+        "src/CascadeClassifierWrap.cc",
-        , "src/Contours.cc"
+        "src/Contours.cc",
-        , "src/Point.cc"
+        "src/Point.cc",
-        , "src/VideoCaptureWrap.cc"
+        "src/VideoCaptureWrap.cc",
-        , "src/CamShift.cc"
+        "src/CamShift.cc",
-        , "src/HighGUI.cc"
+        "src/HighGUI.cc",
-        , "src/FaceRecognizer.cc"
+        "src/FaceRecognizer.cc",
-        , "src/BackgroundSubtractor.cc"
+        "src/BackgroundSubtractor.cc",
-        , "src/Constants.cc"
+        "src/Constants.cc",
-        ]
+        "src/Calib3D.cc",
-      , 'libraries': [
+        "src/ImgProc.cc"
-          '<!@(pkg-config --libs opencv)'
+      ],
-        ]
+
+      "libraries": [
+        "<!@(pkg-config --libs opencv)"
+      ],
 
       # For windows
-      ,'include_dirs': [
-          '<!@(pkg-config --cflags opencv)',
-          "<!(node -e \"require('nan')\")"
-          ]
 
-      , 'cflags': [
+      "include_dirs": [
-            '<!@(pkg-config --cflags "opencv >= 2.4.9" )'
+        "<!@(pkg-config --cflags opencv)",
-            , '-Wall'
+        "<!(node -e \"require('nan')\")"
-          ]
+      ],
-      , 'cflags!' : [ '-fno-exceptions']
+
-      , 'cflags_cc!': [ '-fno-rtti',  '-fno-exceptions']
+      "cflags!" : [ "-fno-exceptions"],
-      , "conditions": [
+      "cflags_cc!": [ "-fno-rtti",  "-fno-exceptions"],
-        ['OS=="win"',
+
-          {
+      "conditions": [
-            'msvs_settings': {
+        [ "OS==\"linux\"", {
-              'VCCLCompilerTool': {
+            "cflags": [
-                'ExceptionHandling': '2',
+              "<!@(pkg-config --cflags \"opencv >= 2.3.1\" )",
-                'DisableSpecificWarnings': [ '4530', '4506', '4244' ],
+              "-Wall"
-              },
-            },
-          },
-        ],
-        ['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)'
             ]
-            , "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",
+      "target_name": "action_after_build",
-    "type": "none",
+      "type": "none",
-    "dependencies": [ "<(module_name)" ],
+      "dependencies": [ "<(module_name)" ],
-    "copies": [
+      "copies": [
       {
         "files": [ "<(PRODUCT_DIR)/<(module_name).node" ],
         "destination": "<(module_path)"
       }
-    ]
+      ]
-  }]
+    }]
 }

package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "node-pre-gyp": "0.5.31",
     "buffers": "0.1.1",
-    "nan": "^1.3.0"
+    "nan": "1.4.3"
   },
   "version": "1.0.0",
   "devDependencies": {

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');
-})
+});

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 history = 200;
-  int nmixtures = 5;
+  // int nmixtures = 5;
-  double backgroundRatio = 0.7;
+  // double backgroundRatio = 0.7;
-  double noiseSigma = 0;
+  // double noiseSigma = 0;
-
+  //
-  if(args.Length() > 1){
+  // if(args.Length() > 1){
-    INT_FROM_ARGS(history, 0)
+  //   INT_FROM_ARGS(history, 0)
-    INT_FROM_ARGS(nmixtures, 1)
+  //   INT_FROM_ARGS(nmixtures, 1)
-    DOUBLE_FROM_ARGS(backgroundRatio, 2)
+  //   DOUBLE_FROM_ARGS(backgroundRatio, 2)
-    DOUBLE_FROM_ARGS(noiseSigma, 3)
+  //   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
+

src/Calib3D.cc

@@ -0,0 +1,375 @@
+#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);
+    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);
+}
+
+// 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
+
+        // Find the corners
+        std::vector<cv::Point2f> corners;
+        bool found = cv::findChessboardCorners(mat, patternSize, corners);
+
+        // Make the return value
+        Local<Object> ret = NanNew<Object>();
+        ret->Set(NanNew<String>("found"), NanNew<Boolean>(found));
+
+        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(NanNew<Number>(i), point_data);
+        }
+
+        ret->Set(NanNew<String>("corners"), cornersArray);
+
+        NanReturnValue(ret);
+
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        NanReturnUndefined();
+    }
+
+};
+
+// 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();
+
+        // Draw the corners
+        cv::drawChessboardCorners(mat, patternSize, corners, patternWasFound);
+
+        // Return the passed image, now with corners drawn on it
+        NanReturnValue(args[0]);
+
+    } catch (cv::Exception &e) {
+        const char *err_msg = e.what();
+        NanThrowError(err_msg);
+        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(1)->IntegerValue(), v8sz->Get(0)->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();
+    }
+}
+
+// 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();
+    }
+}
+
+// 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(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass original image 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(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass new image 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();
+    }
+}

src/Calib3D.h

@@ -0,0 +1,23 @@
+#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);
+
+    static NAN_METHOD(DrawChessboardCorners);
+
+    static NAN_METHOD(CalibrateCamera);
+
+    static NAN_METHOD(SolvePnP);
+
+    static NAN_METHOD(GetOptimalNewCameraMatrix);
+};
+
+#endif

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

src/ImgProc.cc

@@ -0,0 +1,169 @@
+#include "ImgProc.h"
+#include "Matrix.h"
+
+void ImgProc::Init(Handle<Object> target)
+{
+    Persistent<Object> inner;
+    Local<Object> obj = NanNew<Object>();
+    NanAssignPersistent(inner, obj);
+
+    NODE_SET_METHOD(obj, "undistort", Undistort);
+    NODE_SET_METHOD(obj, "initUndistortRectifyMap", InitUndistortRectifyMap);
+    NODE_SET_METHOD(obj, "remap", Remap);
+
+    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();
+    }
+}
+
+// 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(1)->IntegerValue(), v8sz->Get(0)->IntegerValue());
+        } else {
+            JSTHROW_TYPE("Must pass image size");
+        }
+
+        // Arg 5 is the first map type, skip for now
+        int m1type = args[5]->IntegerValue();
+
+        // 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();
+    }
+}
+
+// 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();
+    }
+}

src/ImgProc.h

@@ -0,0 +1,19 @@
+#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);
+
+    static NAN_METHOD(Undistort);
+
+    static NAN_METHOD(InitUndistortRectifyMap);
+
+    static NAN_METHOD(Remap);
+};
+
+#endif

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) {
@@ -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);
@@ -68,6 +69,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);
@@ -450,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);
@@ -483,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);
 
 
@@ -1027,7 +1029,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,7 +1046,12 @@ NAN_METHOD(Matrix::BitwiseNot) {
 
     Matrix *dst = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
 
-    cv::bitwise_not(self->mat, dst->mat);
+    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);
+    }	
 
     NanReturnNull();
 }
@@ -1052,7 +1064,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 +1142,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);
 
@@ -1238,6 +1259,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);
@@ -1254,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");
@@ -1263,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();
+	result.x = point->Get(0)->IntegerValue();
-	ret.y = point->Get(1)->IntegerValue();
+	result.y = point->Get(1)->IntegerValue();
-	ret.width = size->Get(0)->IntegerValue();
+	result.width = size->Get(0)->IntegerValue();
-	ret.height = size->Get(1)->IntegerValue();
+	result.height = size->Get(1)->IntegerValue();
 
-	return (cv::Rect*) &ret;
+	return &result;
 }
 
 
@@ -1658,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 );

src/Matrix.h

@@ -74,6 +74,7 @@ class Matrix: public node::ObjectWrap {
     // Feature Detection
     JSFUNC(GoodFeaturesToTrack)
     JSFUNC(HoughLinesP)
+    JSFUNC(HoughCircles)
 
     JSFUNC(Crop)
 

src/OpenCV.cc

@@ -5,48 +5,47 @@
 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);
-
+}
-}  
 
 
 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 +73,4 @@ NAN_METHOD(OpenCV::ReadImage) {
       NanThrowError(err_msg);
       NanReturnUndefined();
   }
-};    
+};

src/OpenCV.h

@@ -55,4 +55,3 @@ class OpenCV: public node::ObjectWrap{
 
 
 #endif
-

src/init.cc

@@ -9,21 +9,24 @@
 #include "HighGUI.h"
 #include "FaceRecognizer.h"
 #include "Constants.h"
-
+#include "Calib3D.h"
+#include "ImgProc.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);
+    ImgProc::Init(target);
 
 
    #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4

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

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