diff --git a/src/Contours.cc b/src/Contours.cc
index c5818e0..c586b3d 100755
--- a/src/Contours.cc
+++ b/src/Contours.cc
@@ -23,12 +23,15 @@ Contour::Init(Handle<Object> target) {
 	//Local<ObjectTemplate> proto = constructor->PrototypeTemplate();
 
 
+	NODE_SET_PROTOTYPE_METHOD(constructor, "point", Point);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "size", Size);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "cornerCount", CornerCount);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "area", Area);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "arcLength", ArcLength);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "approxPolyDP", ApproxPolyDP);
+	NODE_SET_PROTOTYPE_METHOD(constructor, "convexHull", ConvexHull);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "boundingRect", BoundingRect);
+	NODE_SET_PROTOTYPE_METHOD(constructor, "minAreaRect", BoundingRect);
 	NODE_SET_PROTOTYPE_METHOD(constructor, "isConvex", IsConvex);
 	target->Set(String::NewSymbol("Contours"), m->GetFunction());
 };
@@ -53,6 +56,23 @@ Contour::Contour(): ObjectWrap() {
 }
 
 
+Handle<Value>
+Contour::Point(const Arguments &args) {
+	HandleScope scope;
+
+		Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+		int pos   = args[0]->NumberValue();
+		int index = args[1]->NumberValue();
+
+		cv::Point point = self->contours[pos][index];
+
+		Local<Object> data = Object::New();
+		data->Set(String::NewSymbol("x"), Number::New(point.x));
+		data->Set(String::NewSymbol("y"), Number::New(point.y));
+
+		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.
@@ -116,6 +136,23 @@ Contour::ApproxPolyDP(const Arguments &args) {
 }
 
 
+Handle<Value>
+Contour::ConvexHull(const Arguments &args) {
+	HandleScope scope;
+
+	Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+
+	int pos        = args[0]->NumberValue();
+	bool clockwise = args[1]->BooleanValue();
+
+	cv::Mat hull;
+	cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise);
+	hull.copyTo(self->contours[pos]);
+
+	return scope.Close(v8::Null());
+}
+
+
 Handle<Value>
 Contour::BoundingRect(const Arguments &args) {
 	HandleScope scope;
@@ -135,6 +172,45 @@ Contour::BoundingRect(const Arguments &args) {
 }
 
 
+Handle<Value>
+Contour::MinAreaRect(const Arguments &args) {
+	HandleScope scope;
+
+	Contour *self = ObjectWrap::Unwrap<Contour>(args.This());
+	int pos = args[0]->NumberValue();
+
+	cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos]));
+
+	Local<Object> rect = Object::New();
+	rect->Set(String::NewSymbol("angle"), Number::New(minimum.angle));
+
+	Local<Object> size = Object::New();
+	size->Set(String::NewSymbol("height"), Number::New(minimum.size.height));
+	size->Set(String::NewSymbol("width"), Number::New(minimum.size.width));
+	rect->Set(String::NewSymbol("size"), size);
+
+	Local<Object> center = Object::New();
+	center->Set(String::NewSymbol("x"), Number::New(minimum.center.x));
+	center->Set(String::NewSymbol("y"), Number::New(minimum.center.y));
+
+	v8::Local<v8::Array> points = v8::Array::New(4);
+
+	cv::Point2f rect_points[4];
+	minimum.points(rect_points);
+
+	for (unsigned int i=0; i<4; i++){
+		Local<Object> point = Object::New();
+		point->Set(String::NewSymbol("x"), Number::New(rect_points[i].x));
+		point->Set(String::NewSymbol("y"), Number::New(rect_points[i].y));
+		points->Set(i, point);
+	}
+
+	rect->Set(String::NewSymbol("points"), points);
+
+	return scope.Close(rect);
+}
+
+
 Handle<Value>
 Contour::IsConvex(const Arguments &args) {
 	HandleScope scope;
diff --git a/src/Contours.h b/src/Contours.h
index 259503a..c0f8879 100755
--- a/src/Contours.h
+++ b/src/Contours.h
@@ -14,12 +14,15 @@ class Contour: public node::ObjectWrap {
 	Contour();
 
 	//JSFUNC(Size)
+	static Handle<Value> Point(const v8::Arguments&);
 	static Handle<Value> Size(const v8::Arguments&);
 	static Handle<Value> CornerCount(const v8::Arguments&);
 	static Handle<Value> Area(const v8::Arguments&);
 	static Handle<Value> ArcLength(const v8::Arguments&);
 	static Handle<Value> ApproxPolyDP(const v8::Arguments&);
+	static Handle<Value> ConvexHull(const v8::Arguments&);
 	static Handle<Value> BoundingRect(const v8::Arguments&);
+	static Handle<Value> MinAreaRect(const v8::Arguments&);
 	static Handle<Value> IsConvex(const v8::Arguments&);
 };