diff --git a/binding.gyp b/binding.gyp index ef75193..6318322 100755 --- a/binding.gyp +++ b/binding.gyp @@ -15,13 +15,13 @@ "src/BackgroundSubtractor.cc", "src/Constants.cc", "src/Calib3D.cc", - "src/ImgProc.cc" + "src/ImgProc.cc", + "src/Stereo.cc" ], "libraries": [ " matrixFromMat(cv::Mat &input) +{ + Local matrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *matrix = ObjectWrap::Unwrap(matrixWrap); + matrix->mat = input; + + return matrixWrap; +} + +inline cv::Mat matFromMatrix(Handle matrix) +{ + Matrix* m = ObjectWrap::Unwrap(matrix->ToObject()); + return m->mat; +} + +inline cv::Size sizeFromArray(Handle jsArray) +{ + cv::Size patternSize; + + if (jsArray->IsArray()) + { + Local v8sz = jsArray->ToObject(); + + patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue()); + } + else + { + JSTHROW_TYPE("Size is not a valid array"); + } + + return patternSize; +} + +inline std::vector points2fFromArray(Handle array) +{ + std::vector points; + if(array->IsArray()) + { + Local pointsArray = Local::Cast(array->ToObject()); + + for(unsigned int i = 0; i < pointsArray->Length(); i++) + { + Local pt = pointsArray->Get(i)->ToObject(); + points.push_back(cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), + pt->Get(NanNew("y"))->ToNumber()->Value())); + } + } + else + { + JSTHROW_TYPE("Points not a valid array"); + } + + return points; +} + +inline std::vector points3fFromArray(Handle array) +{ + std::vector points; + if(array->IsArray()) { + Local pointsArray = Local::Cast(array->ToObject()); + + for(unsigned int i = 0; i < pointsArray->Length(); i++) + { + Local pt = pointsArray->Get(i)->ToObject(); + points.push_back(cv::Point3f(pt->Get(NanNew("x"))->ToNumber()->Value(), + pt->Get(NanNew("y"))->ToNumber()->Value(), + pt->Get(NanNew("z"))->ToNumber()->Value())); + } + } + else + { + JSTHROW_TYPE("Must pass array of object points for each frame") + } + + return points; +} + +inline std::vector > points2fFromArrayOfArrays(Handle array) +{ + std::vector > points; + if(array->IsArray()) + { + Local pointsArray = Local::Cast(array->ToObject()); + + for(unsigned int i = 0; i < pointsArray->Length(); i++) + { + points.push_back(points2fFromArray(pointsArray->Get(i))); + } + } + else + { + JSTHROW_TYPE("Must pass array of object points for each frame") + } + + return points; +} + +inline std::vector > points3fFromArrayOfArrays(Handle array) +{ + std::vector > points; + if(array->IsArray()) + { + Local pointsArray = Local::Cast(array->ToObject()); + + for(unsigned int i = 0; i < pointsArray->Length(); i++) + { + points.push_back(points3fFromArray(pointsArray->Get(i))); + } + } + else + { + JSTHROW_TYPE("Must pass array of object points for each frame") + } + + return points; +} + void Calib3D::Init(Handle target) { Persistent inner; @@ -12,6 +129,10 @@ void Calib3D::Init(Handle target) NODE_SET_METHOD(obj, "calibrateCamera", CalibrateCamera); NODE_SET_METHOD(obj, "solvePnP", SolvePnP); NODE_SET_METHOD(obj, "getOptimalNewCameraMatrix", GetOptimalNewCameraMatrix); + NODE_SET_METHOD(obj, "stereoCalibrate", StereoCalibrate); + NODE_SET_METHOD(obj, "stereoRectify", StereoRectify); + NODE_SET_METHOD(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines); + NODE_SET_METHOD(obj, "reprojectImageTo3d", ReprojectImageTo3D); target->Set(NanNew("calib3d"), obj); } @@ -25,18 +146,10 @@ NAN_METHOD(Calib3D::FindChessboardCorners) // Get the arguments from javascript // Arg 0 is the image - Matrix* m = ObjectWrap::Unwrap(args[0]->ToObject()); - cv::Mat mat = m->mat; + cv::Mat mat = matFromMatrix(args[0]); // Arg 1 is the pattern size - cv::Size patternSize; - if (args[1]->IsArray()) { - Local v8sz = args[1]->ToObject(); - - patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue()); - } else { - JSTHROW_TYPE("Must pass pattern size"); - } + cv::Size patternSize = sizeFromArray(args[1]); // Arg 2 would normally be the flags, ignoring this for now and using the default flags @@ -80,33 +193,13 @@ NAN_METHOD(Calib3D::DrawChessboardCorners) // Get the arguments // Arg 0 is the image - Matrix* m = ObjectWrap::Unwrap(args[0]->ToObject()); - cv::Mat mat = m->mat; + cv::Mat mat = matFromMatrix(args[0]); // Arg 1 is the pattern size - cv::Size patternSize; - if (args[1]->IsArray()) { - Local v8sz = args[1]->ToObject(); - - patternSize = cv::Size(v8sz->Get(0)->IntegerValue(), v8sz->Get(1)->IntegerValue()); - } else { - JSTHROW_TYPE("Must pass pattern size"); - } + cv::Size patternSize = sizeFromArray(args[1]); // Arg 2 is the corners array - std::vector corners; - if(args[2]->IsArray()) { - Local cornersArray = Local::Cast(args[2]); - - for(unsigned int i = 0; i < cornersArray->Length(); i++) - { - Local pt = cornersArray->Get(i)->ToObject(); - corners.push_back(cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value())); - } - } else { - JSTHROW_TYPE("Must pass corners array"); - } + std::vector corners = points2fFromArray(args[2]); // Arg 3, pattern found boolean bool patternWasFound = args[3]->ToBoolean()->Value(); @@ -133,61 +226,13 @@ NAN_METHOD(Calib3D::CalibrateCamera) // Get the arguments // Arg 0, the array of object points, an array of arrays - std::vector > objectPoints; - if(args[0]->IsArray()) { - Local objectPointsArray = Local::Cast(args[0]); + std::vector > objectPoints = points3fFromArrayOfArrays(args[0]); - for(unsigned int i = 0; i < objectPointsArray->Length(); i++) - { - std::vector points; - - Local pointsArray = Local::Cast(objectPointsArray->Get(i)); - for(unsigned int j = 0; j < pointsArray->Length(); j++) - { - Local pt = pointsArray->Get(j)->ToObject(); - points.push_back(cv::Point3f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value(), - pt->Get(NanNew("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 > imagePoints; - if(args[1]->IsArray()) { - Local imagePointsArray = Local::Cast(args[1]); - - for(unsigned int i = 0; i < imagePointsArray->Length(); i++) - { - std::vector points; - - Local pointsArray = Local::Cast(imagePointsArray->Get(i)); - for(unsigned int j = 0; j < pointsArray->Length(); j++) - { - Local pt = pointsArray->Get(j)->ToObject(); - points.push_back(cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value())); - } - - imagePoints.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 > imagePoints = points2fFromArrayOfArrays(args[1]); // Arg 2, the image size - cv::Size imageSize; - if (args[2]->IsArray()) { - Local v8sz = args[2]->ToObject(); - - imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); - } else { - JSTHROW_TYPE("Must pass pattern size"); - } + cv::Size imageSize = sizeFromArray(args[2]); // Arg 3, 4, input guesses for the camrea matrix and distortion coefficients, skipping for now cv::Mat K, dist; @@ -206,17 +251,11 @@ NAN_METHOD(Calib3D::CalibrateCamera) ret->Set(NanNew("reprojectionError"), NanNew(error)); // K - Local KMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *KMatrix = ObjectWrap::Unwrap(KMatrixWrap); - KMatrix->mat = K; - + Local KMatrixWrap = matrixFromMat(K); ret->Set(NanNew("K"), KMatrixWrap); // dist - Local distMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *distMatrix = ObjectWrap::Unwrap(distMatrixWrap); - distMatrix->mat = dist; - + Local distMatrixWrap = matrixFromMat(dist); ret->Set(NanNew("distortion"), distMatrixWrap); // Per frame R and t, skiping for now @@ -240,43 +279,16 @@ NAN_METHOD(Calib3D::SolvePnP) // Get the arguments // Arg 0, the array of object points - std::vector objectPoints; - if(args[0]->IsArray()) { - Local objectPointsArray = Local::Cast(args[0]); - - for(unsigned int i = 0; i < objectPointsArray->Length(); i++) - { - Local pt = objectPointsArray->Get(i)->ToObject(); - objectPoints.push_back(cv::Point3f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value(), - pt->Get(NanNew("z"))->ToNumber()->Value())); - } - } else { - JSTHROW_TYPE("Must pass array of object points for each frame") - } + std::vector objectPoints = points3fFromArray(args[0]); // Arg 1, the image points - std::vector imagePoints; - if(args[1]->IsArray()) { - Local imagePointsArray = Local::Cast(args[1]); - - for(unsigned int i = 0; i < imagePointsArray->Length(); i++) - { - Local pt = imagePointsArray->Get(i)->ToObject(); - imagePoints.push_back(cv::Point2f(pt->Get(NanNew("x"))->ToNumber()->Value(), - pt->Get(NanNew("y"))->ToNumber()->Value())); - } - } else { - JSTHROW_TYPE("Must pass array of object points for each frame") - } + std::vector imagePoints = points2fFromArray(args[1]); // Arg 2, the camera matrix - Matrix* kWrap = ObjectWrap::Unwrap(args[2]->ToObject()); - cv::Mat K = kWrap->mat; + cv::Mat K = matFromMatrix(args[2]); // Arg 3, the distortion coefficients - Matrix* distWrap = ObjectWrap::Unwrap(args[3]->ToObject()); - cv::Mat dist = distWrap->mat; + cv::Mat dist = matFromMatrix(args[3]); // Arg 4, use extrinsic guess, skipped for now @@ -291,17 +303,11 @@ NAN_METHOD(Calib3D::SolvePnP) Local ret = NanNew(); // rvec - Local rMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *rMatrix = ObjectWrap::Unwrap(rMatrixWrap); - rMatrix->mat = rvec; - + Local rMatrixWrap = matrixFromMat(rvec); ret->Set(NanNew("rvec"), rMatrixWrap); // tvec - Local tMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *tMatrix = ObjectWrap::Unwrap(tMatrixWrap); - tMatrix->mat = tvec; - + Local tMatrixWrap = matrixFromMat(tvec); ret->Set(NanNew("tvec"), tMatrixWrap); // Return @@ -314,7 +320,7 @@ NAN_METHOD(Calib3D::SolvePnP) } } -// cv::solvePnP +// cv::getOptimalNewCameraMAtrix NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) { NanEscapableScope(); @@ -323,35 +329,19 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) // Get the arguments // Arg 0 is the original camera matrix - Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); - cv::Mat Kin = m0->mat; + cv::Mat Kin = matFromMatrix(args[0]); // Arg 1 is the distortion coefficients - Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); - cv::Mat dist = m1->mat; + cv::Mat dist = matFromMatrix(args[1]); // Arg 2, the image size - cv::Size imageSize; - if (args[2]->IsArray()) { - Local v8sz = args[2]->ToObject(); - - imageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); - } else { - JSTHROW_TYPE("Must pass original image size"); - } + cv::Size imageSize = sizeFromArray(args[2]); // 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 v8sz = args[4]->ToObject(); - - newImageSize = cv::Size(v8sz->Get(1)->IntegerValue(), v8sz->Get(0)->IntegerValue()); - } else { - JSTHROW_TYPE("Must pass new image size"); - } + cv::Size newImageSize = sizeFromArray(args[4]); // Arg 5, valid ROI, skip for now // Arg 6, center principal point, skip for now @@ -360,9 +350,7 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) cv::Mat Kout = cv::getOptimalNewCameraMatrix(Kin, dist, imageSize, alpha, newImageSize); // Wrap the output K - Local KMatrixWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); - Matrix *KMatrix = ObjectWrap::Unwrap(KMatrixWrap); - KMatrix->mat = Kout; + Local KMatrixWrap = matrixFromMat(Kout); // Return the new K matrix NanReturnValue(KMatrixWrap); @@ -373,3 +361,229 @@ NAN_METHOD(Calib3D::GetOptimalNewCameraMatrix) NanReturnUndefined(); } } + +// cv::stereoCalibrate +NAN_METHOD(Calib3D::StereoCalibrate) +{ + NanEscapableScope(); + + try { + // Get the arguments + + // Arg 0, the array of object points, an array of arrays + std::vector > objectPoints = points3fFromArrayOfArrays(args[0]); + + // Arg 1, the image points1, another array of arrays + std::vector > imagePoints1 = points2fFromArrayOfArrays(args[1]); + + // Arg 2, the image points2, another array of arrays =( + std::vector > imagePoints2 = points2fFromArrayOfArrays(args[2]); + + // Arg 3 is the image size (follows the PYTHON api not the C++ api since all following arguments are optional or outputs) + cv::Size imageSize = sizeFromArray(args[3]); + + // Arg 4,5,6,7 is the camera matrix and distortion coefficients (optional but must pass all 4 or none) + cv::Mat k1, d1, k2, d2; + if(args.Length() >= 8) + { + k1 = matFromMatrix(args[4]); + d1 = matFromMatrix(args[5]); + + k2 = matFromMatrix(args[6]); + d2 = matFromMatrix(args[7]); + } + + // Last argument is flags, skipping for now + + // Output mats + cv::Mat R, t, E, F; + + // Do the stereo calibration + cv::stereoCalibrate(objectPoints, imagePoints1, imagePoints2, k1, d1, k2, d2, imageSize, R, t, E, F); + + // make the return value + Local ret = NanNew(); + + // Make the output arguments + + // k1 + Local K1MatrixWrap = matrixFromMat(k1); + + // d1 + Local d1MatrixWrap = matrixFromMat(d1); + + // k2 + Local K2MatrixWrap = matrixFromMat(k2); + + // d2 + Local d2MatrixWrap = matrixFromMat(d2); + + // R + Local RMatrixWrap = matrixFromMat(R); + + // t + Local tMatrixWrap = matrixFromMat(t); + + // E + Local EMatrixWrap = matrixFromMat(E); + + // F + Local FMatrixWrap = matrixFromMat(F); + + // Add to return object + ret->Set(NanNew("K1"), K1MatrixWrap); + ret->Set(NanNew("distortion1"), d1MatrixWrap); + ret->Set(NanNew("K2"), K2MatrixWrap); + ret->Set(NanNew("distortion2"), d2MatrixWrap); + ret->Set(NanNew("R"), RMatrixWrap); + ret->Set(NanNew("t"), tMatrixWrap); + ret->Set(NanNew("E"), EMatrixWrap); + ret->Set(NanNew("F"), FMatrixWrap); + + // Return + NanReturnValue(ret); + + } catch (cv::Exception &e) { + const char *err_msg = e.what(); + NanThrowError(err_msg); + NanReturnUndefined(); + } +} + +// cv::stereoRectify +NAN_METHOD(Calib3D::StereoRectify) +{ + NanEscapableScope(); + + try { + // Get the arguments + + // Arg0, the first camera matrix + cv::Mat K1 = matFromMatrix(args[0]); + + // Arg1, the first distortion coefficients + cv::Mat d1 = matFromMatrix(args[1]); + + // Arg2, the second camera matrix + cv::Mat K2 = matFromMatrix(args[2]); + + // Arg3, the second distortion coefficients + cv::Mat d2 = matFromMatrix(args[3]); + + // Arg4, the image size + cv::Size imageSize = sizeFromArray(args[4]); + + // arg5, the intercamera rotation matrix + cv::Mat R = matFromMatrix(args[5]); + + // Arg6, the intercamera translation vector + cv::Mat t = matFromMatrix(args[6]); + + // Arg8, flags, skipping for now + + // Arg9, freescaling paremeter, skipping for now + + // Arg10, new image size, skipping for now to fix at original image size + + // Make output matrics + cv::Mat R1, R2, P1, P2, Q; + + // Do the stereo rectification + cv::stereoRectify(K1, d1, K2, d2, imageSize, R, t, R1, R2, P1, P2, Q); + + // Make the return object + Local ret = NanNew(); + + ret->Set(NanNew("R1"), matrixFromMat(R1)); + ret->Set(NanNew("R2"), matrixFromMat(R2)); + ret->Set(NanNew("P1"), matrixFromMat(P1)); + ret->Set(NanNew("P2"), matrixFromMat(P2)); + ret->Set(NanNew("Q"), matrixFromMat(Q)); + + // Return the recification parameters + NanReturnValue(ret); + + } catch (cv::Exception &e) { + const char *err_msg = e.what(); + NanThrowError(err_msg); + NanReturnUndefined(); + } +} + +// cv::computeCorrespondEpilines +NAN_METHOD(Calib3D::ComputeCorrespondEpilines) +{ + NanEscapableScope(); + + try { + // Get the arguments + + // Arg0, the image points + std::vector points = points2fFromArray(args[0]); + + // Arg1, the image index (1 or 2) + int whichImage = int(args[1]->ToNumber()->Value()); + + // Arg2, the fundamental matrix + cv::Mat F = matFromMatrix(args[2]); + + // compute the lines + std::vector lines; + cv::computeCorrespondEpilines(points, whichImage, F, lines); + + // Convert the lines to an array of objects (ax + by + c = 0) + Local linesArray = NanNew(lines.size()); + for(unsigned int i = 0; i < lines.size(); i++) + { + Local line_data = NanNew(); + line_data->Set(NanNew("a"), NanNew(lines[i][0])); + line_data->Set(NanNew("b"), NanNew(lines[i][1])); + line_data->Set(NanNew("c"), NanNew(lines[i][2])); + + linesArray->Set(NanNew(i), line_data); + } + + // Return the lines + NanReturnValue(linesArray); + + } catch (cv::Exception &e) { + const char *err_msg = e.what(); + NanThrowError(err_msg); + NanReturnUndefined(); + } +} + +// cv::reprojectImageTo3D +NAN_METHOD(Calib3D::ReprojectImageTo3D) +{ + NanEscapableScope(); + + try { + // Get the arguments + + // Arg0, the disparity image + cv::Mat disparity = matFromMatrix(args[0]); + + // Arg1, the depth-to-disparity transformation Q + cv::Mat Q = matFromMatrix(args[1]); + + // Arg 2, handle missing values, skipped for now + + // Arg3, output bit depth, skipped for now + + // Compute the depth image + cv::Mat depthImage; + cv::reprojectImageTo3D(disparity, depthImage, Q); + + // Wrap the depth image + Local depthImageMatrix = matrixFromMat(depthImage); + + NanReturnValue(depthImageMatrix); + + + } 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 ab5669e..4f06505 100644 --- a/src/Calib3D.h +++ b/src/Calib3D.h @@ -18,6 +18,14 @@ public: static NAN_METHOD(SolvePnP); static NAN_METHOD(GetOptimalNewCameraMatrix); + + static NAN_METHOD(StereoCalibrate); + + static NAN_METHOD(StereoRectify); + + static NAN_METHOD(ComputeCorrespondEpilines); + + static NAN_METHOD(ReprojectImageTo3D); }; #endif diff --git a/src/Stereo.cc b/src/Stereo.cc new file mode 100644 index 0000000..54da7af --- /dev/null +++ b/src/Stereo.cc @@ -0,0 +1,323 @@ +#include "Stereo.h" +#include "Matrix.h" +#include + +// Block matching + +v8::Persistent StereoBM::constructor; + +void +StereoBM::Init(Handle target) { + NanScope(); + + Local ctor = NanNew(StereoBM::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("StereoBM")); + + NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); + + ctor->Set(NanNew("BASIC_PRESET"), NanNew((int)cv::StereoBM::BASIC_PRESET)); + ctor->Set(NanNew("FISH_EYE_PRESET"), NanNew((int)cv::StereoBM::FISH_EYE_PRESET)); + ctor->Set(NanNew("NARROW_PRESET"), NanNew((int)cv::StereoBM::NARROW_PRESET)); + + target->Set(NanNew("StereoBM"), ctor->GetFunction()); +} + +NAN_METHOD(StereoBM::New) { + NanScope(); + + if (args.This()->InternalFieldCount() == 0) + NanThrowTypeError("Cannot instantiate without new"); + + StereoBM *stereo; + + if (args.Length() == 0) + { + stereo = new StereoBM(); + } + else if (args.Length() == 1) + { + stereo = new StereoBM(args[0]->IntegerValue()); // preset + } + else if (args.Length() == 2) + { + stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue()); // preset, disparity search range + } + else + { + stereo = new StereoBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue()); // preset, disparity search range, sum of absolute differences window size + } + + stereo->Wrap(args.Holder()); + NanReturnValue(args.Holder()); +} + +StereoBM::StereoBM(int preset, int ndisparities, int SADWindowSize) + : ObjectWrap(), stereo(preset, ndisparities, SADWindowSize) +{ + +} + +// TODO make this async +NAN_METHOD(StereoBM::Compute) +{ + SETUP_FUNCTION(StereoBM) + + try { + // Get the arguments + + // Arg 0, the 'left' image + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + cv::Mat left = m0->mat; + + // Arg 1, the 'right' image + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + cv::Mat right = m1->mat; + + // Optional 3rd arg, the disparty depth + int type = CV_16S; + if(args.Length() > 2) + { + type = args[2]->IntegerValue(); + } + + // Compute stereo using the block matching algorithm + cv::Mat disparity; + self->stereo(left, right, disparity, type); + + // Wrap the returned disparity map + Local disparityWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + disp->mat = disparity; + + NanReturnValue(disparityWrap); + + } catch (cv::Exception &e) { + const char *err_msg = e.what(); + NanThrowError(err_msg); + NanReturnUndefined(); + } + +}; + +// Semi-Global Block matching + +v8::Persistent StereoSGBM::constructor; + +void +StereoSGBM::Init(Handle target) { + NanScope(); + + Local ctor = NanNew(StereoSGBM::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("StereoSGBM")); + + NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); + + target->Set(NanNew("StereoSGBM"), ctor->GetFunction()); +} + +NAN_METHOD(StereoSGBM::New) { + NanScope(); + + if (args.This()->InternalFieldCount() == 0) + NanThrowTypeError("Cannot instantiate without new"); + + StereoSGBM *stereo; + + if (args.Length() == 0) + { + stereo = new StereoSGBM(); + } + else + { + // If passing arguments, must pass the first 3 at least + if (args.Length() >= 3) + { + switch (args.Length()) + { + case 3: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue()); + break; + + case 4: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue()); + break; + + case 5: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue()); + break; + + case 6: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), args[5]->IntegerValue()); + break; + + case 7: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue()); + break; + + case 8: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue()); + break; + + case 9: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(), args[8]->IntegerValue()); + break; + + case 10: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(), args[8]->IntegerValue(), args[9]->IntegerValue()); + break; + + default: + stereo = new StereoSGBM(args[0]->IntegerValue(), args[1]->IntegerValue(), args[2]->IntegerValue(), args[3]->IntegerValue(), args[4]->IntegerValue(), args[5]->IntegerValue(), args[6]->IntegerValue(), args[7]->IntegerValue(), args[8]->IntegerValue(), args[9]->IntegerValue(), args[10]->ToBoolean()->Value()); + break; + } + } + else + { + NanThrowError("If overriding default settings, must pass minDisparity, numDisparities, and SADWindowSize"); + NanReturnUndefined(); + } + } + + stereo->Wrap(args.Holder()); + NanReturnValue(args.Holder()); +} + +StereoSGBM::StereoSGBM() + : ObjectWrap(), stereo() +{ + +} + +StereoSGBM::StereoSGBM(int minDisparity, int ndisparities, int SADWindowSize, int p1, int p2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, bool fullDP) + : ObjectWrap(), stereo(minDisparity, ndisparities, SADWindowSize, p1, p2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, fullDP) +{ + +} + +// TODO make this async +NAN_METHOD(StereoSGBM::Compute) +{ + SETUP_FUNCTION(StereoSGBM) + + try { + // Get the arguments + + // Arg 0, the 'left' image + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + cv::Mat left = m0->mat; + + // Arg 1, the 'right' image + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + cv::Mat right = m1->mat; + + // Compute stereo using the block matching algorithm + cv::Mat disparity; + self->stereo(left, right, disparity); + + // Wrap the returned disparity map + Local disparityWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + disp->mat = disparity; + + NanReturnValue(disparityWrap); + + } catch (cv::Exception &e) { + const char *err_msg = e.what(); + NanThrowError(err_msg); + NanReturnUndefined(); + } + +}; + +// Graph cut + +v8::Persistent StereoGC::constructor; + +void +StereoGC::Init(Handle target) { + NanScope(); + + Local ctor = NanNew(StereoGC::New); + NanAssignPersistent(constructor, ctor); + ctor->InstanceTemplate()->SetInternalFieldCount(1); + ctor->SetClassName(NanNew("StereoGC")); + + NODE_SET_PROTOTYPE_METHOD(ctor, "compute", Compute); + + target->Set(NanNew("StereoGC"), ctor->GetFunction()); +} + +NAN_METHOD(StereoGC::New) { + NanScope(); + + if (args.This()->InternalFieldCount() == 0) + NanThrowTypeError("Cannot instantiate without new"); + + StereoGC *stereo; + + if (args.Length() == 0) + { + stereo = new StereoGC(); + } + else if (args.Length() == 1) + { + stereo = new StereoGC(args[0]->IntegerValue()); // numberOfDisparities + } + else + { + stereo = new StereoGC(args[0]->IntegerValue(), args[1]->IntegerValue()); // max iterations + } + + stereo->Wrap(args.Holder()); + NanReturnValue(args.Holder()); +} + +StereoGC::StereoGC(int numberOfDisparities, int maxIters) +: ObjectWrap() +{ + stereo = cvCreateStereoGCState(numberOfDisparities, maxIters); +} + +// TODO make this async +NAN_METHOD(StereoGC::Compute) +{ + SETUP_FUNCTION(StereoGC) + + try { + // Get the arguments + + // Arg 0, the 'left' image + Matrix* m0 = ObjectWrap::Unwrap(args[0]->ToObject()); + cv::Mat left = m0->mat; + + // Arg 1, the 'right' image + Matrix* m1 = ObjectWrap::Unwrap(args[1]->ToObject()); + cv::Mat right = m1->mat; + + // Compute stereo using the block matching algorithm + CvMat left_leg = left, right_leg = right; + CvMat *disp_left = cvCreateMat(left.rows, left.cols, CV_16S), *disp_right = cvCreateMat(right.rows, right.cols, CV_16S); + cvFindStereoCorrespondenceGC(&left_leg, &right_leg, disp_left, disp_right, self->stereo, 0); + + cv::Mat disp16 = disp_left; + cv::Mat disparity(disp16.rows, disp16.cols, CV_8U); + disp16.convertTo(disparity, CV_8U, -16); + + // Wrap the returned disparity map + Local disparityWrap = NanNew(Matrix::constructor)->GetFunction()->NewInstance(); + Matrix *disp = ObjectWrap::Unwrap(disparityWrap); + disp->mat = disparity; + + NanReturnValue(disparityWrap); + + } catch (cv::Exception &e) { + const char *err_msg = e.what(); + NanThrowError(err_msg); + NanReturnUndefined(); + } + +}; diff --git a/src/Stereo.h b/src/Stereo.h new file mode 100644 index 0000000..569a6d6 --- /dev/null +++ b/src/Stereo.h @@ -0,0 +1,58 @@ +#ifndef __NODE_STEREO_H +#define __NODE_STEREO_H + +#include "OpenCV.h" + +class StereoBM: public node::ObjectWrap { +public: + cv::StereoBM stereo; + + static Persistent constructor; + static void Init(Handle target); + static NAN_METHOD(New); + + StereoBM(int preset = cv::StereoBM::BASIC_PRESET, int ndisparities = 0, int SADWindowSize=21); + + JSFUNC(Compute); +}; + +class StereoSGBM: public node::ObjectWrap { +public: + cv::StereoSGBM stereo; + + static Persistent constructor; + static void Init(Handle target); + static NAN_METHOD(New); + + StereoSGBM(); + StereoSGBM(int minDisparity, + int ndisparities, + int SADWindowSize, + int p1 = 0, + int p2 = 0, + int disp12MaxDiff = 0, + int preFilterCap = 0, + int uniquenessRatio = 0, + int speckleWindowSize = 0, + int speckleRange = 0, + bool fullDP = false); + + JSFUNC(Compute); +}; + +struct CvStereoGCState; + +class StereoGC: public node::ObjectWrap { +public: + CvStereoGCState *stereo; + + static Persistent constructor; + static void Init(Handle target); + static NAN_METHOD(New); + + StereoGC(int numberOfDisparities = 16, int maxIterations = 2); + + JSFUNC(Compute); +}; + +#endif diff --git a/src/init.cc b/src/init.cc index 95eef1a..a107061 100755 --- a/src/init.cc +++ b/src/init.cc @@ -11,6 +11,7 @@ #include "Constants.h" #include "Calib3D.h" #include "ImgProc.h" +#include "Stereo.h" extern "C" void init(Handle target) { @@ -27,6 +28,9 @@ init(Handle target) { Constants::Init(target); Calib3D::Init(target); ImgProc::Init(target); + StereoBM::Init(target); + StereoSGBM::Init(target); + StereoGC::Init(target); #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >=4