mirror of
https://github.com/peterbraden/node-opencv.git
synced 2025-12-08 19:45:55 +00:00
- finished converting Matrix.cc (preliminary pass)
* no compile error in nw-gyp v0.10.5
This commit is contained in:
Mark Moissette
parent
0a23d23636
commit
3bf2ee7fac
773
src/Matrix.cc
773
src/Matrix.cc
@ -1128,3 +1128,776 @@ NAN_METHOD(Matrix::DrawContour) {
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::DrawAllContours) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
Contour *cont = ObjectWrap::Unwrap<Contour>(args[0]->ToObject());
|
||||
|
||||
cv::Scalar color(0, 0, 255);
|
||||
|
||||
if(args[1]->IsArray()) {
|
||||
Local<Object> objColor = args[1]->ToObject();
|
||||
color = setColor(objColor);
|
||||
}
|
||||
|
||||
int thickness = args.Length() < 3 ? 1 : args[2]->NumberValue();
|
||||
|
||||
cv::drawContours(self->mat, cont->contours, -1, color, thickness);
|
||||
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::GoodFeaturesToTrack) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
std::vector<cv::Point2f> corners;
|
||||
|
||||
cv::Mat gray;
|
||||
|
||||
cvtColor(self->mat, gray, CV_BGR2GRAY);
|
||||
equalizeHist(gray, gray);
|
||||
|
||||
cv::goodFeaturesToTrack(gray, corners, 500, 0.01, 10);
|
||||
|
||||
v8::Local<v8::Array> arr = NanNew<Array>(corners.size());
|
||||
|
||||
|
||||
for (unsigned int i=0; i<corners.size(); i++){
|
||||
v8::Local<v8::Array> pt = NanNew<Array>(2);
|
||||
pt->Set(0, NanNew<Number>((double) corners[i].x));
|
||||
pt->Set(1, NanNew<Number>((double) corners[i].y));
|
||||
arr->Set(i, pt);
|
||||
}
|
||||
|
||||
NanReturnValue(arr);
|
||||
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::HoughLinesP) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
double rho = args.Length() < 1 ? 1 : args[0]->NumberValue();
|
||||
double theta = args.Length() < 2 ? CV_PI/180 : args[1]->NumberValue();
|
||||
int threshold = args.Length() < 3 ? 80 : args[2]->Uint32Value();
|
||||
double minLineLength = args.Length() < 4 ? 30 : args[3]->NumberValue();
|
||||
double maxLineGap = args.Length() < 5 ? 10 : args[4]->NumberValue();
|
||||
std::vector<cv::Vec4i> lines;
|
||||
|
||||
cv::Mat gray;
|
||||
|
||||
|
||||
equalizeHist(self->mat, gray);
|
||||
// cv::Canny(gray, gray, 50, 200, 3);
|
||||
cv::HoughLinesP(gray, lines, rho, theta, threshold, minLineLength, maxLineGap);
|
||||
|
||||
v8::Local<v8::Array> arr = NanNew<Array>(lines.size());
|
||||
|
||||
|
||||
for (unsigned int i=0; i<lines.size(); i++){
|
||||
v8::Local<v8::Array> pt = NanNew<Array>(4);
|
||||
pt->Set(0, NanNew<Number>((double) lines[i][0]));
|
||||
pt->Set(1, NanNew<Number>((double) lines[i][1]));
|
||||
pt->Set(2, NanNew<Number>((double) lines[i][2]));
|
||||
pt->Set(3, NanNew<Number>((double) lines[i][3]));
|
||||
arr->Set(i, pt);
|
||||
}
|
||||
|
||||
NanReturnValue(arr);
|
||||
|
||||
}
|
||||
|
||||
cv::Scalar setColor(Local<Object> objColor) {
|
||||
|
||||
Local<Value> valB = objColor->Get(0);
|
||||
Local<Value> valG = objColor->Get(1);
|
||||
Local<Value> valR = objColor->Get(2);
|
||||
|
||||
cv::Scalar color = cv::Scalar(valB->IntegerValue(), valG->IntegerValue(), valR->IntegerValue());
|
||||
return color;
|
||||
|
||||
|
||||
}
|
||||
|
||||
cv::Point setPoint(Local<Object> objPoint) {
|
||||
return cv::Point( objPoint->Get(0)->IntegerValue(), objPoint->Get(1)->IntegerValue() );
|
||||
}
|
||||
|
||||
cv::Rect* setRect(Local<Object> objRect) {
|
||||
|
||||
if(!objRect->IsArray() || !objRect->Get(0)->IsArray() || !objRect->Get(0)->IsArray() ){
|
||||
printf("error");
|
||||
return 0;
|
||||
};
|
||||
|
||||
Local<Object> point = objRect->Get(0)->ToObject();
|
||||
Local<Object> size = objRect->Get(1)->ToObject();
|
||||
cv::Rect ret;
|
||||
|
||||
ret.x = point->Get(0)->IntegerValue();
|
||||
ret.y = point->Get(1)->IntegerValue();
|
||||
ret.width = size->Get(0)->IntegerValue();
|
||||
ret.height = size->Get(1)->IntegerValue();
|
||||
|
||||
return (cv::Rect*) &ret;
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::Resize){
|
||||
NanScope();
|
||||
|
||||
int x = args[0]->Uint32Value();
|
||||
int y = args[1]->Uint32Value();
|
||||
/*
|
||||
CV_INTER_NN =0,
|
||||
CV_INTER_LINEAR =1,
|
||||
CV_INTER_CUBIC =2,
|
||||
CV_INTER_AREA =3,
|
||||
CV_INTER_LANCZOS4 =4
|
||||
*/
|
||||
int interpolation = (args.Length() < 3) ? (int)cv::INTER_LINEAR : args[2]->Uint32Value();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
cv::Mat res = cv::Mat(x, y, CV_32FC3);
|
||||
cv::resize(self->mat, res, cv::Size(x, y), 0, 0, interpolation);
|
||||
~self->mat;
|
||||
self->mat = res;
|
||||
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::Rotate){
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
cv::Mat rotMatrix(2, 3, CV_32FC1);
|
||||
cv::Mat res;
|
||||
|
||||
float angle = args[0]->ToNumber()->Value();
|
||||
|
||||
// Modification by SergeMv
|
||||
//-------------
|
||||
// If you provide only the angle argument and the angle is multiple of 90, then
|
||||
// we do a fast thing
|
||||
bool rightOrStraight = (ceil(angle) == angle) && (!((int)angle % 90))
|
||||
&& (args.Length() == 1);
|
||||
if (rightOrStraight) {
|
||||
int angle2 = ((int)angle) % 360;
|
||||
if (!angle2) { NanReturnUndefined(); }
|
||||
if (angle2 < 0) { angle2 += 360; }
|
||||
// See if we do right angle rotation, we transpose the matrix:
|
||||
if (angle2 % 180) {
|
||||
cv::transpose(self->mat, res);
|
||||
~self->mat;
|
||||
self->mat = res;
|
||||
}
|
||||
// Now flip the image
|
||||
int mode = -1; // flip around both axes
|
||||
// If counterclockwise, flip around the x-axis
|
||||
if (angle2 == 90) { mode = 0; }
|
||||
// If clockwise, flip around the y-axis
|
||||
if (angle2 == 270) { mode = 1; }
|
||||
cv::flip(self->mat, self->mat, mode);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
//-------------
|
||||
|
||||
int x = args[1]->IsUndefined() ? round(self->mat.size().width / 2) : args[1]->Uint32Value();
|
||||
int y = args[1]->IsUndefined() ? round(self->mat.size().height / 2) : args[2]->Uint32Value();
|
||||
|
||||
cv::Point center = cv::Point(x,y);
|
||||
rotMatrix = getRotationMatrix2D(center, angle, 1.0);
|
||||
|
||||
cv::warpAffine(self->mat, res, rotMatrix, self->mat.size());
|
||||
~self->mat;
|
||||
self->mat = res;
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::PyrDown){
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
cv::pyrDown(self->mat, self->mat);
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::PyrUp){
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
cv::pyrUp(self->mat, self->mat);
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::inRange) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
/*if(self->mat.channels() != 3)
|
||||
NanThrowError(String::New("Image is no 3-channel"));*/
|
||||
|
||||
if(args[0]->IsArray() && args[1]->IsArray()) {
|
||||
Local<Object> args_lowerb = args[0]->ToObject();
|
||||
Local<Object> args_upperb = args[1]->ToObject();
|
||||
|
||||
cv::Scalar lowerb(0, 0, 0);
|
||||
cv::Scalar upperb(0, 0, 0);
|
||||
|
||||
lowerb = setColor(args_lowerb);
|
||||
upperb = setColor(args_upperb);
|
||||
|
||||
cv::Mat mask;
|
||||
cv::inRange(self->mat, lowerb, upperb, mask);
|
||||
mask.copyTo(self->mat);
|
||||
}
|
||||
|
||||
|
||||
NanReturnNull();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::AdjustROI) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
int dtop = args[0]->Uint32Value();
|
||||
int dbottom = args[1]->Uint32Value();
|
||||
int dleft = args[2]->Uint32Value();
|
||||
int dright = args[3]->Uint32Value();
|
||||
|
||||
self->mat.adjustROI(dtop, dbottom, dleft, dright);
|
||||
|
||||
NanReturnNull();
|
||||
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::LocateROI) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
cv::Size wholeSize;
|
||||
cv::Point ofs;
|
||||
|
||||
self->mat.locateROI(wholeSize, ofs);
|
||||
|
||||
v8::Local<v8::Array> arr = NanNew<Array>(4);
|
||||
arr->Set(0, NanNew<Number>(wholeSize.width));
|
||||
arr->Set(1, NanNew<Number>(wholeSize.height));
|
||||
arr->Set(2, NanNew<Number>(ofs.x));
|
||||
arr->Set(3, NanNew<Number>(ofs.y));
|
||||
|
||||
NanReturnValue(arr);
|
||||
}
|
||||
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::Threshold) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
double threshold = args[0]->NumberValue();
|
||||
double maxVal = args[1]->NumberValue();
|
||||
|
||||
int typ = cv::THRESH_BINARY;
|
||||
if (args.Length() == 3){
|
||||
// typ = args[2]->IntegerValue();
|
||||
NanAsciiString typstr(args[2]);
|
||||
if (strcmp(*typstr, "Binary") == 0){
|
||||
typ=0;
|
||||
}
|
||||
if (strcmp(*typstr, "Binary Inverted") == 0){
|
||||
typ=1;
|
||||
}
|
||||
if (strcmp(*typstr, "Threshold Truncated") == 0){
|
||||
typ=2;
|
||||
}
|
||||
if (strcmp(*typstr, "Threshold to Zero") == 0){
|
||||
typ=3;
|
||||
}
|
||||
if (strcmp(*typstr, "Threshold to Zero Inverted") == 0){
|
||||
typ=4;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Local<Object> img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
|
||||
self->mat.copyTo(img->mat);
|
||||
|
||||
cv::threshold(self->mat, img->mat, threshold, maxVal, typ);
|
||||
|
||||
NanReturnValue(img_to_return);
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::AdaptiveThreshold) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
double maxVal = args[0]->NumberValue();
|
||||
double adaptiveMethod = args[1]->NumberValue();
|
||||
double thresholdType = args[2]->NumberValue();
|
||||
double blockSize = args[3]->NumberValue();
|
||||
double C = args[4]->NumberValue();
|
||||
|
||||
Local<Object> img_to_return = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix *img = ObjectWrap::Unwrap<Matrix>(img_to_return);
|
||||
self->mat.copyTo(img->mat);
|
||||
|
||||
cv::adaptiveThreshold(self->mat, img->mat, maxVal, adaptiveMethod, thresholdType, blockSize, C);
|
||||
|
||||
NanReturnValue(img_to_return);
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::MeanStdDev) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
Local<Object> mean = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix *m_mean = ObjectWrap::Unwrap<Matrix>(mean);
|
||||
Local<Object> stddev = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix *m_stddev = ObjectWrap::Unwrap<Matrix>(stddev);
|
||||
|
||||
cv::meanStdDev(self->mat, m_mean->mat, m_stddev->mat);
|
||||
|
||||
Local<Object> data = NanNew<Object>();
|
||||
data->Set(NanNew<String>("mean"), mean);
|
||||
data->Set(NanNew<String>("stddev"), stddev);
|
||||
NanReturnValue(data);
|
||||
}
|
||||
|
||||
|
||||
// @author SergeMv
|
||||
// Copies our (small) image into a ROI of another (big) image
|
||||
// @param Object another image (destination)
|
||||
// @param Number Destination x (where our image is to be copied)
|
||||
// @param Number Destination y (where our image is to be copied)
|
||||
// Example: smallImg.copyTo(bigImg, 50, 50);
|
||||
// Note, x,y and width and height of our image must be so that
|
||||
// our.width + x <= destination.width (and the same for y and height)
|
||||
// both x and y must be >= 0
|
||||
NAN_METHOD(Matrix::CopyTo) {
|
||||
NanScope();
|
||||
|
||||
Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
int width = self->mat.size().width;
|
||||
int height = self->mat.size().height;
|
||||
|
||||
// param 0 - destination image:
|
||||
Matrix *dest = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
|
||||
// param 1 - x coord of the destination
|
||||
int x = args[1]->IntegerValue();
|
||||
// param 2 - y coord of the destination
|
||||
int y = args[2]->IntegerValue();
|
||||
|
||||
cv::Mat dstROI = cv::Mat(dest->mat, cv::Rect(x, y, width, height));
|
||||
self->mat.copyTo(dstROI);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
|
||||
// @author SergeMv
|
||||
// Does in-place color transformation
|
||||
// img.cvtColor('CV_BGR2YCrCb');
|
||||
NAN_METHOD(Matrix::CvtColor) {
|
||||
NanScope();
|
||||
|
||||
Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
v8::String::Utf8Value str (args[0]->ToString());
|
||||
std::string str2 = std::string(*str);
|
||||
const char * sTransform = (const char *) str2.c_str();
|
||||
int iTransform;
|
||||
//
|
||||
if (!strcmp(sTransform, "CV_BGR2GRAY")) { iTransform = CV_BGR2GRAY; }
|
||||
else if (!strcmp(sTransform, "CV_GRAY2BGR")) { iTransform = CV_GRAY2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BGR2XYZ")) { iTransform = CV_BGR2XYZ; }
|
||||
else if (!strcmp(sTransform, "CV_XYZ2BGR")) { iTransform = CV_XYZ2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BGR2YCrCb")) { iTransform = CV_BGR2YCrCb; }
|
||||
else if (!strcmp(sTransform, "CV_YCrCb2BGR")) { iTransform = CV_YCrCb2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BGR2HSV")) { iTransform = CV_BGR2HSV; }
|
||||
else if (!strcmp(sTransform, "CV_HSV2BGR")) { iTransform = CV_HSV2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BGR2HLS")) { iTransform = CV_BGR2HLS; }
|
||||
else if (!strcmp(sTransform, "CV_HLS2BGR")) { iTransform = CV_HLS2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BGR2Lab")) { iTransform = CV_BGR2Lab; }
|
||||
else if (!strcmp(sTransform, "CV_Lab2BGR")) { iTransform = CV_Lab2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BGR2Luv")) { iTransform = CV_BGR2Luv; }
|
||||
else if (!strcmp(sTransform, "CV_Luv2BGR")) { iTransform = CV_Luv2BGR; }
|
||||
//
|
||||
else if (!strcmp(sTransform, "CV_BayerBG2BGR")) { iTransform = CV_BayerBG2BGR; }
|
||||
else if (!strcmp(sTransform, "CV_BayerGB2BGR")) { iTransform = CV_BayerGB2BGR; }
|
||||
else if (!strcmp(sTransform, "CV_BayerRG2BGR")) { iTransform = CV_BayerRG2BGR; }
|
||||
else if (!strcmp(sTransform, "CV_BayerGR2BGR")) { iTransform = CV_BayerGR2BGR; }
|
||||
else {
|
||||
iTransform = 0; // to avoid compiler warning
|
||||
NanThrowTypeError("Conversion code is unsupported");
|
||||
}
|
||||
|
||||
cv::cvtColor(self->mat, self->mat, iTransform);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
// @author SergeMv
|
||||
// arrChannels = img.split();
|
||||
NAN_METHOD(Matrix::Split) {
|
||||
NanScope();
|
||||
|
||||
Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
vector<cv::Mat> channels;
|
||||
cv::split(self->mat, channels);
|
||||
unsigned int size = channels.size();
|
||||
v8::Local<v8::Array> arrChannels = NanNew<Array>(size);
|
||||
for (unsigned int i = 0; i < size; i++) {
|
||||
Local<Object> matObject = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix * m = ObjectWrap::Unwrap<Matrix>(matObject);
|
||||
m->mat = channels[i];
|
||||
arrChannels->Set(i, matObject);
|
||||
}
|
||||
|
||||
NanReturnValue(arrChannels);
|
||||
}
|
||||
|
||||
|
||||
// @author SergeMv
|
||||
// img.merge(arrChannels);
|
||||
NAN_METHOD(Matrix::Merge) {
|
||||
NanScope();
|
||||
|
||||
Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
if (!args[0]->IsArray()) {
|
||||
NanThrowTypeError("The argument must be an array");
|
||||
}
|
||||
v8::Handle<v8::Array> jsChannels = v8::Handle<v8::Array>::Cast(args[0]);
|
||||
|
||||
unsigned int L = jsChannels->Length();
|
||||
vector<cv::Mat> vChannels(L);
|
||||
for (unsigned int i = 0; i < L; i++) {
|
||||
Matrix * matObject = ObjectWrap::Unwrap<Matrix>(jsChannels->Get(i)->ToObject());
|
||||
vChannels[i] = matObject->mat;
|
||||
}
|
||||
cv::merge(vChannels, self->mat);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
// @author SergeMv
|
||||
// Equalizes histogram
|
||||
// img.equalizeHist()
|
||||
NAN_METHOD(Matrix::EqualizeHist) {
|
||||
NanScope();
|
||||
|
||||
Matrix * self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
cv::equalizeHist(self->mat, self->mat);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::FloodFill){
|
||||
SETUP_FUNCTION(Matrix)
|
||||
//obj->Get(NanNew<String>("x"))
|
||||
//int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int)
|
||||
|
||||
|
||||
/* mat.floodFill( { seedPoint: [1,1] ,
|
||||
newColor: [255,0,0] ,
|
||||
rect:[[0,2],[30,40]] ,
|
||||
loDiff : [8,90,60],
|
||||
upDiff:[10,100,70]
|
||||
} );*/
|
||||
|
||||
|
||||
if(args.Length() < 1 || !args[0]->IsObject()) {
|
||||
//error
|
||||
}
|
||||
|
||||
|
||||
Local<Object> obj = args[0]->ToObject();
|
||||
|
||||
int ret = cv::floodFill(self->mat, setPoint(obj->Get(NanNew<String>("seedPoint"))->ToObject())
|
||||
, setColor(obj->Get(NanNew<String>("newColor"))->ToObject())
|
||||
, obj->Get(NanNew<String>("rect"))->IsUndefined() ? 0 : setRect(obj->Get(NanNew<String>("rect"))->ToObject())
|
||||
, setColor(obj->Get(NanNew<String>("loDiff"))->ToObject())
|
||||
, setColor(obj->Get(NanNew<String>("upDiff"))->ToObject())
|
||||
, 4 );
|
||||
|
||||
|
||||
NanReturnValue(NanNew<Number>( ret ));
|
||||
}
|
||||
|
||||
|
||||
// @author ytham
|
||||
// Match Template filter
|
||||
// Usage: output = input.matchTemplate("templateFileString", method);
|
||||
NAN_METHOD(Matrix::MatchTemplate) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
v8::String::Utf8Value args0(args[0]->ToString());
|
||||
std::string filename = std::string(*args0);
|
||||
cv::Mat templ;
|
||||
templ = cv::imread(filename, CV_8S);
|
||||
|
||||
Local<Object> out = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix *m_out = ObjectWrap::Unwrap<Matrix>(out);
|
||||
int cols = self->mat.cols - templ.cols + 1;
|
||||
int rows = self->mat.rows - templ.rows + 1;
|
||||
m_out->mat.create(cols, rows, CV_32FC1);
|
||||
|
||||
/*
|
||||
TM_SQDIFF =0
|
||||
TM_SQDIFF_NORMED =1
|
||||
TM_CCORR =2
|
||||
TM_CCORR_NORMED =3
|
||||
TM_CCOEFF =4
|
||||
TM_CCOEFF_NORMED =5
|
||||
*/
|
||||
int method = (args.Length() < 2) ? (int)cv::TM_CCORR_NORMED : args[1]->Uint32Value();
|
||||
|
||||
cv::matchTemplate(self->mat, templ, m_out->mat, method);
|
||||
|
||||
double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc;
|
||||
cv::minMaxLoc(m_out->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() );
|
||||
|
||||
NanReturnValue(out);
|
||||
}
|
||||
|
||||
|
||||
// @author ytham
|
||||
// Min/Max location
|
||||
NAN_METHOD(Matrix::MinMaxLoc) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
double minVal; double maxVal; cv::Point minLoc; cv::Point maxLoc;
|
||||
|
||||
cv::minMaxLoc(self->mat, &minVal, &maxVal, &minLoc, &maxLoc, cv::Mat() );
|
||||
|
||||
Local<Value> v_minVal = NanNew<Number>(minVal);
|
||||
Local<Value> v_maxVal = NanNew<Number>(maxVal);
|
||||
Local<Value> v_minLoc_x = NanNew<Number>(minLoc.x);
|
||||
Local<Value> v_minLoc_y = NanNew<Number>(minLoc.y);
|
||||
Local<Value> v_maxLoc_x = NanNew<Number>(maxLoc.x);
|
||||
Local<Value> v_maxLoc_y = NanNew<Number>(maxLoc.y);
|
||||
|
||||
Local<Object> o_minLoc = NanNew<Object>();
|
||||
o_minLoc->Set(NanNew<String>("x"), v_minLoc_x);
|
||||
o_minLoc->Set(NanNew<String>("y"), v_minLoc_y);
|
||||
|
||||
Local<Object> o_maxLoc = NanNew<Object>();
|
||||
o_maxLoc->Set(NanNew<String>("x"), v_maxLoc_x);
|
||||
o_maxLoc->Set(NanNew<String>("y"), v_maxLoc_y);
|
||||
|
||||
// Output result object
|
||||
Local<Object> result = NanNew<Object>();
|
||||
result->Set(NanNew<String>("minVal"), v_minVal);
|
||||
result->Set(NanNew<String>("maxVal"), v_maxVal);
|
||||
result->Set(NanNew<String>("minLoc"), o_minLoc);
|
||||
result->Set(NanNew<String>("maxLoc"), o_maxLoc);
|
||||
|
||||
NanReturnValue(result);
|
||||
}
|
||||
|
||||
|
||||
// @author ytham
|
||||
// Pushes some matrix (argument) the back of a matrix (self)
|
||||
NAN_METHOD(Matrix::PushBack) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
Matrix *m_input = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
|
||||
|
||||
self->mat.push_back(m_input->mat);
|
||||
|
||||
NanReturnValue(args.This());
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::PutText) {
|
||||
NanScope();
|
||||
|
||||
Matrix *self = ObjectWrap::Unwrap<Matrix>(args.This());
|
||||
|
||||
NanAsciiString textString(args[0]);//FIXME: might cause issues, see here https://github.com/rvagg/nan/pull/152
|
||||
char *text = *textString; //(char *) malloc(textString.length() + 1);
|
||||
//strcpy(text, *textString);
|
||||
|
||||
int x = args[1]->IntegerValue();
|
||||
int y = args[2]->IntegerValue();
|
||||
|
||||
NanAsciiString fontString(args[3]);
|
||||
char *font = *fontString;//(char *) malloc(fontString.length() + 1);
|
||||
//strcpy(font, *fontString);
|
||||
int constFont = cv::FONT_HERSHEY_SIMPLEX;
|
||||
|
||||
if (!strcmp(font, "HERSEY_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SIMPLEX; }
|
||||
else if (!strcmp(font, "HERSEY_PLAIN")) { constFont = cv::FONT_HERSHEY_PLAIN; }
|
||||
else if (!strcmp(font, "HERSEY_DUPLEX")) { constFont = cv::FONT_HERSHEY_DUPLEX; }
|
||||
else if (!strcmp(font, "HERSEY_COMPLEX")) { constFont = cv::FONT_HERSHEY_COMPLEX; }
|
||||
else if (!strcmp(font, "HERSEY_TRIPLEX")) { constFont = cv::FONT_HERSHEY_TRIPLEX; }
|
||||
else if (!strcmp(font, "HERSEY_COMPLEX_SMALL")) { constFont = cv::FONT_HERSHEY_COMPLEX_SMALL; }
|
||||
else if (!strcmp(font, "HERSEY_SCRIPT_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_SIMPLEX; }
|
||||
else if (!strcmp(font, "HERSEY_SCRIPT_COMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_COMPLEX; }
|
||||
else if (!strcmp(font, "HERSEY_SCRIPT_SIMPLEX")) { constFont = cv::FONT_HERSHEY_SCRIPT_SIMPLEX; }
|
||||
|
||||
cv::Scalar color(0, 0, 255);
|
||||
|
||||
if(args[4]->IsArray()) {
|
||||
Local<Object> objColor = args[4]->ToObject();
|
||||
color = setColor(objColor);
|
||||
}
|
||||
|
||||
double scale = args.Length() < 6 ? 1 : args[5]->NumberValue();
|
||||
|
||||
cv::putText(self->mat, text, cv::Point(x, y), constFont, scale, color, 2);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::GetPerspectiveTransform) {
|
||||
NanScope();
|
||||
|
||||
// extract quad args
|
||||
Local<Object> srcArray = args[0]->ToObject();
|
||||
Local<Object> tgtArray = args[1]->ToObject();
|
||||
|
||||
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(),srcArray->Get(i*2+1)->IntegerValue());
|
||||
tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue(),tgtArray->Get(i*2+1)->IntegerValue());
|
||||
}
|
||||
|
||||
Local<Object> xfrm = NanNew(Matrix::constructor)->GetFunction()->NewInstance();
|
||||
Matrix *xfrmmat = ObjectWrap::Unwrap<Matrix>(xfrm);
|
||||
xfrmmat->mat = cv::getPerspectiveTransform(src_corners, tgt_corners);
|
||||
|
||||
NanReturnValue(xfrm);
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::WarpPerspective) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
Matrix *xfrm = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
|
||||
|
||||
int width = args[1]->IntegerValue();
|
||||
int height = args[2]->IntegerValue();
|
||||
|
||||
int flags = cv::INTER_LINEAR;
|
||||
int borderMode = cv::BORDER_REPLICATE;
|
||||
|
||||
cv::Scalar borderColor(0, 0, 255);
|
||||
|
||||
if(args[3]->IsArray()) {
|
||||
Local<Object> objColor = args[3]->ToObject();
|
||||
borderColor = setColor(objColor);
|
||||
}
|
||||
|
||||
cv::Mat res = cv::Mat(width, height, CV_32FC3);
|
||||
|
||||
cv::warpPerspective(self->mat, res, xfrm->mat, cv::Size(width, height), flags, borderMode, borderColor);
|
||||
|
||||
~self->mat;
|
||||
self->mat = res;
|
||||
|
||||
NanReturnNull();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::CopyWithMask) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
// param 0 - destination image:
|
||||
Matrix *dest = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
|
||||
// param 1 - mask. same size as src and dest
|
||||
Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
|
||||
|
||||
self->mat.copyTo(dest->mat,mask->mat);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
|
||||
NAN_METHOD(Matrix::SetWithMask) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
// param 0 - target value:
|
||||
Local<Object> valArray = args[0]->ToObject();
|
||||
cv::Scalar newvals;
|
||||
newvals.val[0] = valArray->Get(0)->NumberValue();
|
||||
newvals.val[1] = valArray->Get(1)->NumberValue();
|
||||
newvals.val[2] = valArray->Get(2)->NumberValue();
|
||||
|
||||
// param 1 - mask. same size as src and dest
|
||||
Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[1]->ToObject());
|
||||
|
||||
self->mat.setTo(newvals,mask->mat);
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::MeanWithMask) {
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
// param 0 - mask. same size as src and dest
|
||||
Matrix *mask = ObjectWrap::Unwrap<Matrix>(args[0]->ToObject());
|
||||
|
||||
cv::Scalar means = cv::mean(self->mat, mask->mat);
|
||||
v8::Local<v8::Array> arr = NanNew<Array>(3);
|
||||
arr->Set(0, NanNew<Number>( means[0] ));
|
||||
arr->Set(1, NanNew<Number>( means[1] ));
|
||||
arr->Set(2, NanNew<Number>( means[2] ));
|
||||
|
||||
NanReturnValue(arr);
|
||||
}
|
||||
|
||||
NAN_METHOD(Matrix::Shift){
|
||||
SETUP_FUNCTION(Matrix)
|
||||
|
||||
cv::Mat res;
|
||||
|
||||
double tx = args[0]->NumberValue();
|
||||
double ty = args[1]->NumberValue();
|
||||
|
||||
// get the integer values of args
|
||||
cv::Point2i deltai(ceil(tx), ceil(ty));
|
||||
|
||||
int fill=cv::BORDER_REPLICATE;
|
||||
cv::Scalar value=cv::Scalar(0,0,0,0);
|
||||
|
||||
// INTEGER SHIFT
|
||||
// first create a border around the parts of the Mat that will be exposed
|
||||
int t = 0, b = 0, l = 0, r = 0;
|
||||
if (deltai.x > 0) l = deltai.x;
|
||||
if (deltai.x < 0) r = -deltai.x;
|
||||
if (deltai.y > 0) t = deltai.y;
|
||||
if (deltai.y < 0) b = -deltai.y;
|
||||
cv::Mat padded;
|
||||
cv::copyMakeBorder(self->mat, padded, t, b, l, r, fill, value);
|
||||
|
||||
// construct the region of interest around the new matrix
|
||||
cv::Rect roi = cv::Rect(std::max(-deltai.x,0),std::max(-deltai.y,0),0,0) + self->mat.size();
|
||||
res = padded(roi);
|
||||
~self->mat;
|
||||
self->mat = res;
|
||||
|
||||
NanReturnUndefined();
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user