mirror of
https://github.com/peterbraden/node-opencv.git
synced 2025-12-08 19:45:55 +00:00
Merge pull request #215 from Queuecumber/master
Added Camera Calibration Functions
This commit is contained in:
Peter Braden
commit
8a7a8c6f85
@ -14,6 +14,7 @@
|
||||
, "src/FaceRecognizer.cc"
|
||||
, "src/BackgroundSubtractor.cc"
|
||||
, "src/Constants.cc"
|
||||
, "src/Calib3D.cc"
|
||||
]
|
||||
, 'libraries': [
|
||||
'<!@(pkg-config --libs opencv)'
|
||||
|
||||
314
src/Calib3D.cc
Normal file
314
src/Calib3D.cc
Normal file
@ -0,0 +1,314 @@
|
||||
#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);
|
||||
|
||||
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(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();
|
||||
}
|
||||
}
|
||||
|
||||
// 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();
|
||||
}
|
||||
}
|
||||
21
src/Calib3D.h
Normal file
21
src/Calib3D.h
Normal file
@ -0,0 +1,21 @@
|
||||
#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);
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -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();
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
@ -55,4 +55,3 @@ class OpenCV: public node::ObjectWrap{
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user