From 1341a83a7ac4693800801d65855597013031814b Mon Sep 17 00:00:00 2001 From: Oskar Dahlberg Date: Mon, 22 Sep 2014 14:40:39 +0200 Subject: [PATCH 1/3] Added hierarchy to Contours --- src/Contours.cc | 21 ++++++++++++++++++++- src/Contours.h | 5 ++++- src/Matrix.cc | 24 ++++++++++++++---------- 3 files changed, 38 insertions(+), 12 deletions(-) diff --git a/src/Contours.cc b/src/Contours.cc index b2f8d04..8b1431c 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -33,7 +33,8 @@ Contour::Init(Handle target) { NODE_SET_PROTOTYPE_METHOD(constructor, "boundingRect", BoundingRect); NODE_SET_PROTOTYPE_METHOD(constructor, "minAreaRect", MinAreaRect); NODE_SET_PROTOTYPE_METHOD(constructor, "isConvex", IsConvex); - NODE_SET_PROTOTYPE_METHOD(constructor, "moments", Moments); + NODE_SET_PROTOTYPE_METHOD(constructor, "moments", Moments); + NODE_SET_PROTOTYPE_METHOD(constructor, "hierarchy", Hierarchy); target->Set(String::NewSymbol("Contours"), m->GetFunction()); }; @@ -242,3 +243,21 @@ Contour::Moments(const Arguments &args) { return scope.Close(res); } +Handle +Contour::Hierarchy(const Arguments &args) { + HandleScope scope; + + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->IntegerValue(); + + cv::Vec4i hierarchy = self->hierarchy[pos]; + + Local res = Array::New(4); + + res->Set(0, Number::New(hierarchy[0])); + res->Set(1, Number::New(hierarchy[1])); + res->Set(2, Number::New(hierarchy[2])); + res->Set(3, Number::New(hierarchy[3])); + + return scope.Close(res); +} \ No newline at end of file diff --git a/src/Contours.h b/src/Contours.h index e84c005..059316f 100755 --- a/src/Contours.h +++ b/src/Contours.h @@ -7,7 +7,9 @@ class Contour: public node::ObjectWrap { cv::Mat mat; vector > contours; - static Persistent constructor; + vector hierarchy; + + static Persistent constructor; static void Init(Handle target); static Handle New(const Arguments &args); @@ -25,5 +27,6 @@ class Contour: public node::ObjectWrap { static Handle MinAreaRect(const v8::Arguments&); static Handle IsConvex(const v8::Arguments&); static Handle Moments(const v8::Arguments&); + static Handle Hierarchy(const v8::Arguments&); }; diff --git a/src/Matrix.cc b/src/Matrix.cc index 8dfc669..e278418 100755 --- a/src/Matrix.cc +++ b/src/Matrix.cc @@ -8,8 +8,6 @@ cv::Scalar setColor(Local objColor); cv::Point setPoint(Local objPoint); cv::Rect* setRect(Local objRect); -// - void Matrix::Init(Handle target) { HandleScope scope; @@ -1149,23 +1147,29 @@ Matrix::Erode(const v8::Arguments& args) { return scope.Close(v8::Null()); } - Handle Matrix::FindContours(const v8::Arguments& args) { - HandleScope scope; + SETUP_FUNCTION(Matrix) - Matrix *self = ObjectWrap::Unwrap(args.This()); + int mode = CV_RETR_LIST; + int chain = CV_CHAIN_APPROX_SIMPLE; - Local conts_to_return= Contour::constructor->GetFunction()->NewInstance(); - Contour *contours = ObjectWrap::Unwrap(conts_to_return); + if (args.Length() > 0) { + if (args[0]->IsNumber()) mode = args[0]->IntegerValue(); + } - cv::findContours(self->mat, contours->contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE); + if (args.Length() > 1) { + if (args[1]->IsNumber()) chain = args[1]->IntegerValue(); + } - return scope.Close(conts_to_return); + Local conts_to_return = Contour::constructor->GetFunction()->NewInstance(); + Contour *contours = ObjectWrap::Unwrap(conts_to_return); + cv::findContours(self->mat, contours->contours, contours->hierarchy, mode, chain); + + return scope.Close(conts_to_return); } - Handle Matrix::DrawContour(const v8::Arguments& args) { HandleScope scope; From d9af0e7ee478dd6395c4993380cd836eebd31906 Mon Sep 17 00:00:00 2001 From: Oskar Dahlberg Date: Mon, 22 Sep 2014 14:50:11 +0200 Subject: [PATCH 2/3] New methods for easier access of contour data --- src/Contours.cc | 115 +++++++++++++++++++++++++++++++++++++++++++++++- src/Contours.h | 9 ++-- 2 files changed, 120 insertions(+), 4 deletions(-) diff --git a/src/Contours.cc b/src/Contours.cc index 8b1431c..dcc5b31 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -23,7 +23,8 @@ Contour::Init(Handle target) { //Local proto = constructor->PrototypeTemplate(); - NODE_SET_PROTOTYPE_METHOD(constructor, "point", Point); + NODE_SET_PROTOTYPE_METHOD(constructor, "point", Point); + NODE_SET_PROTOTYPE_METHOD(constructor, "points", Points); NODE_SET_PROTOTYPE_METHOD(constructor, "size", Size); NODE_SET_PROTOTYPE_METHOD(constructor, "cornerCount", CornerCount); NODE_SET_PROTOTYPE_METHOD(constructor, "area", Area); @@ -35,6 +36,8 @@ Contour::Init(Handle target) { NODE_SET_PROTOTYPE_METHOD(constructor, "isConvex", IsConvex); NODE_SET_PROTOTYPE_METHOD(constructor, "moments", Moments); NODE_SET_PROTOTYPE_METHOD(constructor, "hierarchy", Hierarchy); + NODE_SET_PROTOTYPE_METHOD(constructor, "serialize", Serialize); + NODE_SET_PROTOTYPE_METHOD(constructor, "deserialize", Deserialize); target->Set(String::NewSymbol("Contours"), m->GetFunction()); }; @@ -75,6 +78,28 @@ Contour::Point(const Arguments &args) { return scope.Close(data); } +Handle +Contour::Points(const Arguments &args) { + HandleScope scope; + + Contour *self = ObjectWrap::Unwrap(args.This()); + int pos = args[0]->NumberValue(); + + vector points = self->contours[pos]; + + Local data = Array::New(points.size()); + + for (std::vector::size_type i = 0; i != points.size(); i++) { + Local point_data = Object::New(); + point_data->Set(String::NewSymbol("x"), Number::New(points[i].x)); + point_data->Set(String::NewSymbol("y"), Number::New(points[i].y)); + + data->Set(i, point_data); + } + + return scope.Close(data); +} + // FIXME: this sould better be called "Length" as ``Contours`` is an Array like structure // also, this would allow to use ``Size`` for the function returning the number of corners // in the contour for better consistency with OpenCV. @@ -260,4 +285,92 @@ Contour::Hierarchy(const Arguments &args) { res->Set(3, Number::New(hierarchy[3])); return scope.Close(res); +} + +Handle +Contour::Serialize(const Arguments &args) { + HandleScope scope; + + Contour *self = ObjectWrap::Unwrap(args.This()); + + Local contours_data = Array::New(self->contours.size()); + + for (std::vector::size_type i = 0; i != self->contours.size(); i++) { + vector points = self->contours[i]; + Local contour_data = Array::New(points.size()); + + for (std::vector::size_type j = 0; j != points.size(); j++) { + Local point_data = Array::New(2); + point_data->Set(0, Number::New(points[j].x)); + point_data->Set(1, Number::New(points[j].y)); + + contour_data->Set(j, point_data); + } + + contours_data->Set(i, contour_data); + } + + Local hierarchy_data = Array::New(self->hierarchy.size()); + for (std::vector::size_type i = 0; i != self->hierarchy.size(); i++) { + Local contour_data = Array::New(4); + contour_data->Set(0, Number::New(self->hierarchy[i][0])); + contour_data->Set(1, Number::New(self->hierarchy[i][1])); + contour_data->Set(2, Number::New(self->hierarchy[i][2])); + contour_data->Set(3, Number::New(self->hierarchy[i][3])); + + hierarchy_data->Set(i, contour_data); + } + + Local data = Object::New(); + data->Set(String::NewSymbol("contours"), contours_data); + data->Set(String::NewSymbol("hierarchy"), hierarchy_data); + + return scope.Close(data); +} + +Handle +Contour::Deserialize(const Arguments &args) { + HandleScope scope; + + Contour *self = ObjectWrap::Unwrap(args.This()); + + Handle data = Handle::Cast(args[0]); + + Handle contours_data = Handle::Cast(data->Get(v8::String::NewSymbol("contours"))); + Handle hierarchy_data = Handle::Cast(data->Get(v8::String::NewSymbol("hierarchy"))); + + vector> contours_res; + int contours_length = contours_data->Length(); + + for (int i = 0; i < contours_length; i++) { + Handle contour_data = Handle::Cast(contours_data->Get(i)); + vector points; + + int contour_length = contour_data->Length(); + for (int j = 0; j < contour_length; j++) { + Handle point_data = Handle::Cast(contour_data->Get(j)); + int x = point_data->Get(0)->IntegerValue(); + int y = point_data->Get(1)->IntegerValue(); + points.push_back(cv::Point(x, y)); + } + + contours_res.push_back(points); + } + + vector hierarchy_res; + int hierarchy_length = hierarchy_data->Length(); + + for (int i = 0; i < hierarchy_length; i++) { + Handle contour_data = Handle::Cast(hierarchy_data->Get(i)); + int a = contour_data->Get(0)->IntegerValue(); + int b = contour_data->Get(1)->IntegerValue(); + int c = contour_data->Get(2)->IntegerValue(); + int d = contour_data->Get(3)->IntegerValue(); + hierarchy_res.push_back(cv::Vec4i(a, b, c, d)); + } + + self->contours = contours_res; + self->hierarchy = hierarchy_res; + + return scope.Close(v8::Null()); } \ No newline at end of file diff --git a/src/Contours.h b/src/Contours.h index 059316f..548e0e9 100755 --- a/src/Contours.h +++ b/src/Contours.h @@ -13,10 +13,11 @@ class Contour: public node::ObjectWrap { static void Init(Handle target); static Handle New(const Arguments &args); - Contour(); - + Contour(); + //JSFUNC(Size) - static Handle Point(const v8::Arguments&); + static Handle Point(const v8::Arguments&); + static Handle Points(const v8::Arguments&); static Handle Size(const v8::Arguments&); static Handle CornerCount(const v8::Arguments&); static Handle Area(const v8::Arguments&); @@ -28,5 +29,7 @@ class Contour: public node::ObjectWrap { static Handle IsConvex(const v8::Arguments&); static Handle Moments(const v8::Arguments&); static Handle Hierarchy(const v8::Arguments&); + static Handle Serialize(const v8::Arguments&); + static Handle Deserialize(const v8::Arguments&); }; From 1e3842a0ac48306e07e7f24d1f5b57cbef93b2b5 Mon Sep 17 00:00:00 2001 From: Oskar Dahlberg Date: Mon, 22 Sep 2014 15:44:11 +0200 Subject: [PATCH 3/3] Added space between >> --- src/Contours.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Contours.cc b/src/Contours.cc index dcc5b31..54ec81c 100755 --- a/src/Contours.cc +++ b/src/Contours.cc @@ -339,7 +339,7 @@ Contour::Deserialize(const Arguments &args) { Handle contours_data = Handle::Cast(data->Get(v8::String::NewSymbol("contours"))); Handle hierarchy_data = Handle::Cast(data->Get(v8::String::NewSymbol("hierarchy"))); - vector> contours_res; + vector > contours_res; int contours_length = contours_data->Length(); for (int i = 0; i < contours_length; i++) {