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

Merge pull request #670 from guangmingwan/master

Browse Source 
fix nodejs 13+
This commit is contained in:
Peter Braden 2020-03-16 11:59:02 +01:00 committed by GitHub
commit f0a03a4be7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 381 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BackgroundSubtractor.cc
View File

@ -66,7 +66,7 @@ void BackgroundSubtractorWrap::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "noiseSigma", NoiseSigma);
Nan::SetPrototypeMethod(ctor, "backgroundRatio", BackgroundRatio);
target->Set(Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(BackgroundSubtractorWrap::New) {

66
src/Calib3D.cc
View File

@ -14,8 +14,8 @@ inline cv::Size sizeFromArray(Local<Value> jsArray) {
if (jsArray->IsArray()) {
Local<Object> v8sz = jsArray->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
patternSize = cv::Size(v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
patternSize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
} else {
JSTHROW_TYPE("Size is not a valid array");
}
@ -50,7 +50,7 @@ inline std::vector<cv::Point3f> points3fFromArray(Local<Value> array) {
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
for (unsigned int i = 0; i < pointsArray->Length(); i++) {
Local<Object> pt = pointsArray->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
Local<Object> pt = pointsArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
points.push_back(
cv::Point3f(
Nan::To<double>(Nan::Get(pt, Nan::New<String>("x").ToLocalChecked()).ToLocalChecked()).FromJust(),
@ -73,7 +73,7 @@ inline std::vector<std::vector<cv::Point2f> > points2fFromArrayOfArrays(
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
for (unsigned int i = 0; i < pointsArray->Length(); i++) {
points.push_back(points2fFromArray(pointsArray->Get(i)));
points.push_back(points2fFromArray(pointsArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()));
}
} else {
JSTHROW_TYPE("Must pass array of object points for each frame")
@ -89,7 +89,7 @@ inline std::vector<std::vector<cv::Point3f> > points3fFromArrayOfArrays(
Local<Array> pointsArray = Local<Array>::Cast(array->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
for (unsigned int i = 0; i < pointsArray->Length(); i++) {
points.push_back(points3fFromArray(pointsArray->Get(i)));
points.push_back(points3fFromArray(pointsArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()));
}
} else {
JSTHROW_TYPE("Must pass array of object points for each frame")
@ -113,7 +113,7 @@ void Calib3D::Init(Local<Object> target) {
Nan::SetMethod(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines);
Nan::SetMethod(obj, "reprojectImageTo3d", ReprojectImageTo3D);
target->Set(Nan::New("calib3d").ToLocalChecked(), obj);
target->Set(Nan::GetCurrentContext(), Nan::New("calib3d").ToLocalChecked(), obj);
}
// cv::findChessboardCorners
@ -138,18 +138,18 @@ NAN_METHOD(Calib3D::FindChessboardCorners) {
// Make the return value
Local<Object> ret = Nan::New<Object>();
ret->Set(Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found));
Local<Array> cornersArray = Nan::New<Array>(corners.size());
for (unsigned int i = 0; i < corners.size(); i++) {
Local<Object> point_data = Nan::New<Object>();
point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x));
point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y));
point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x));
point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y));
cornersArray->Set(Nan::New<Number>(i), point_data);
cornersArray->Set(Nan::GetCurrentContext(), Nan::New<Number>(i), point_data);
}
ret->Set(Nan::New<String>("corners").ToLocalChecked(), cornersArray);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("corners").ToLocalChecked(), cornersArray);
info.GetReturnValue().Set(ret);
} catch (cv::Exception &e) {
@ -225,15 +225,15 @@ NAN_METHOD(Calib3D::CalibrateCamera) {
Local<Object> ret = Nan::New<Object>();
// Reprojection error
ret->Set(Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error));
// K
Local<Object> KMatrixWrap = Matrix::CreateWrappedFromMat(K);
ret->Set(Nan::New<String>("K").ToLocalChecked(), KMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("K").ToLocalChecked(), KMatrixWrap);
// dist
Local<Object> distMatrixWrap = Matrix::CreateWrappedFromMat(dist);
ret->Set(Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap);
// Per frame R and t, skiping for now
@ -279,11 +279,11 @@ NAN_METHOD(Calib3D::SolvePnP) {
// rvec
Local<Object> rMatrixWrap = Matrix::CreateWrappedFromMat(rvec);
ret->Set(Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap);
// tvec
Local<Object> tMatrixWrap = Matrix::CreateWrappedFromMat(tvec);
ret->Set(Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap);
// Return
info.GetReturnValue().Set(ret);
@ -409,14 +409,14 @@ NAN_METHOD(Calib3D::StereoCalibrate) {
Local<Object> FMatrixWrap = Matrix::CreateWrappedFromMat(F);
// Add to return object
ret->Set(Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap);
ret->Set(Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap);
ret->Set(Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap);
ret->Set(Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap);
ret->Set(Nan::New<String>("R").ToLocalChecked(), RMatrixWrap);
ret->Set(Nan::New<String>("t").ToLocalChecked(), tMatrixWrap);
ret->Set(Nan::New<String>("E").ToLocalChecked(), EMatrixWrap);
ret->Set(Nan::New<String>("F").ToLocalChecked(), FMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("R").ToLocalChecked(), RMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("t").ToLocalChecked(), tMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("E").ToLocalChecked(), EMatrixWrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("F").ToLocalChecked(), FMatrixWrap);
// Return
info.GetReturnValue().Set(ret);
@ -470,11 +470,11 @@ NAN_METHOD(Calib3D::StereoRectify) {
// Make the return object
Local<Object> ret = Nan::New<Object>();
ret->Set(Nan::New<String>("R1").ToLocalChecked(), Matrix::CreateWrappedFromMat(R1));
ret->Set(Nan::New<String>("R2").ToLocalChecked(), Matrix::CreateWrappedFromMat(R2));
ret->Set(Nan::New<String>("P1").ToLocalChecked(), Matrix::CreateWrappedFromMat(P1));
ret->Set(Nan::New<String>("P2").ToLocalChecked(), Matrix::CreateWrappedFromMat(P2));
ret->Set(Nan::New<String>("Q").ToLocalChecked(), Matrix::CreateWrappedFromMat(Q));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("R1").ToLocalChecked(), Matrix::CreateWrappedFromMat(R1));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("R2").ToLocalChecked(), Matrix::CreateWrappedFromMat(R2));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("P1").ToLocalChecked(), Matrix::CreateWrappedFromMat(P1));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("P2").ToLocalChecked(), Matrix::CreateWrappedFromMat(P2));
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("Q").ToLocalChecked(), Matrix::CreateWrappedFromMat(Q));
// Return the rectification parameters
info.GetReturnValue().Set(ret);
@ -510,11 +510,11 @@ NAN_METHOD(Calib3D::ComputeCorrespondEpilines) {
for(unsigned int i = 0; i < lines.size(); i++)
{
Local<Object> line_data = Nan::New<Object>();
line_data->Set(Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0]));
line_data->Set(Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1]));
line_data->Set(Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2]));
line_data->Set(Nan::GetCurrentContext(), Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0]));
line_data->Set(Nan::GetCurrentContext(), Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1]));
line_data->Set(Nan::GetCurrentContext(), Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2]));
linesArray->Set(Nan::New<Number>(i), line_data);
linesArray->Set(Nan::GetCurrentContext(), Nan::New<Number>(i), line_data);
}
// Return the lines

24
src/CamShift.cc
View File

@ -33,7 +33,7 @@ void TrackedObject::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "track", Track);
target->Set(Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(TrackedObject::New) {
@ -50,10 +50,10 @@ NAN_METHOD(TrackedObject::New) {
if (info[1]->IsArray()) {
Local<Object> v8rec = info[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
r = cv::Rect(
v8rec->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8rec->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8rec->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8rec->Get(3)->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
v8rec->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8rec->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8rec->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
v8rec->Get(Nan::GetCurrentContext(),3).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
} else {
JSTHROW_TYPE("Must pass rectangle to track")
}
@ -61,8 +61,8 @@ NAN_METHOD(TrackedObject::New) {
if (info[2]->IsObject()) {
Local<Object> opts = info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
if (opts->Get(Nan::New("channel").ToLocalChecked())->IsString()) {
v8::String::Utf8Value c(v8::Isolate::GetCurrent(),opts->Get(Nan::New("channel").ToLocalChecked())->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
if (opts->Get(Nan::GetCurrentContext(),Nan::New("channel").ToLocalChecked()).ToLocalChecked()->IsString()) {
v8::String::Utf8Value c(v8::Isolate::GetCurrent(),opts->Get(Nan::GetCurrentContext(),Nan::New("channel").ToLocalChecked()).ToLocalChecked()->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
std::string cc = std::string(*c);
if (cc == "hue" || cc == "h") {
@ -166,17 +166,17 @@ NAN_METHOD(TrackedObject::Track) {
v8::Local<v8::Array> arr = Nan::New<Array>(4);
arr->Set(0, Nan::New<Number>(bounds.x));
arr->Set(1, Nan::New<Number>(bounds.y));
arr->Set(2, Nan::New<Number>(bounds.x + bounds.width));
arr->Set(3, Nan::New<Number>(bounds.y + bounds.height));
arr->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(bounds.x));
arr->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(bounds.y));
arr->Set(Nan::GetCurrentContext(),2, Nan::New<Number>(bounds.x + bounds.width));
arr->Set(Nan::GetCurrentContext(),3, Nan::New<Number>(bounds.y + bounds.height));
/*
cv::Point2f pts[4];
r.points(pts);
for (int i = 0; i < 8; i += 2) {
arr->Set(i, Nan::New<Number>(pts[i].x));
arr->Set(Nan::GetCurrentContext(), i, Nan::New<Number>(pts[i].x));
arr->Set(i + 1, Nan::New<Number>(pts[i].y));
} */

12
src/CascadeClassifierWrap.cc
View File

@ -24,7 +24,7 @@ void CascadeClassifierWrap::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "detectMultiScale", DetectMultiScale);
target->Set(Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(CascadeClassifierWrap::New) {
@ -95,11 +95,11 @@ public:
for (unsigned int i = 0; i < this->res.size(); i++) {
v8::Local < v8::Object > x = Nan::New<v8::Object>();
x->Set(Nan::New("x").ToLocalChecked(), Nan::New < Number > (this->res[i].x));
x->Set(Nan::New("y").ToLocalChecked(), Nan::New < Number > (this->res[i].y));
x->Set(Nan::New("width").ToLocalChecked(), Nan::New < Number > (this->res[i].width));
x->Set(Nan::New("height").ToLocalChecked(), Nan::New < Number > (this->res[i].height));
arr->Set(i, x);
x->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New < Number > (this->res[i].x));
x->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New < Number > (this->res[i].y));
x->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New < Number > (this->res[i].width));
x->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New < Number > (this->res[i].height));
arr->Set(Nan::GetCurrentContext(), i, x);
}
argv[0] = Nan::Null();

14
src/Constants.cc
View File

@ -6,16 +6,16 @@
#endif
#define CONST(C) \
obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>(C));
obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>(C));
#define CONST_INT(C) \
obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)C));
obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)C));
#define CONST_DOUBLE(C) \
obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Number>(C));
obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Number>(C));
#define CONST_ENUM(C) \
obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)(cv::C)));
obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)(cv::C)));
void Constants::Init(Local<Object> target) {
Nan::Persistent<Object> inner;
@ -126,10 +126,10 @@ void Constants::Init(Local<Object> target) {
CONST_ENUM(CMP_LE)
CONST_ENUM(CMP_NE)
target->Set(Nan::New("TERM_CRITERIA_EPS").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::EPS));
target->Set(Nan::New("TERM_CRITERIA_COUNT").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::COUNT));
target->Set(Nan::GetCurrentContext(), Nan::New("TERM_CRITERIA_EPS").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::EPS));
target->Set(Nan::GetCurrentContext(), Nan::New("TERM_CRITERIA_COUNT").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::COUNT));
target->Set(Nan::New("Constants").ToLocalChecked(), obj);
target->Set(Nan::GetCurrentContext(), Nan::New("Constants").ToLocalChecked(), obj);
}
#undef CONST

122
src/Contours.cc
View File

@ -33,7 +33,7 @@ void Contour::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "hierarchy", Hierarchy);
Nan::SetPrototypeMethod(ctor, "serialize", Serialize);
Nan::SetPrototypeMethod(ctor, "deserialize", Deserialize);
target->Set(Nan::New("Contours").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("Contours").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
};
NAN_METHOD(Contour::New) {
@ -64,8 +64,8 @@ NAN_METHOD(Contour::Point) {
cv::Point point = self->contours[pos][index];
Local<Object> data = Nan::New<Object>();
data->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x));
data->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y));
data->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x));
data->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y));
info.GetReturnValue().Set(data);
}
@ -81,10 +81,10 @@ NAN_METHOD(Contour::Points) {
for (std::vector<int>::size_type i = 0; i != points.size(); i++) {
Local<Object> point_data = Nan::New<Object>();
point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x));
point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y));
point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x));
point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y));
data->Set(i, point_data);
data->Set(Nan::GetCurrentContext(), i, point_data);
}
info.GetReturnValue().Set(data);
@ -115,7 +115,7 @@ NAN_METHOD(Contour::Area) {
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0].As<Number>()->Value();
bool orientation = (info.Length() > 1 && info[1]->BooleanValue( Nan::GetCurrentContext() ).FromJust());
bool orientation = (info.Length() > 1 && info[1]->BooleanValue( v8::Isolate::GetCurrent() ));
// info.GetReturnValue().Set(Nan::New<Number>(contourArea(self->contours)));
info.GetReturnValue().Set(Nan::New<Number>(contourArea(cv::Mat(self->contours[pos]), orientation)));
@ -126,7 +126,7 @@ NAN_METHOD(Contour::ArcLength) {
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0].As<Number>()->Value();
bool isClosed = info[1]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
bool isClosed = info[1]->BooleanValue( v8::Isolate::GetCurrent() );
info.GetReturnValue().Set(Nan::New<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
}
@ -137,7 +137,7 @@ NAN_METHOD(Contour::ApproxPolyDP) {
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0].As<Number>()->Value();
double epsilon = info[1].As<Number>()->Value();
bool isClosed = info[2]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
bool isClosed = info[2]->BooleanValue( v8::Isolate::GetCurrent() );
cv::Mat approxed;
approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed);
@ -152,7 +152,7 @@ NAN_METHOD(Contour::ConvexHull) {
Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
int pos = info[0].As<Number>()->Value();
bool clockwise = info[1]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
bool clockwise = info[1]->BooleanValue( v8::Isolate::GetCurrent() );
cv::Mat hull;
cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise);
@ -170,10 +170,10 @@ NAN_METHOD(Contour::BoundingRect) {
cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos]));
Local<Object> rect = Nan::New<Object>();
rect->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x));
rect->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y));
rect->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width));
rect->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height));
rect->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x));
rect->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y));
rect->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width));
rect->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height));
info.GetReturnValue().Set(rect);
}
@ -187,16 +187,16 @@ NAN_METHOD(Contour::MinAreaRect) {
cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos]));
Local<Object> rect = Nan::New<Object>();
rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle));
rect->Set(Nan::GetCurrentContext(), Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle));
Local<Object> size = Nan::New<Object>();
size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height));
size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width));
rect->Set(Nan::New("size").ToLocalChecked(), size);
size->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height));
size->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width));
rect->Set(Nan::GetCurrentContext(), Nan::New("size").ToLocalChecked(), size);
Local<Object> center = Nan::New<Object>();
center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x));
center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y));
center->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x));
center->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y));
v8::Local<v8::Array> points = Nan::New<Array>(4);
@ -205,12 +205,12 @@ NAN_METHOD(Contour::MinAreaRect) {
for (unsigned int i=0; i<4; i++) {
Local<Object> point = Nan::New<Object>();
point->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x));
point->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y));
points->Set(i, point);
point->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x));
point->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y));
points->Set(Nan::GetCurrentContext(), i, point);
}
rect->Set(Nan::New("points").ToLocalChecked(), points);
rect->Set(Nan::GetCurrentContext(), Nan::New("points").ToLocalChecked(), points);
info.GetReturnValue().Set(rect);
}
@ -225,17 +225,17 @@ NAN_METHOD(Contour::FitEllipse) {
cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos]));
Local<Object> jsEllipse = Nan::New<Object>();
jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle));
jsEllipse->Set(Nan::GetCurrentContext(), Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle));
Local<Object> size = Nan::New<Object>();
size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height));
size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width));
jsEllipse->Set(Nan::New("size").ToLocalChecked(), size);
size->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height));
size->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width));
jsEllipse->Set(Nan::GetCurrentContext(), Nan::New("size").ToLocalChecked(), size);
Local<Object> center = Nan::New<Object>();
center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x));
center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y));
jsEllipse->Set(Nan::New("center").ToLocalChecked(), center);
center->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x));
center->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y));
jsEllipse->Set(Nan::GetCurrentContext(), Nan::New("center").ToLocalChecked(), center);
info.GetReturnValue().Set(jsEllipse);
}
@ -263,10 +263,10 @@ NAN_METHOD(Contour::Moments) {
Local<Object> res = Nan::New<Object>();
res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00));
res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10));
res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01));
res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11));
res->Set(Nan::GetCurrentContext(), Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00));
res->Set(Nan::GetCurrentContext(), Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10));
res->Set(Nan::GetCurrentContext(), Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01));
res->Set(Nan::GetCurrentContext(), Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11));
info.GetReturnValue().Set(res);
}
@ -281,10 +281,10 @@ NAN_METHOD(Contour::Hierarchy) {
Local<Array> res = Nan::New<Array>(4);
res->Set(0, Nan::New<Number>(hierarchy[0]));
res->Set(1, Nan::New<Number>(hierarchy[1]));
res->Set(2, Nan::New<Number>(hierarchy[2]));
res->Set(3, Nan::New<Number>(hierarchy[3]));
res->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(hierarchy[0]));
res->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(hierarchy[1]));
res->Set(Nan::GetCurrentContext(),2, Nan::New<Number>(hierarchy[2]));
res->Set(Nan::GetCurrentContext(),3, Nan::New<Number>(hierarchy[3]));
info.GetReturnValue().Set(res);
}
@ -302,28 +302,28 @@ NAN_METHOD(Contour::Serialize) {
for (std::vector<int>::size_type j = 0; j != points.size(); j++) {
Local<Array> point_data = Nan::New<Array>(2);
point_data->Set(0, Nan::New<Number>(points[j].x));
point_data->Set(1, Nan::New<Number>(points[j].y));
point_data->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(points[j].x));
point_data->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(points[j].y));
contour_data->Set(j, point_data);
contour_data->Set(Nan::GetCurrentContext(),j, point_data);
}
contours_data->Set(i, contour_data);
contours_data->Set(Nan::GetCurrentContext(), i, contour_data);
}
Local<Array> hierarchy_data = Nan::New<Array>(self->hierarchy.size());
for (std::vector<int>::size_type i = 0; i != self->hierarchy.size(); i++) {
Local<Array> contour_data = Nan::New<Array>(4);
contour_data->Set(0, Nan::New<Number>(self->hierarchy[i][0]));
contour_data->Set(1, Nan::New<Number>(self->hierarchy[i][1]));
contour_data->Set(2, Nan::New<Number>(self->hierarchy[i][2]));
contour_data->Set(3, Nan::New<Number>(self->hierarchy[i][3]));
contour_data->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(self->hierarchy[i][0]));
contour_data->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(self->hierarchy[i][1]));
contour_data->Set(Nan::GetCurrentContext(),2, Nan::New<Number>(self->hierarchy[i][2]));
contour_data->Set(Nan::GetCurrentContext(),3, Nan::New<Number>(self->hierarchy[i][3]));
hierarchy_data->Set(i, contour_data);
hierarchy_data->Set(Nan::GetCurrentContext(), i, contour_data);
}
Local<Object> data = Nan::New<Object>();
data->Set(Nan::New<String>("contours").ToLocalChecked(), contours_data);
data->Set(Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data);
data->Set(Nan::GetCurrentContext(), Nan::New<String>("contours").ToLocalChecked(), contours_data);
data->Set(Nan::GetCurrentContext(), Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data);
info.GetReturnValue().Set(data);
}
@ -335,21 +335,21 @@ NAN_METHOD(Contour::Deserialize) {
Local<Object> data = Local<Object>::Cast(info[0]);
Local<Array> contours_data = Local<Array>::Cast(data->Get(Nan::New<String>("contours").ToLocalChecked()));
Local<Array> hierarchy_data = Local<Array>::Cast(data->Get(Nan::New<String>("hierarchy").ToLocalChecked()));
Local<Array> contours_data = Local<Array>::Cast(data->Get(Nan::GetCurrentContext(),Nan::New<String>("contours").ToLocalChecked()).ToLocalChecked());
Local<Array> hierarchy_data = Local<Array>::Cast(data->Get(Nan::GetCurrentContext(),Nan::New<String>("hierarchy").ToLocalChecked()).ToLocalChecked());
std::vector<std::vector<cv::Point> > contours_res;
int contours_length = contours_data->Length();
for (int i = 0; i < contours_length; i++) {
Local<Array> contour_data = Local<Array>::Cast(contours_data->Get(i));
Local<Array> contour_data = Local<Array>::Cast(contours_data->Get(Nan::GetCurrentContext(),i).ToLocalChecked());
std::vector<cv::Point> points;
int contour_length = contour_data->Length();
for (int j = 0; j < contour_length; j++) {
Local<Array> point_data = Local<Array>::Cast(contour_data->Get(j));
int x = point_data->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y = point_data->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
Local<Array> point_data = Local<Array>::Cast(contour_data->Get(Nan::GetCurrentContext(),j).ToLocalChecked());
int x = point_data->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y = point_data->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
points.push_back(cv::Point(x, y));
}
@ -360,11 +360,11 @@ NAN_METHOD(Contour::Deserialize) {
int hierarchy_length = hierarchy_data->Length();
for (int i = 0; i < hierarchy_length; i++) {
Local<Array> contour_data = Local<Array>::Cast(hierarchy_data->Get(i));
int a = contour_data->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int b = contour_data->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int c = contour_data->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int d = contour_data->Get(3)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
Local<Array> contour_data = Local<Array>::Cast(hierarchy_data->Get(Nan::GetCurrentContext(),i).ToLocalChecked());
int a = contour_data->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int b = contour_data->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int c = contour_data->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int d = contour_data->Get(Nan::GetCurrentContext(),3).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
hierarchy_res.push_back(cv::Vec4i(a, b, c, d));
}

18
src/FaceRecognizer.cc
View File

@ -81,7 +81,7 @@ void FaceRecognizerWrap::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "getMat", GetMat);
target->Set(Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
};
NAN_METHOD(FaceRecognizerWrap::New) {
@ -191,7 +191,7 @@ Local<Value> UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info,
const uint32_t length = tuples->Length();
for (uint32_t i = 0; i < length; ++i) {
const Local<Value> val = tuples->Get(i);
const Local<Value> val = tuples->Get(Nan::GetCurrentContext(),i).ToLocalChecked();
if (!val->IsArray()) {
JSTHROW("train takes a list of [label, image] tuples")
@ -199,12 +199,12 @@ Local<Value> UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info,
Local<Array> valarr = Local<Array>::Cast(val);
if (valarr->Length() != 2 || !valarr->Get(0)->IsInt32()) {
if (valarr->Length() != 2 || !valarr->Get(Nan::GetCurrentContext(),0)->IsInt32()) {
JSTHROW("train takes a list of [label, image] tuples")
}
int label = valarr->Get(0)->Uint32Value(Nan::GetCurrentContext()).ToChecked();
cv::Mat im = fromMatrixOrFilename(valarr->Get(1)); //this is ok because we clone the image
int label = valarr->Get(Nan::GetCurrentContext(),0)->Uint32Value(Nan::GetCurrentContext()).ToChecked();
cv::Mat im = fromMatrixOrFilename(valarr->Get(Nan::GetCurrentContext(),1)); //this is ok because we clone the image
im = im.clone();
if (im.channels() == 3) {
cv::cvtColor(im, im, CV_RGB2GRAY);
@ -332,8 +332,8 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync) {
#endif
v8::Local<v8::Object> res = Nan::New<Object>();
res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
res->Set(Nan::GetCurrentContext(), Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
res->Set(Nan::GetCurrentContext(), Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
info.GetReturnValue().Set(res);
}
@ -372,8 +372,8 @@ public:
matrix = NULL;
v8::Local<v8::Object> res = Nan::New<Object>();
res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
res->Set(Nan::GetCurrentContext(), Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
res->Set(Nan::GetCurrentContext(), Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
Local<Value> argv[] = {
res

2
src/HighGUI.cc
View File

@ -21,7 +21,7 @@ void NamedWindow::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "blockingWaitKey", BlockingWaitKey);
Nan::SetPrototypeMethod(ctor, "resizeWindow", ResizeWindow);
target->Set(Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
};
NAN_METHOD(NamedWindow::New) {

24
src/Histogram.cc
View File

@ -9,7 +9,7 @@ void Histogram::Init(Local<Object> target) {
Nan::SetMethod(obj, "calcHist", CalcHist);
Nan::SetMethod(obj, "emd", Emd);
target->Set(Nan::New("histogram").ToLocalChecked(), obj);
target->Set(Nan::GetCurrentContext(), Nan::New("histogram").ToLocalChecked(), obj);
}
NAN_METHOD(Histogram::CalcHist) {
@ -33,14 +33,14 @@ NAN_METHOD(Histogram::CalcHist) {
// in vs, can't create an array of non-constant size; but since we have dims<3, just use 3..
int channels[3];
for (unsigned int i = 0; i < dims; i++) {
channels[i] = nodeChannels->Get(i)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[i] = nodeChannels->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
}
// Arg 2 is histogram sizes in each dimension
Local<Array> nodeHistSizes = Local<Array>::Cast(info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
int histSize[3];
for (unsigned int i = 0; i < dims; i++) {
histSize[i] = nodeHistSizes->Get(i)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
histSize[i] = nodeHistSizes->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
}
// Arg 3 is array of the histogram bin boundaries in each dimension
@ -50,16 +50,16 @@ NAN_METHOD(Histogram::CalcHist) {
const float* ranges[3];
for (unsigned int i = 0; i < dims; i++) {
Local<Array> nodeRange = Local<Array>::Cast(nodeRanges->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
float lower = nodeRange->Get(0).As<Number>()->Value();
float higher = nodeRange->Get(1).As<Number>()->Value();
Local<Array> nodeRange = Local<Array>::Cast(nodeRanges->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
float lower = nodeRange->Get(Nan::GetCurrentContext(),0).ToLocalChecked().As<Number>()->Value();
float higher = nodeRange->Get(Nan::GetCurrentContext(),1).ToLocalChecked().As<Number>()->Value();
histRanges[i][0] = lower;
histRanges[i][1] = higher;
ranges[i] = histRanges[i];
}
// Arg 4 is uniform flag
bool uniform = info[4]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
bool uniform = info[4]->BooleanValue( v8::Isolate::GetCurrent() );
// Make a mat to hold the result image
cv::Mat outputHist;
@ -72,21 +72,21 @@ NAN_METHOD(Histogram::CalcHist) {
for (unsigned int i=0; i < (unsigned int) histSize[0]; i++) {
if(dims <= 1){
arr->Set(i, Nan::New<Number>(outputHist.at<float>(i)));
arr->Set(Nan::GetCurrentContext(), i, Nan::New<Number>(outputHist.at<float>(i)));
} else {
v8::Local<v8::Array> arr2 = Nan::New<Array>(dims);
for (unsigned int j=0; j < (unsigned int) histSize[1]; j++) {
if(dims <= 2){
arr2->Set(j, Nan::New<Number>(outputHist.at<float>(i,j)));
arr2->Set(Nan::GetCurrentContext(),j, Nan::New<Number>(outputHist.at<float>(i,j)));
} else {
v8::Local<v8::Array> arr3 = Nan::New<Array>(dims);
for (unsigned int k=0; k < (unsigned int) histSize[1]; k++) {
arr3->Set(k, Nan::New<Number>(outputHist.at<float>(i,j,k)));
arr3->Set(Nan::GetCurrentContext(),k, Nan::New<Number>(outputHist.at<float>(i,j,k)));
}
arr2->Set(j, arr3);
arr2->Set(Nan::GetCurrentContext(),j, arr3);
}
}
arr->Set(i, arr2);
arr->Set(Nan::GetCurrentContext(), i, arr2);
}
}

10
src/ImgProc.cc
View File

@ -14,7 +14,7 @@ void ImgProc::Init(Local<Object> target) {
Nan::SetMethod(obj, "distanceTransform", DistanceTransform);
Nan::SetMethod(obj, "getStructuringElement", GetStructuringElement);
target->Set(Nan::New("imgproc").ToLocalChecked(), obj);
target->Set(Nan::GetCurrentContext(), Nan::New("imgproc").ToLocalChecked(), obj);
}
// cv::distanceTransform
@ -109,7 +109,7 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
cv::Size imageSize;
if (info[4]->IsArray()) {
Local<Object> v8sz = info[4]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
imageSize = cv::Size(v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
imageSize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
} else {
JSTHROW_TYPE("Must pass image size");
}
@ -129,8 +129,8 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
// Make a return object with the two maps
Local<Object> ret = Nan::New<Object>();
ret->Set(Nan::New<String>("map1").ToLocalChecked(), map1Wrap);
ret->Set(Nan::New<String>("map2").ToLocalChecked(), map2Wrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("map1").ToLocalChecked(), map1Wrap);
ret->Set(Nan::GetCurrentContext(), Nan::New<String>("map2").ToLocalChecked(), map2Wrap);
// Return the maps
info.GetReturnValue().Set(ret);
@ -206,7 +206,7 @@ NAN_METHOD(ImgProc::GetStructuringElement) {
JSTHROW_TYPE("'ksize' argument must be a 2 double array");
}
Local<Object> v8sz = info[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
ksize = cv::Size(v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
ksize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
// GetStructuringElement
cv::Mat mat = cv::getStructuringElement(shape, ksize);

2
src/LDAWrap.cc
View File

@ -28,7 +28,7 @@ void LDAWrap::Init(Local<Object> target) {
Nan::SetMethod(ctor, "subspaceProject", SubspaceProject);
Nan::SetMethod(ctor, "subspaceReconstruct", SubspaceReconstruct);
target->Set(Nan::New("LDA").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("LDA").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
};
NAN_METHOD(LDAWrap::New) {

427
src/Matrix.cc
View File

@ -133,7 +133,7 @@ void Matrix::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "div", Div);
Nan::SetPrototypeMethod(ctor, "pow", Pow);
target->Set(Nan::New("Matrix").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
Nan::Set(target, Nan::New("Matrix").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
};
NAN_METHOD(Matrix::New) {
@ -225,14 +225,20 @@ Matrix::Matrix(int rows, int cols, int type, Local<Object> scalarObj) {
mat = cv::Mat(rows, cols, type);
Nan::AdjustExternalMemory(mat.dataend - mat.datastart);
if (mat.channels() == 3) {
mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
scalarObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
scalarObj->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked()));
mat.setTo(cv::Scalar(
Nan::To<double>( Nan::Get(scalarObj,0).ToLocalChecked() ).FromJust(),
Nan::To<double>( Nan::Get(scalarObj,1).ToLocalChecked() ).FromJust(),
Nan::To<double>( Nan::Get(scalarObj,2).ToLocalChecked() ).FromJust()
));
} else if (mat.channels() == 2) {
mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
scalarObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked()));
mat.setTo(cv::Scalar(
Nan::To<double>( Nan::Get(scalarObj,0).ToLocalChecked() ).FromJust(),
Nan::To<double>( Nan::Get(scalarObj,1).ToLocalChecked() ).FromJust()
));
} else if (mat.channels() == 1) {
mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked()));
mat.setTo(cv::Scalar(
Nan::To<double>( Nan::Get(scalarObj,0).ToLocalChecked() ).FromJust()
));
} else {
Nan::ThrowError("Only 1-3 channels are supported");
}
@ -305,13 +311,13 @@ NAN_METHOD(Matrix::Pixel) {
if (self->mat.channels() == 3) {
self->mat.at<cv::Vec3b>(y, x)[0] =
(uchar) objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
(uchar) Nan::To<uint32_t>( Nan::Get(objColor,0).ToLocalChecked() ).FromJust();
self->mat.at<cv::Vec3b>(y, x)[1] =
(uchar) objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
(uchar) Nan::To<uint32_t>( Nan::Get(objColor,1).ToLocalChecked() ).FromJust();
self->mat.at<cv::Vec3b>(y, x)[2] =
(uchar) objColor->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
(uchar) Nan::To<uint32_t>( Nan::Get(objColor,2).ToLocalChecked() ).FromJust();
} else if (self->mat.channels() == 1)
self->mat.at<uchar>(y, x) = (uchar) objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
self->mat.at<uchar>(y, x) = Nan::To<uint32_t>( Nan::Get(objColor,0).ToLocalChecked() ).FromJust();;
info.GetReturnValue().Set(info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
} else {
@ -319,9 +325,9 @@ NAN_METHOD(Matrix::Pixel) {
cv::Vec3b intensity = self->mat.at<cv::Vec3b>(y, x);
v8::Local < v8::Array > arr = Nan::New<v8::Array>(3);
arr->Set(0, Nan::New<Number>(intensity[0]));
arr->Set(1, Nan::New<Number>(intensity[1]));
arr->Set(2, Nan::New<Number>(intensity[2]));
Nan::Set(arr, 0, Nan::New<Number>(intensity[0]));
Nan::Set(arr, 1, Nan::New<Number>(intensity[1]));
Nan::Set(arr, 2, Nan::New<Number>(intensity[2]));
info.GetReturnValue().Set(arr);
} else if (self->mat.channels() == 1) {
uchar intensity = self->mat.at<uchar>(y, x);
@ -353,17 +359,17 @@ NAN_METHOD(Matrix::GetPixel) {
if (self->mat.channels() == 4) {
v8::Local < v8::Array > arr = Nan::New<Array>(4);
cv::Vec4b pixel = self->mat.at<cv::Vec4b>(y, x);
arr->Set(0, Nan::New<Number>((double) pixel.val[0]));
arr->Set(1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(2, Nan::New<Number>((double) pixel.val[2]));
arr->Set(3, Nan::New<Number>((double) pixel.val[3]));
Nan::Set(arr, 0, Nan::New<Number>((double) pixel.val[0]));
Nan::Set(arr, 1, Nan::New<Number>((double) pixel.val[1]));
Nan::Set(arr, 2, Nan::New<Number>((double) pixel.val[2]));
Nan::Set(arr, 3, Nan::New<Number>((double) pixel.val[3]));
info.GetReturnValue().Set(arr);
} else if (self->mat.channels() == 3) {
v8::Local < v8::Array > arr = Nan::New<Array>(3);
cv::Vec3b pixel = self->mat.at<cv::Vec3b>(y, x);
arr->Set(0, Nan::New<Number>((double) pixel.val[0]));
arr->Set(1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(2, Nan::New<Number>((double) pixel.val[2]));
Nan::Set(arr, 0, Nan::New<Number>((double) pixel.val[0]));
Nan::Set(arr, 1, Nan::New<Number>((double) pixel.val[1]));
Nan::Set(arr, 2, Nan::New<Number>((double) pixel.val[2]));
info.GetReturnValue().Set(arr);
} else if(self->mat.channels() == 1) {
int pixel = (int)self->mat.at<unsigned char>(y, x);
@ -439,7 +445,7 @@ NAN_METHOD(Matrix::GetData) {
}
v8::Local<v8::Object> globalObj = Nan::GetCurrentContext()->Global();
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(Nan::Get(globalObj,Nan::New<String>("Buffer").ToLocalChecked()).ToLocalChecked());
v8::Local<v8::Value> constructorArgs[3] = {buf, Nan::New<v8::Integer>((unsigned) size), Nan::New<v8::Integer>(0)};
v8::Local<v8::Object> actualBuffer = Nan::NewInstance(bufferConstructor, 3, constructorArgs).ToLocalChecked();
@ -596,8 +602,8 @@ NAN_METHOD(Matrix::Size) {
SETUP_FUNCTION(Matrix)
v8::Local < v8::Array > arr = Nan::New<Array>(2);
arr->Set(0, Nan::New<Number>(self->mat.size().height));
arr->Set(1, Nan::New<Number>(self->mat.size().width));
Nan::Set(arr, 0, Nan::New<Number>(self->mat.size().height));
Nan::Set(arr, 1, Nan::New<Number>(self->mat.size().width));
info.GetReturnValue().Set(arr);
}
@ -646,7 +652,7 @@ NAN_METHOD(Matrix::Row) {
for (int x = 0; x < width; x++) {
double v = Matrix::DblGet(self->mat, y, x);
arr->Set(x, Nan::New<Number>(v));
Nan::Set(arr, x, Nan::New<Number>(v));
}
info.GetReturnValue().Set(arr);
@ -664,25 +670,25 @@ NAN_METHOD(Matrix::PixelRow) {
for (int x = 0; x < width; x++) {
cv::Vec4b pixel = self->mat.at<cv::Vec4b>(y, x);
int offset = x * 4;
arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
arr->Set(offset + 3, Nan::New<Number>((double) pixel.val[3]));
Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
Nan::Set(arr, offset + 3, Nan::New<Number>((double) pixel.val[3]));
}
} else if(self->mat.channels() == 3){
arr = Nan::New<Array>(width * 3);
for (int x = 0; x < width; x++) {
cv::Vec3b pixel = self->mat.at<cv::Vec3b>(y, x);
int offset = x * 3;
arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
}
} else if(self->mat.channels() == 1){
arr = Nan::New<Array>(width);
for (int x = 0; x < width; x++) {
int pixel = (int)self->mat.at<unsigned char>(y, x);
arr->Set(x, Nan::New<Number>(pixel));
Nan::Set(arr, x, Nan::New<Number>(pixel));
}
} else {
Nan::ThrowTypeError("Only 4, 3 and 1 channel matrix are supported");
@ -700,7 +706,7 @@ NAN_METHOD(Matrix::Col) {
for (int y = 0; y < height; y++) {
double v = Matrix::DblGet(self->mat, y, x);
arr->Set(y, Nan::New<Number>(v));
Nan::Set(arr, y, Nan::New<Number>(v));
}
info.GetReturnValue().Set(arr);
}
@ -717,25 +723,25 @@ NAN_METHOD(Matrix::PixelCol) {
for (int y = 0; y < height; y++) {
cv::Vec4b pixel = self->mat.at<cv::Vec4b>(y, x);
int offset = y * 4;
arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
arr->Set(offset + 3, Nan::New<Number>((double) pixel.val[3]));
Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
Nan::Set(arr, offset + 3, Nan::New<Number>((double) pixel.val[3]));
}
} else if (self->mat.channels() == 3) {
arr = Nan::New<Array>(height * 3);
for (int y = 0; y < height; y++) {
cv::Vec3b pixel = self->mat.at<cv::Vec3b>(y, x);
int offset = y * 3;
arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
}
} else if(self->mat.channels() == 1) {
arr = Nan::New<Array>(height);
for (int y = 0; y < height; y++) {
int pixel = (int)self->mat.at<unsigned char>(y, x);
arr->Set(y, Nan::New<Number>(pixel));
Nan::Set(arr, y, Nan::New<Number>(pixel));
}
} else {
Nan::ThrowTypeError("Only 4, 3 and 1 channel matrix are supported");
@ -788,19 +794,19 @@ NAN_METHOD(Matrix::ToBuffer) {
// If the extension (image format) is provided
if (options->Has( Nan::GetCurrentContext(), Nan::New<String>("ext").ToLocalChecked()).ToChecked() ) {
v8::String::Utf8Value str(v8::Isolate::GetCurrent(),
options->Get(Nan::New<String>("ext").ToLocalChecked())->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
options->Get(Nan::GetCurrentContext(), Nan::New<String>("ext").ToLocalChecked()).ToLocalChecked()->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
optExt = *str;
ext = (const char *) optExt.c_str();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("jpegQuality").ToLocalChecked()).ToChecked() ) {
int compression =
options->Get(Nan::New<String>("jpegQuality").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
options->Get(Nan::GetCurrentContext(), Nan::New<String>("jpegQuality").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
params.push_back(CV_IMWRITE_JPEG_QUALITY);
params.push_back(compression);
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("pngCompression").ToLocalChecked()).ToChecked() ) {
int compression =
options->Get(Nan::New<String>("pngCompression").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
options->Get(Nan::GetCurrentContext(), Nan::New<String>("pngCompression").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
params.push_back(CV_IMWRITE_PNG_COMPRESSION);
params.push_back(compression);
}
@ -817,7 +823,7 @@ NAN_METHOD(Matrix::ToBuffer) {
v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global();
v8::Local < v8::Function > bufferConstructor = v8::Local < v8::Function
> ::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
> ::Cast(globalObj->Get(Nan::GetCurrentContext(), Nan::New<String>("Buffer").ToLocalChecked()).ToLocalChecked());
v8::Local<v8::Value> constructorArgs[3] =
{buf, Nan::New<v8::Integer>((unsigned)vec.size()), Nan::New<v8::Integer>(0)};
v8::Local < v8::Object > actualBuffer = Nan::NewInstance(bufferConstructor, 3, constructorArgs).ToLocalChecked();
@ -857,7 +863,7 @@ public:
memcpy(data, &res[0], res.size());
v8::Local<v8::Object> globalObj = Nan::GetCurrentContext()->Global();
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::GetCurrentContext(), Nan::New<String>("Buffer").ToLocalChecked()).ToLocalChecked());
v8::Local<v8::Value> constructorArgs[3] = {buf, Nan::New<v8::Integer>((unsigned)res.size()), Nan::New<v8::Integer>(0)};
v8::Local<v8::Object> actualBuffer = Nan::NewInstance(bufferConstructor, 3, constructorArgs).ToLocalChecked();;
@ -896,19 +902,19 @@ NAN_METHOD(Matrix::ToBufferAsync) {
// If the extension (image format) is provided
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("ext").ToLocalChecked()).ToChecked() ) {
v8::String::Utf8Value str(v8::Isolate::GetCurrent(),
options->Get(Nan::New<String>("ext").ToLocalChecked())->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
options->Get(Nan::GetCurrentContext(), Nan::New<String>("ext").ToLocalChecked()).ToLocalChecked()->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
std::string str2 = std::string(*str);
ext = str2;
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("jpegQuality").ToLocalChecked()).ToChecked() ) {
int compression =
options->Get(Nan::New<String>("jpegQuality").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
options->Get(Nan::GetCurrentContext(), Nan::New<String>("jpegQuality").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
params.push_back(CV_IMWRITE_JPEG_QUALITY);
params.push_back(compression);
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("pngCompression").ToLocalChecked()).ToChecked() ) {
int compression =
options->Get(Nan::New<String>("pngCompression").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
options->Get(Nan::GetCurrentContext(), Nan::New<String>("pngCompression").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
params.push_back(CV_IMWRITE_PNG_COMPRESSION);
params.push_back(compression);
}
@ -939,36 +945,36 @@ NAN_METHOD(Matrix::Ellipse) {
v8::Local < v8::Object > options = v8::Local<v8::Object>::Cast(info[0]);
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("center").ToLocalChecked()).ToChecked() ) {
Local < Object > center =
options->Get(Nan::New<String>("center").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
x = center->Get(Nan::New<String>("x").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
y = center->Get(Nan::New<String>("y").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
options->Get(Nan::GetCurrentContext(), Nan::New<String>("center").ToLocalChecked()).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
x = center->Get(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
y = center->Get(Nan::GetCurrentContext(), Nan::New<String>("y").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("axes").ToLocalChecked()).ToChecked() ) {
Local < Object > axes = options->Get(Nan::New<String>("axes").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
width = axes->Get(Nan::New<String>("width").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
height = axes->Get(Nan::New<String>("height").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
Local < Object > axes = options->Get(Nan::GetCurrentContext(), Nan::New<String>("axes").ToLocalChecked()).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
width = axes->Get(Nan::GetCurrentContext(), Nan::New<String>("width").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
height = axes->Get(Nan::GetCurrentContext(), Nan::New<String>("height").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("thickness").ToLocalChecked()).ToChecked() ) {
thickness = options->Get(Nan::New<String>("thickness").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
thickness = options->Get(Nan::GetCurrentContext(), Nan::New<String>("thickness").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("angle").ToLocalChecked()).ToChecked() ) {
angle = options->Get(Nan::New<String>("angle").ToLocalChecked()).As<Number>()->Value();
angle = options->Get(Nan::GetCurrentContext(), Nan::New<String>("angle").ToLocalChecked()).ToLocalChecked().As<Number>()->Value();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("startAngle").ToLocalChecked()).ToChecked() ) {
startAngle = options->Get(Nan::New<String>("startAngle").ToLocalChecked()).As<Number>()->Value();
startAngle = options->Get(Nan::GetCurrentContext(), Nan::New<String>("startAngle").ToLocalChecked()).ToLocalChecked().As<Number>()->Value();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("endAngle").ToLocalChecked()).ToChecked() ) {
endAngle = options->Get(Nan::New<String>("endAngle").ToLocalChecked()).As<Number>()->Value();
endAngle = options->Get(Nan::GetCurrentContext(), Nan::New<String>("endAngle").ToLocalChecked()).ToLocalChecked().As<Number>()->Value();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("lineType").ToLocalChecked()).ToChecked() ) {
lineType = options->Get(Nan::New<String>("lineType").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
lineType = options->Get(Nan::GetCurrentContext(), Nan::New<String>("lineType").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("shift").ToLocalChecked()).ToChecked() ) {
shift = options->Get(Nan::New<String>("shift").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
shift = options->Get(Nan::GetCurrentContext(), Nan::New<String>("shift").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
}
if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("color").ToLocalChecked()).ToChecked() ) {
Local < Object > objColor =
options->Get(Nan::New<String>("color").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
options->Get(Nan::GetCurrentContext(), Nan::New<String>("color").ToLocalChecked()).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
color = setColor(objColor);
}
} else {
@ -1005,11 +1011,11 @@ NAN_METHOD(Matrix::Rectangle) {
color = setColor(objColor);
}
int x = xy->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y = xy->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int x = xy->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y = xy->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int width = width_height->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int height = width_height->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int width = width_height->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int height = width_height->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int thickness = 1;
@ -1037,11 +1043,11 @@ NAN_METHOD(Matrix::Line) {
color = setColor(objColor);
}
int x1 = xy1->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y1 = xy1->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int x1 = xy1->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y1 = xy1->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int x2 = xy2->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y2 = xy2->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int x2 = xy2->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int y2 = xy2->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
int thickness = 1;
@ -1063,14 +1069,14 @@ NAN_METHOD(Matrix::FillPoly) {
cv::Point **polygons = new cv::Point*[polyArray->Length()];
int *polySizes = new int[polyArray->Length()];
for (unsigned int i = 0; i < polyArray->Length(); i++) {
Local<Array> singlePoly = Local<Array> ::Cast(polyArray->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
Local<Array> singlePoly = Local<Array> ::Cast(polyArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
polygons[i] = new cv::Point[singlePoly->Length()];
polySizes[i] = singlePoly->Length();
for (unsigned int j = 0; j < singlePoly->Length(); j++) {
Local<Array> point = Local<Array> ::Cast(singlePoly->Get(j)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
polygons[i][j].x = point->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
polygons[i][j].y = point->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
Local<Array> point = Local<Array> ::Cast(singlePoly->Get(Nan::GetCurrentContext(),j).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
polygons[i][j].x = point->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
polygons[i][j].y = point->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
}
}
@ -1258,8 +1264,8 @@ NAN_METHOD(Matrix::GaussianBlur) {
}
Local<Object> array = Nan::To<v8::Object>(info[0]).ToLocalChecked();
// TODO: Length check
Local<Value> x = array->Get(0);
Local<Value> y = array->Get(1);
Local<Value> x = array->Get(Nan::GetCurrentContext(),0).ToLocalChecked();
Local<Value> y = array->Get(Nan::GetCurrentContext(),1).ToLocalChecked();
if (!x->IsNumber() || !y->IsNumber()) {
Nan::ThrowTypeError("'ksize' argument must be a 2 double array");
}
@ -1577,32 +1583,32 @@ NAN_METHOD(Matrix::Moments) {
Local<Object> res = Nan::New<Object>();
res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mo.m00));
res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mo.m10));
res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mo.m01));
res->Set(Nan::New("m20").ToLocalChecked(), Nan::New<Number>(mo.m20));
res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mo.m11));
res->Set(Nan::New("m02").ToLocalChecked(), Nan::New<Number>(mo.m02));
res->Set(Nan::New("m30").ToLocalChecked(), Nan::New<Number>(mo.m30));
res->Set(Nan::New("m21").ToLocalChecked(), Nan::New<Number>(mo.m21));
res->Set(Nan::New("m12").ToLocalChecked(), Nan::New<Number>(mo.m12));
res->Set(Nan::New("m03").ToLocalChecked(), Nan::New<Number>(mo.m03));
res->Set(Nan::GetCurrentContext(),Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mo.m00));
res->Set(Nan::GetCurrentContext(),Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mo.m10));
res->Set(Nan::GetCurrentContext(),Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mo.m01));
res->Set(Nan::GetCurrentContext(),Nan::New("m20").ToLocalChecked(), Nan::New<Number>(mo.m20));
res->Set(Nan::GetCurrentContext(),Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mo.m11));
res->Set(Nan::GetCurrentContext(),Nan::New("m02").ToLocalChecked(), Nan::New<Number>(mo.m02));
res->Set(Nan::GetCurrentContext(),Nan::New("m30").ToLocalChecked(), Nan::New<Number>(mo.m30));
res->Set(Nan::GetCurrentContext(),Nan::New("m21").ToLocalChecked(), Nan::New<Number>(mo.m21));
res->Set(Nan::GetCurrentContext(),Nan::New("m12").ToLocalChecked(), Nan::New<Number>(mo.m12));
res->Set(Nan::GetCurrentContext(),Nan::New("m03").ToLocalChecked(), Nan::New<Number>(mo.m03));
res->Set(Nan::New("mu20").ToLocalChecked(), Nan::New<Number>(mo.mu20));
res->Set(Nan::New("mu11").ToLocalChecked(), Nan::New<Number>(mo.mu11));
res->Set(Nan::New("mu02").ToLocalChecked(), Nan::New<Number>(mo.mu02));
res->Set(Nan::New("mu30").ToLocalChecked(), Nan::New<Number>(mo.mu30));
res->Set(Nan::New("mu21").ToLocalChecked(), Nan::New<Number>(mo.mu21));
res->Set(Nan::New("mu12").ToLocalChecked(), Nan::New<Number>(mo.mu12));
res->Set(Nan::New("mu03").ToLocalChecked(), Nan::New<Number>(mo.mu03));
res->Set(Nan::GetCurrentContext(),Nan::New("mu20").ToLocalChecked(), Nan::New<Number>(mo.mu20));
res->Set(Nan::GetCurrentContext(),Nan::New("mu11").ToLocalChecked(), Nan::New<Number>(mo.mu11));
res->Set(Nan::GetCurrentContext(),Nan::New("mu02").ToLocalChecked(), Nan::New<Number>(mo.mu02));
res->Set(Nan::GetCurrentContext(),Nan::New("mu30").ToLocalChecked(), Nan::New<Number>(mo.mu30));
res->Set(Nan::GetCurrentContext(),Nan::New("mu21").ToLocalChecked(), Nan::New<Number>(mo.mu21));
res->Set(Nan::GetCurrentContext(),Nan::New("mu12").ToLocalChecked(), Nan::New<Number>(mo.mu12));
res->Set(Nan::GetCurrentContext(),Nan::New("mu03").ToLocalChecked(), Nan::New<Number>(mo.mu03));
res->Set(Nan::New("nu20").ToLocalChecked(), Nan::New<Number>(mo.nu20));
res->Set(Nan::New("nu11").ToLocalChecked(), Nan::New<Number>(mo.nu11));
res->Set(Nan::New("nu02").ToLocalChecked(), Nan::New<Number>(mo.nu02));
res->Set(Nan::New("nu30").ToLocalChecked(), Nan::New<Number>(mo.nu30));
res->Set(Nan::New("nu21").ToLocalChecked(), Nan::New<Number>(mo.nu21));
res->Set(Nan::New("nu12").ToLocalChecked(), Nan::New<Number>(mo.nu12));
res->Set(Nan::New("nu03").ToLocalChecked(), Nan::New<Number>(mo.nu03));
res->Set(Nan::GetCurrentContext(),Nan::New("nu20").ToLocalChecked(), Nan::New<Number>(mo.nu20));
res->Set(Nan::GetCurrentContext(),Nan::New("nu11").ToLocalChecked(), Nan::New<Number>(mo.nu11));
res->Set(Nan::GetCurrentContext(),Nan::New("nu02").ToLocalChecked(), Nan::New<Number>(mo.nu02));
res->Set(Nan::GetCurrentContext(),Nan::New("nu30").ToLocalChecked(), Nan::New<Number>(mo.nu30));
res->Set(Nan::GetCurrentContext(),Nan::New("nu21").ToLocalChecked(), Nan::New<Number>(mo.nu21));
res->Set(Nan::GetCurrentContext(),Nan::New("nu12").ToLocalChecked(), Nan::New<Number>(mo.nu12));
res->Set(Nan::GetCurrentContext(),Nan::New("nu03").ToLocalChecked(), Nan::New<Number>(mo.nu03));
info.GetReturnValue().Set(res);
}
@ -1735,7 +1741,7 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) {
double qualityLevel = info.Length() >= 2 ? (double) info[1].As<Number>()->Value() : 0.01;
double minDistance = info.Length() >= 3 ? (double) info[2].As<Number>()->Value() : 10;
int blockSize = info.Length() >= 4 ? info[3]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 3;
bool useHarrisDetector = info.Length() >= 5 ? info[4]->BooleanValue( Nan::GetCurrentContext() ).FromJust() : false;
bool useHarrisDetector = info.Length() >= 5 ? info[4]->BooleanValue( v8::Isolate::GetCurrent() ) : false;
double k = info.Length() >= 6 ? (double) info[5].As<Number>()->Value() : 0.04;
std::vector<cv::Point2f> corners;
@ -1753,9 +1759,9 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) {
for (unsigned int i=0; i<corners.size(); i++) {
v8::Local<v8::Array> pt = Nan::New<Array>(2);
pt->Set(0, Nan::New<Number>((double) corners[i].x));
pt->Set(1, Nan::New<Number>((double) corners[i].y));
arr->Set(i, pt);
pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) corners[i].x));
pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) corners[i].y));
Nan::Set(arr, i, pt);
}
info.GetReturnValue().Set(arr);
@ -1771,14 +1777,14 @@ NAN_METHOD(Matrix::CalcOpticalFlowPyrLK) {
std::vector<cv::Point2f> old_points;
for (unsigned int i=0; i<points->Length(); i++) {
Local<Object> pt = points->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
old_points.push_back(cv::Point2f(pt->Get(0).As<Number>()->Value(), pt->Get(1).As<Number>()->Value()));
Local<Object> pt = points->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
old_points.push_back(cv::Point2f(pt->Get(Nan::GetCurrentContext(),0).ToLocalChecked().As<Number>()->Value(), pt->Get(Nan::GetCurrentContext(),1).ToLocalChecked().As<Number>()->Value()));
}
cv::Size winSize;
if (info.Length() >= 3 && info[2]->IsArray()) {
Local<Object> winSizeObj = info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
winSize = cv::Size(winSizeObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), winSizeObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
winSize = cv::Size(winSizeObj->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), winSizeObj->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
} else {
winSize = cv::Size(21, 21);
}
@ -1788,7 +1794,7 @@ NAN_METHOD(Matrix::CalcOpticalFlowPyrLK) {
cv::TermCriteria criteria;
if (info.Length() >= 5 && info[4]->IsArray()) {
Local<Object> criteriaObj = info[4]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
criteria = cv::TermCriteria(criteriaObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), criteriaObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), (double) criteriaObj->Get(2).As<Number>()->Value());
criteria = cv::TermCriteria(criteriaObj->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), criteriaObj->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), (double) criteriaObj->Get(Nan::GetCurrentContext(),2).ToLocalChecked().As<Number>()->Value());
} else {
criteria = cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, 0.01);
}
@ -1814,27 +1820,27 @@ NAN_METHOD(Matrix::CalcOpticalFlowPyrLK) {
for (unsigned int i=0; i<old_points.size(); i++) {
v8::Local<v8::Array> pt = Nan::New<Array>(2);
pt->Set(0, Nan::New<Number>((double) old_points[i].x));
pt->Set(1, Nan::New<Number>((double) old_points[i].y));
old_arr->Set(i, pt);
pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) old_points[i].x));
pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) old_points[i].y));
new_arr->Set(Nan::GetCurrentContext(), i, pt);
}
for (unsigned int i=0; i<new_points.size(); i++) {
v8::Local<v8::Array> pt = Nan::New<Array>(2);
pt->Set(0, Nan::New<Number>((double) new_points[i].x));
pt->Set(1, Nan::New<Number>((double) new_points[i].y));
new_arr->Set(i, pt);
pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) new_points[i].x));
pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) new_points[i].y));
new_arr->Set(Nan::GetCurrentContext(), i, pt);
}
for (unsigned int i=0; i<status.size(); i++) {
v8::Local<v8::Integer> pt = Nan::New<Integer>((int)status[i]);
found->Set(i, pt);
found->Set(Nan::GetCurrentContext(),i, pt);
}
Local<Object> data = Nan::New<Object>();
data->Set(Nan::New<String>("old_points").ToLocalChecked(), old_arr);
data->Set(Nan::New<String>("new_points").ToLocalChecked(), new_arr);
data->Set(Nan::New<String>("found").ToLocalChecked(), found);
data->Set(Nan::GetCurrentContext(),Nan::New<String>("old_points").ToLocalChecked(), old_arr);
data->Set(Nan::GetCurrentContext(),Nan::New<String>("new_points").ToLocalChecked(), new_arr);
data->Set(Nan::GetCurrentContext(),Nan::New<String>("found").ToLocalChecked(), found);
info.GetReturnValue().Set(data);
}
@ -1861,11 +1867,11 @@ NAN_METHOD(Matrix::HoughLinesP) {
for (unsigned int i=0; i<lines.size(); i++) {
v8::Local<v8::Array> pt = Nan::New<Array>(4);
pt->Set(0, Nan::New<Number>((double) lines[i][0]));
pt->Set(1, Nan::New<Number>((double) lines[i][1]));
pt->Set(2, Nan::New<Number>((double) lines[i][2]));
pt->Set(3, Nan::New<Number>((double) lines[i][3]));
arr->Set(i, pt);
pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) lines[i][0]));
pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) lines[i][1]));
pt->Set(Nan::GetCurrentContext(),2, Nan::New<Number>((double) lines[i][2]));
pt->Set(Nan::GetCurrentContext(),3, Nan::New<Number>((double) lines[i][3]));
Nan::Set(arr, i, pt);
}
info.GetReturnValue().Set(arr);
@ -1895,10 +1901,10 @@ NAN_METHOD(Matrix::HoughCircles) {
for (unsigned int i=0; i < circles.size(); i++) {
v8::Local<v8::Array> pt = Nan::New<Array>(3);
pt->Set(0, Nan::New<Number>((double) circles[i][0])); // center x
pt->Set(1, Nan::New<Number>((double) circles[i][1]));// center y
pt->Set(2, Nan::New<Number>((double) circles[i][2]));// radius
arr->Set(i, pt);
pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) circles[i][0])); // center x
pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) circles[i][1]));// center y
pt->Set(Nan::GetCurrentContext(),2, Nan::New<Number>((double) circles[i][2]));// radius
Nan::Set(arr, i, pt);
}
info.GetReturnValue().Set(arr);
@ -1910,43 +1916,43 @@ cv::Scalar setColor(Local<Object> objColor) {
// We'll accomodate a channel count up to 4 and fall back to the old
// "assume it's always 3" in the default case
if (!objColor->HasRealIndexedProperty( Nan::GetCurrentContext() , 1).ToChecked()) {
channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[0] = objColor->Get(Nan::GetCurrentContext(), 0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
} else if (!objColor->HasRealIndexedProperty( Nan::GetCurrentContext() , 2).ToChecked()) {
channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[1] = objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[0] = objColor->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[1] = objColor->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
} else if (!objColor->HasRealIndexedProperty( Nan::GetCurrentContext() , 4).ToChecked()) {
channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[1] = objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[2] = objColor->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[3] = objColor->Get(3)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[0] = objColor->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[1] = objColor->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[2] = objColor->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[3] = objColor->Get(Nan::GetCurrentContext(),3).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
} else {
channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[1] = objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[2] = objColor->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[0] = objColor->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[1] = objColor->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
channels[2] = objColor->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
}
return cv::Scalar(channels[0], channels[1], channels[2], channels[3]);
}
cv::Point setPoint(Local<Object> objPoint) {
return cv::Point(objPoint->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
objPoint->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
return cv::Point(objPoint->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
objPoint->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
}
cv::Rect* setRect(Local<Object> objRect, cv::Rect &result) {
if (!objRect->IsArray() || !objRect->Get(0)->IsArray()
|| !objRect->Get(0)->IsArray()) {
if (!objRect->IsArray() || !objRect->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IsArray()
|| !objRect->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IsArray()) {
printf("error");
return 0;
};
Local < Object > point = objRect->Get(0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
Local < Object > size = objRect->Get(1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
Local < Object > point = Nan::To<Object>( Nan::Get(objRect,0).ToLocalChecked() ).ToLocalChecked();;
Local < Object > size = Nan::To<Object>( Nan::Get(objRect,1).ToLocalChecked() ).ToLocalChecked();
result.x = point->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
result.y = point->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
result.width = size->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
result.height = size->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
result.x = Nan::To<int32_t>( Nan::Get(point,0).ToLocalChecked() ).FromJust();
result.y = Nan::To<int32_t>( Nan::Get(point,1).ToLocalChecked() ).FromJust();
result.width = Nan::To<int32_t>( Nan::Get(size,0).ToLocalChecked() ).FromJust();
result.height = Nan::To<int32_t>( Nan::Get(size,1).ToLocalChecked() ).FromJust();
return &result;
}
@ -2259,10 +2265,10 @@ NAN_METHOD(Matrix::LocateROI) {
self->mat.locateROI(wholeSize, ofs);
v8::Local < v8::Array > arr = Nan::New<Array>(4);
arr->Set(0, Nan::New<Number>(wholeSize.width));
arr->Set(1, Nan::New<Number>(wholeSize.height));
arr->Set(2, Nan::New<Number>(ofs.x));
arr->Set(3, Nan::New<Number>(ofs.y));
Nan::Set(arr, 0, Nan::New<Number>(wholeSize.width));
Nan::Set(arr, 1, Nan::New<Number>(wholeSize.height));
Nan::Set(arr, 2, Nan::New<Number>(ofs.x));
Nan::Set(arr, 3, Nan::New<Number>(ofs.y));
info.GetReturnValue().Set(arr);
}
@ -2374,8 +2380,8 @@ NAN_METHOD(Matrix::MeanStdDev) {
cv::meanStdDev(self->mat, meanMat, stddevMat);
Local<Object> data = Nan::New<Object>();
data->Set(Nan::New<String>("mean").ToLocalChecked(), CreateWrappedFromMat(meanMat));
data->Set(Nan::New<String>("stddev").ToLocalChecked(), CreateWrappedFromMat(stddevMat));
Nan::Set(data,Nan::New<String>("mean").ToLocalChecked(), CreateWrappedFromMat(meanMat));
Nan::Set(data,Nan::New<String>("stddev").ToLocalChecked(), CreateWrappedFromMat(stddevMat));
info.GetReturnValue().Set(data);
}
@ -2536,7 +2542,7 @@ NAN_METHOD(Matrix::Split) {
v8::Local<v8::Array> arrChannels = Nan::New<Array>(size);
for (unsigned int i = 0; i < size; i++) {
Local<Object> matObject = Matrix::CreateWrappedFromMatIfNotReferenced(channels[i], 1);
arrChannels->Set(i, matObject);
Nan::Set(arrChannels, i, matObject);
}
info.GetReturnValue().Set(arrChannels);
@ -2557,7 +2563,7 @@ NAN_METHOD(Matrix::Merge) {
unsigned int L = jsChannels->Length();
std::vector<cv::Mat> vChannels(L);
for (unsigned int i = 0; i < L; i++) {
Matrix * matObject = Nan::ObjectWrap::Unwrap<Matrix>(jsChannels->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
Matrix * matObject = Nan::ObjectWrap::Unwrap<Matrix>( Nan::To<v8::Object>( Nan::Get(jsChannels,i).ToLocalChecked() ).ToLocalChecked() );
vChannels[i] = matObject->mat;
}
cv::merge(vChannels, self->mat);
@ -2581,7 +2587,7 @@ NAN_METHOD(Matrix::EqualizeHist) {
NAN_METHOD(Matrix::FloodFill) {
SETUP_FUNCTION(Matrix)
// obj->Get(Nan::New<String>("x").ToLocalChecked())
// obj->Get(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked())
// int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int)
/* mat.floodFill( {seedPoint: [1,1] ,
@ -2599,24 +2605,32 @@ NAN_METHOD(Matrix::FloodFill) {
cv::Rect rect;
int ret = cv::floodFill(self->mat,
setPoint(obj->Get(Nan::New<String>("seedPoint").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()),
setColor(obj->Get(Nan::New<String>("newColor").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()),
obj->Get(Nan::New<String>("rect").ToLocalChecked())->IsUndefined() ?
0 : setRect(obj->Get(Nan::New<String>("rect").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked(), rect),
setColor(obj->Get(Nan::New<String>("loDiff").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()),
setColor(obj->Get(Nan::New<String>("upDiff").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()), 4);
setPoint( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("seedPoint").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
setColor( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("newColor").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).IsEmpty() ?
0 : setRect( Nan::To<Object>( Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked(), rect),
setColor( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("loDiff").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
setColor( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("upDiff").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
4);
// Documentation notes that parameter "rect" is an optional output
// parameter which will hold the smallest possible bounding box of
// affected pixels. If "rect" was provided, let's update the values.
// (https://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html#floodfill)
if (!obj->Get(Nan::New<String>("rect").ToLocalChecked())->IsUndefined()) {
Local< Object > rectArgument =
obj->Get(Nan::New<String>("rect").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
rectArgument->Get(0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(0, Nan::New<Number>(rect.x));
rectArgument->Get(0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(1, Nan::New<Number>(rect.y));
rectArgument->Get(1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(0, Nan::New<Number>(rect.width));
rectArgument->Get(1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(1, Nan::New<Number>(rect.height));
if (! Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).IsEmpty()) {
Local< Object > rectArgument = Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked();
//obj->Get(Nan::GetCurrentContext(), Nan::New<String>("rect").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
//Nan::Get(rectArgument,0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(rect.x));
Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,0).ToLocalChecked() ).ToLocalChecked(), 0, Nan::New<Number>(rect.x) );
//Nan::Get(rectArgument,0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(rect.y));
Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,0).ToLocalChecked() ).ToLocalChecked(), 1, Nan::New<Number>(rect.y) );
//Nan::Get(rectArgument,1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(rect.width));
Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,1).ToLocalChecked() ).ToLocalChecked(), 0, Nan::New<Number>(rect.width) );
//Nan::Get(rectArgument,1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(rect.height));
Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,1).ToLocalChecked() ).ToLocalChecked(), 1, Nan::New<Number>(rect.height) );
}
info.GetReturnValue().Set(Nan::New<Number>(ret));
@ -2635,7 +2649,7 @@ NAN_METHOD(Matrix::TemplateMatches) {
double min_probability = filter_min_probability ? info[0].As<Number>()->Value() : 0;
double max_probability = filter_max_probability ? info[1].As<Number>()->Value() : 0;
int limit = (info.Length() >= 3) ? info[2]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 0;
bool ascending = (info.Length() >= 4) ? info[3]->BooleanValue( Nan::GetCurrentContext() ).FromJust() : false;
bool ascending = (info.Length() >= 4) ? Nan::To<bool>(info[3] ).FromJust() : false;
int min_x_distance = (info.Length() >= 5) ? info[4]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 0;
int min_y_distance = (info.Length() >= 6) ? info[5]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 0;
@ -2709,11 +2723,11 @@ NAN_METHOD(Matrix::TemplateMatches) {
Local<Value> probability_value = Nan::New<Number>(probability);
Local < Object > probability_object = Nan::New<Object>();
probability_object->Set(Nan::New<String>("x").ToLocalChecked(), x_value);
probability_object->Set(Nan::New<String>("y").ToLocalChecked(), y_value);
probability_object->Set(Nan::New<String>("probability").ToLocalChecked(), probability_value);
Nan::Set(probability_object,Nan::New<String>("x").ToLocalChecked(), x_value);
Nan::Set(probability_object,Nan::New<String>("y").ToLocalChecked(), y_value);
Nan::Set(probability_object,Nan::New<String>("probability").ToLocalChecked(), probability_value);
probabilites_array->Set(index, probability_object);
Nan::Set(probabilites_array,index, probability_object);
index++;
}
@ -2807,11 +2821,11 @@ NAN_METHOD(Matrix::MatchTemplate) {
result.convertTo(result, CV_8UC1, 255, 0);
v8::Local <v8::Array> arr = Nan::New<v8::Array>(5);
arr->Set(0, CreateWrappedFromMat(result));
arr->Set(1, Nan::New<Number>(roi_x));
arr->Set(2, Nan::New<Number>(roi_y));
arr->Set(3, Nan::New<Number>(roi_width));
arr->Set(4, Nan::New<Number>(roi_height));
Nan::Set(arr, 0, CreateWrappedFromMat(result));
Nan::Set(arr, 1, Nan::New<Number>(roi_x));
Nan::Set(arr, 2, Nan::New<Number>(roi_y));
Nan::Set(arr, 3, Nan::New<Number>(roi_width));
Nan::Set(arr, 4, Nan::New<Number>(roi_height));
info.GetReturnValue().Set(arr);
}
@ -2833,19 +2847,19 @@ NAN_METHOD(Matrix::MinMaxLoc) {
Local<Value> v_maxLoc_y = Nan::New<Number>(maxLoc.y);
Local<Object> o_minLoc = Nan::New<Object>();
o_minLoc->Set(Nan::New<String>("x").ToLocalChecked(), v_minLoc_x);
o_minLoc->Set(Nan::New<String>("y").ToLocalChecked(), v_minLoc_y);
Nan::Set(o_minLoc,Nan::New<String>("x").ToLocalChecked(), v_minLoc_x);
Nan::Set(o_minLoc,Nan::New<String>("y").ToLocalChecked(), v_minLoc_y);
Local<Object> o_maxLoc = Nan::New<Object>();
o_maxLoc->Set(Nan::New<String>("x").ToLocalChecked(), v_maxLoc_x);
o_maxLoc->Set(Nan::New<String>("y").ToLocalChecked(), v_maxLoc_y);
Nan::Set(o_maxLoc,Nan::New<String>("x").ToLocalChecked(), v_maxLoc_x);
Nan::Set(o_maxLoc,Nan::New<String>("y").ToLocalChecked(), v_maxLoc_y);
// Output result object
Local<Object> result = Nan::New<Object>();
result->Set(Nan::New<String>("minVal").ToLocalChecked(), v_minVal);
result->Set(Nan::New<String>("maxVal").ToLocalChecked(), v_maxVal);
result->Set(Nan::New<String>("minLoc").ToLocalChecked(), o_minLoc);
result->Set(Nan::New<String>("maxLoc").ToLocalChecked(), o_maxLoc);
Nan::Set(result,Nan::New<String>("minVal").ToLocalChecked(), v_minVal);
Nan::Set(result,Nan::New<String>("maxVal").ToLocalChecked(), v_maxVal);
Nan::Set(result,Nan::New<String>("minLoc").ToLocalChecked(), o_minLoc);
Nan::Set(result, Nan::New<String>("maxLoc").ToLocalChecked(), o_maxLoc);
info.GetReturnValue().Set(result);
}
@ -2913,10 +2927,10 @@ NAN_METHOD(Matrix::GetPerspectiveTransform) {
std::vector<cv::Point2f> src_corners(4);
std::vector<cv::Point2f> tgt_corners(4);
for (unsigned int i = 0; i < 4; i++) {
src_corners[i] = cvPoint(srcArray->Get(i*2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),srcArray->Get(i*2+1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),tgtArray->Get(i*2+1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
src_corners[i] = cvPoint(Nan::To<int32_t>( Nan::Get(srcArray,i*2).ToLocalChecked()).FromJust(), Nan::To<int32_t>( Nan::Get(srcArray,i*2+1).ToLocalChecked()).FromJust());
tgt_corners[i] = cvPoint(Nan::To<int32_t>( Nan::Get(tgtArray,i*2).ToLocalChecked()).FromJust(), Nan::To<int32_t>( Nan::Get(tgtArray,i*2+1).ToLocalChecked()).FromJust());
}
Local<Object> xfrm = Matrix::CreateWrappedFromMat(cv::getPerspectiveTransform(src_corners, tgt_corners));
info.GetReturnValue().Set(xfrm);
@ -2969,10 +2983,9 @@ NAN_METHOD(Matrix::SetWithMask) {
// param 0 - target value:
Local < Object > valArray = Nan::To<v8::Object>(info[0]).ToLocalChecked();
cv::Scalar newvals;
newvals.val[0] = valArray->Get(0).As<Number>()->Value();
newvals.val[1] = valArray->Get(1).As<Number>()->Value();
newvals.val[2] = valArray->Get(2).As<Number>()->Value();
newvals.val[0] = Nan::To<double>( Nan::Get(valArray,0).ToLocalChecked()).FromJust() ;
newvals.val[1] = Nan::To<double>( Nan::Get(valArray,1).ToLocalChecked()).FromJust() ;
newvals.val[2] = Nan::To<double>( Nan::Get(valArray,2).ToLocalChecked()).FromJust() ;
// param 1 - mask. same size as src and dest
Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
@ -2989,10 +3002,10 @@ NAN_METHOD(Matrix::MeanWithMask) {
cv::Scalar means = cv::mean(self->mat, mask->mat);
v8::Local < v8::Array > arr = Nan::New<Array>(4);
arr->Set(0, Nan::New<Number>(means[0]));
arr->Set(1, Nan::New<Number>(means[1]));
arr->Set(2, Nan::New<Number>(means[2]));
arr->Set(3, Nan::New<Number>(means[3]));
Nan::Set(arr, 0, Nan::New<Number>(means[0]));
Nan::Set(arr, 1, Nan::New<Number>(means[1]));
Nan::Set(arr, 2, Nan::New<Number>(means[2]));
Nan::Set(arr, 3, Nan::New<Number>(means[3]));
info.GetReturnValue().Set(arr);
}
@ -3002,10 +3015,10 @@ NAN_METHOD(Matrix::Mean) {
cv::Scalar means = cv::mean(self->mat);
v8::Local<v8::Array> arr = Nan::New<Array>(4);
arr->Set(0, Nan::New<Number>(means[0]));
arr->Set(1, Nan::New<Number>(means[1]));
arr->Set(2, Nan::New<Number>(means[2]));
arr->Set(3, Nan::New<Number>(means[3]));
Nan::Set(arr, 0, Nan::New<Number>(means[0]));
Nan::Set(arr, 1, Nan::New<Number>(means[1]));
Nan::Set(arr, 2, Nan::New<Number>(means[2]));
Nan::Set(arr, 3, Nan::New<Number>(means[3]));
info.GetReturnValue().Set(arr);
}
@ -3031,9 +3044,9 @@ NAN_METHOD(Matrix::CopyMakeBorder) {
v8::Local<v8::Array> objColor = v8::Local<v8::Array>::Cast(info[5]);
unsigned int length = objColor->Length();
Local<Value> valB = objColor->Get(0);
Local<Value> valG = objColor->Get(1);
Local<Value> valR = objColor->Get(2);
Local<Value> valB = Nan::Get(objColor,0).ToLocalChecked();
Local<Value> valG = Nan::Get(objColor,1).ToLocalChecked();
Local<Value> valR = Nan::Get(objColor,2).ToLocalChecked();
if (length == 3) {
value = cv::Scalar(
@ -3042,7 +3055,7 @@ NAN_METHOD(Matrix::CopyMakeBorder) {
valR->IntegerValue( Nan::GetCurrentContext() ).ToChecked()
);
} else if (length == 4) {
Local<Value> valA = objColor->Get(3);
Local<Value> valA = Nan::Get(objColor,3).ToLocalChecked();
value = cv::Scalar(
Nan::To<int>(valB).FromJust(),

4
src/OpenCV.cc
View File

@ -8,7 +8,7 @@ void OpenCV::Init(Local<Object> target) {
// Version string.
char out [21];
int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION);
target->Set(Nan::New<String>("version").ToLocalChecked(), Nan::New<String>(out, n).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New<String>("version").ToLocalChecked(), Nan::New<String>(out, n).ToLocalChecked());
Nan::SetMethod(target, "readImage", ReadImage);
Nan::SetMethod(target, "readImageAsync", ReadImageAsync);
@ -369,7 +369,7 @@ NAN_METHOD(OpenCV::ReadImageMulti) {
for (std::vector<cv::Mat>::size_type i = 0; i < mats.size(); i ++) {
Local<Object> im_h = Matrix::CreateWrappedFromMat(mats[i]);
output->Set(i, im_h);
output->Set(Nan::GetCurrentContext(), i, im_h);
}
Nan::TryCatch try_catch;

2
src/Point.cc
View File

@ -19,7 +19,7 @@ void Point::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "dot", Dot);
target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("Point").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
};
NAN_METHOD(Point::New) {

6
src/Stereo.cc
View File

@ -32,7 +32,7 @@ void StereoBM::Init(Local<Object> target) {
ctor->Set(Nan::New<String>("FISH_EYE_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::FISH_EYE_PRESET));
ctor->Set(Nan::New<String>("NARROW_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::NARROW_PRESET));
target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(),Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(StereoBM::New) {
@ -117,7 +117,7 @@ void StereoSGBM::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "compute", Compute);
target->Set(Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(StereoSGBM::New) {
@ -249,7 +249,7 @@ void StereoGC::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "compute", Compute);
target->Set(Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(),Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(StereoGC::New) {

2
src/VideoCaptureWrap.cc
View File

@ -48,7 +48,7 @@ void VideoCaptureWrap::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "grab", Grab);
Nan::SetPrototypeMethod(ctor, "retrieve", Retrieve);
target->Set(Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(VideoCaptureWrap::New) {

6
src/VideoWriterWrap.cc
View File

@ -34,7 +34,7 @@ void VideoWriterWrap::Init(Local<Object> target) {
Nan::SetPrototypeMethod(ctor, "writeSync", WriteSync);
Nan::SetPrototypeMethod(ctor, "release", Release);
target->Set(Nan::New("VideoWriter").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
target->Set(Nan::GetCurrentContext(), Nan::New("VideoWriter").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}
NAN_METHOD(VideoWriterWrap::New) {
@ -60,13 +60,13 @@ NAN_METHOD(VideoWriterWrap::New) {
cv::Size imageSize;
if (info[3]->IsArray()) {
Local<Object> v8sz = info[3]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
imageSize = cv::Size(v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
imageSize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
} else {
JSTHROW_TYPE("Must pass image size");
}
// Arg 4 is the color flag
bool isColor = info[4]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
bool isColor = info[4]->BooleanValue( v8::Isolate::GetCurrent() );
v = new VideoWriterWrap(filename, fourcc, fps, imageSize, isColor);
v->Wrap(info.This());

6
test/nativemat.cc
View File

@ -6,14 +6,14 @@ void Size(const Nan::FunctionCallbackInfo<v8::Value>& info) {
cv::Mat mat = Nan::ObjectWrap::Unwrap<node_opencv::Matrix>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->mat;
v8::Local < v8::Array > arr = Nan::New<v8::Array>(2);
arr->Set(0, Nan::New<v8::Number>(mat.size().height));
arr->Set(1, Nan::New<v8::Number>(mat.size().width));
arr->Set(Nan::GetCurrentContext(),0, Nan::New<v8::Number>(mat.size().height));
arr->Set(Nan::GetCurrentContext(),1, Nan::New<v8::Number>(mat.size().width));
info.GetReturnValue().Set(arr);
}
void Init(v8::Local<v8::Object> exports) {
exports->Set(Nan::New("size").ToLocalChecked(),
exports->Set(Nan::GetCurrentContext(), Nan::New("size").ToLocalChecked(),
Nan::New<v8::FunctionTemplate>(Size)->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
}