archive-gh-me/node-opencv
1
0
Fork 0
mirror of https://github.com/peterbraden/node-opencv.git synced 2025-12-08 19:45:55 +00:00
Code Issues Projects Releases Wiki Activity

Fix merge issue with main repo master

Browse Source
This commit is contained in:
edgarsilva 2015-02-04 12:05:48 -06:00
commit 9035d9b0fb
12 changed files with 689 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
README.md
View File

@ -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);
```

2
package.json
View File

@ -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": {

375
src/Calib3D.cc Normal file
View File

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

23
src/Calib3D.h Normal file
View File

@ -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

9
src/Constants.cc
View File

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

169
src/ImgProc.cc Normal file
View File

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

19
src/ImgProc.h Normal file
View File

@ -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

84
src/Matrix.cc
View File

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

1
src/Matrix.h
View File

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

21
src/OpenCV.cc
View File

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

1
src/OpenCV.h
View File

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

9
src/init.cc
View File

@ -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