spyglass 0.0.2

data/ext/spyglass/image.h

@@ -0,0 +1,46 @@
+#ifndef SPYGLASS_IMAGE_H_
+#define SPYGLASS_IMAGE_H_
+
+#include "spyglass.h"
+
+namespace Spyglass {
+  namespace Image {
+    void define_ruby_class();
+    VALUE get_ruby_class();
+
+    static VALUE rb_alloc(VALUE self);
+    static void rb_free(cv::Mat *mat);
+    static VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_canny(VALUE self, VALUE threshold1, VALUE threshold2);
+    static VALUE rb_canny_inplace(VALUE self, VALUE threshold1, VALUE threshold2);
+    static VALUE rb_convert(VALUE self, VALUE color_space);
+    static VALUE rb_convert_inplace(VALUE self, VALUE color_space);
+    static VALUE rb_copy_inplace(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_crop(VALUE self, VALUE rect);
+    static VALUE rb_crop_inplace(VALUE self, VALUE rect);
+    static VALUE rb_dilate(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_dilate_inplace(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_draw_contours(VALUE self, VALUE contours, VALUE color);
+    static VALUE rb_draw_rectangle(VALUE self, VALUE rect, VALUE color);
+    static VALUE rb_erode(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_erode_inplace(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_fill(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_fill_inplace(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_load(int argc, VALUE *argv, VALUE klass);
+    static VALUE rb_mean(int argc, VALUE *argv, VALUE klass);
+    static VALUE rb_threshold(int argc, VALUE *argv, VALUE klass);
+    static VALUE rb_threshold_inplace(int argc, VALUE *argv, VALUE klass);
+    static VALUE rb_threshold_inv(int argc, VALUE *argv, VALUE klass);
+    static VALUE rb_threshold_inv_inplace(int argc, VALUE *argv, VALUE klass);
+    static VALUE rb_get_cols(VALUE self);
+    static VALUE rb_get_contours(VALUE self);
+    static VALUE rb_get_rows(VALUE self);
+    static VALUE rb_get_size(VALUE self);
+    static VALUE rb_write(VALUE self, VALUE filename);
+    static VALUE rb_zeros(int argc, VALUE *argv, VALUE klass);
+
+    VALUE from_cvmat(cv::Mat *mat);
+  }
+}
+
+#endif // SPYGLASS_IMAGE_H_

data/ext/spyglass/point.cc

@@ -0,0 +1,78 @@
+#include "point.h"
+
+static VALUE PointClass;
+
+namespace Spyglass {
+  namespace Point {
+    void define_ruby_class() {
+      // Class definition
+      PointClass = rb_define_class_under(Spyglass::get_ruby_module(), "Point", rb_cObject);
+      rb_define_alloc_func(PointClass, rb_alloc);
+      rb_define_method(PointClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 2);
+
+      // Instance methods
+      rb_define_method(PointClass, "x", RUBY_METHOD_FUNC(rb_get_x), 0);
+      rb_define_method(PointClass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+      rb_define_method(PointClass, "y", RUBY_METHOD_FUNC(rb_get_y), 0);
+      rb_define_method(PointClass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+    }
+
+    VALUE get_ruby_class() {
+      return PointClass;
+    }
+
+    static VALUE rb_alloc(VALUE self) {
+      cv::Point *point = new cv::Point();
+      return Data_Wrap_Struct(PointClass, NULL, rb_free, point);
+    }
+
+    static void rb_free(cv::Point *point) {
+      delete point;
+    }
+
+    static VALUE rb_initialize(VALUE self, VALUE x, VALUE y) {
+      Check_Type(x, T_FIXNUM);
+      Check_Type(y, T_FIXNUM);
+
+      cv::Point *point = SG_GET_POINT(self);
+
+      point->x = FIX2INT(x);
+      point->y = FIX2INT(y);
+
+      return self;
+    }
+
+    static VALUE rb_get_x(VALUE self) {
+      cv::Point *point = SG_GET_POINT(self);
+      return INT2FIX(point->x);
+    }
+
+    static VALUE rb_set_x(VALUE self, VALUE x) {
+      Check_Type(x, T_FIXNUM);
+
+      cv::Point *point = SG_GET_POINT(self);
+
+      point->x = FIX2INT(x);
+      return x;
+    }
+
+    static VALUE rb_get_y(VALUE self) {
+      cv::Point *point = SG_GET_POINT(self);
+      return INT2FIX(point->y);
+    }
+
+    static VALUE rb_set_y(VALUE self, VALUE y) {
+      Check_Type(y, T_FIXNUM);
+
+      cv::Point *point = SG_GET_POINT(self);
+
+      point->y = FIX2INT(y);
+      return y;
+    }
+
+    VALUE from_cvrect(cv::Rect *rect) {
+      cv::Point *point = new cv::Point(rect->tl());
+      return Data_Wrap_Struct(PointClass, NULL, rb_free, point);
+    }
+  }
+}

data/ext/spyglass/point.h

@@ -0,0 +1,23 @@
+#ifndef SPYGLASS_POINT_H_
+#define SPYGLASS_POINT_H_
+
+#include "spyglass.h"
+
+namespace Spyglass {
+  namespace Point {
+    void define_ruby_class();
+    VALUE get_ruby_class();
+
+    static VALUE rb_alloc(VALUE self);
+    static void rb_free(cv::Point *point);
+    static VALUE rb_initialize(VALUE self, VALUE x, VALUE y);
+    static VALUE rb_get_x(VALUE self);
+    static VALUE rb_get_y(VALUE self);
+    static VALUE rb_set_x(VALUE self, VALUE x);
+    static VALUE rb_set_y(VALUE self, VALUE y);
+
+    VALUE from_cvrect(cv::Rect *rect);
+  }
+}
+
+#endif // SPYGLASS_POINT_H_

data/ext/spyglass/prelude.h

@@ -0,0 +1,42 @@
+#ifndef SPYGLASS_PRELUDE_H_
+#define SPYGLASS_PRELUDE_H_
+
+#ifndef Data_Set_Struct
+#define Data_Set_Struct(obj,ptr) do {\
+  Check_Type(obj, T_DATA); \
+  DATA_PTR(obj) = ptr; \
+} while (0);
+#endif
+
+#define SG_GEN_GET_OBJECT_FUNCTION(func, type) \
+  inline type *func(VALUE obj) { \
+    type *ptr; \
+    Data_Get_Struct(obj, type, ptr); \
+    return ptr; \
+  }
+
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_BG_SUBTRACTOR,  cv::BackgroundSubtractorMOG2);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_CLASSIFIER,     cv::CascadeClassifier);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_COLOR,          cv::Scalar);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_CONTOUR,        std::vector<cv::Point *>);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_IMAGE,          cv::Mat);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_POINT,          cv::Point);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_RECT,           cv::Rect);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_SIZE,           cv::Size);
+SG_GEN_GET_OBJECT_FUNCTION(SG_GET_VIDEO_CAPTURE,  cv::VideoCapture);
+
+#define SG_OPTION(opts, type, key, default, expr) \
+  type key = default; \
+  if(RTEST(opts)) { \
+    Check_Type(opts, T_HASH); \
+    do { \
+      VALUE option; \
+      option = rb_hash_aref(opts, rb_str_new2(#key)); \
+      if(!RTEST(option)) \
+        option = rb_hash_aref(opts, ID2SYM(rb_intern(#key))); \
+      if(RTEST(option)) \
+        key = expr(option); \
+    } while(0); \
+  }
+
+#endif // SPYGLASS_PRELUDE_H_

data/ext/spyglass/rect.cc

@@ -0,0 +1,131 @@
+#include "rect.h"
+
+static VALUE RectClass;
+
+namespace Spyglass {
+  namespace Rect {
+    void define_ruby_class() {
+      // Class definition
+      RectClass = rb_define_class_under(Spyglass::get_ruby_module(), "Rect", rb_cObject);
+      rb_define_alloc_func(RectClass, rb_alloc);
+      rb_define_method(RectClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 4);
+
+      // Instance methods
+      rb_define_method(RectClass, "area", RUBY_METHOD_FUNC(rb_get_area), 0);
+      rb_define_method(RectClass, "height", RUBY_METHOD_FUNC(rb_get_height), 0);
+      rb_define_method(RectClass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1);
+      rb_define_method(RectClass, "point", RUBY_METHOD_FUNC(rb_get_point), 0);
+      rb_define_method(RectClass, "size", RUBY_METHOD_FUNC(rb_get_size), 0);
+      rb_define_method(RectClass, "width", RUBY_METHOD_FUNC(rb_get_width), 0);
+      rb_define_method(RectClass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1);
+      rb_define_method(RectClass, "x", RUBY_METHOD_FUNC(rb_get_x), 0);
+      rb_define_method(RectClass, "x=", RUBY_METHOD_FUNC(rb_set_x), 1);
+      rb_define_method(RectClass, "y", RUBY_METHOD_FUNC(rb_get_y), 0);
+      rb_define_method(RectClass, "y=", RUBY_METHOD_FUNC(rb_set_y), 1);
+    }
+
+    VALUE get_ruby_class() {
+      return RectClass;
+    }
+
+    static VALUE rb_alloc(VALUE self) {
+      cv::Rect *rect = new cv::Rect();
+      return Data_Wrap_Struct(RectClass, NULL, rb_free, rect);
+    }
+
+    static void rb_free(cv::Rect *rect) {
+      delete rect;
+    }
+
+    static VALUE rb_initialize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height) {
+      Check_Type(x, T_FIXNUM);
+      Check_Type(y, T_FIXNUM);
+      Check_Type(width, T_FIXNUM);
+      Check_Type(height, T_FIXNUM);
+
+      cv::Rect *rect = SG_GET_RECT(self);
+
+      rect->x = FIX2INT(x);
+      rect->y = FIX2INT(y);
+      rect->width = FIX2INT(width);
+      rect->height = FIX2INT(height);
+
+      return self;
+    }
+
+    static VALUE rb_get_area(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return INT2FIX(rect->area());
+    }
+
+    static VALUE rb_get_height(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return INT2FIX(rect->height);
+    }
+
+    static VALUE rb_set_height(VALUE self, VALUE height) {
+      Check_Type(height, T_FIXNUM);
+
+      cv::Rect *rect = SG_GET_RECT(self);
+
+      rect->height = FIX2INT(height);
+      return height;
+    }
+
+    static VALUE rb_get_point(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return Point::from_cvrect(rect);
+    }
+
+    static VALUE rb_get_size(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return Size::from_cvrect(rect);
+    }
+
+    static VALUE rb_get_width(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return INT2FIX(rect->width);
+    }
+
+    static VALUE rb_set_width(VALUE self, VALUE width) {
+      Check_Type(width, T_FIXNUM);
+
+      cv::Rect *rect = SG_GET_RECT(self);
+
+      rect->width = FIX2INT(width);
+      return width;
+    }
+
+    static VALUE rb_get_x(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return INT2FIX(rect->x);
+    }
+
+    static VALUE rb_set_x(VALUE self, VALUE x) {
+      Check_Type(x, T_FIXNUM);
+
+      cv::Rect *rect = SG_GET_RECT(self);
+
+      rect->x = FIX2INT(x);
+      return x;
+    }
+
+    static VALUE rb_get_y(VALUE self) {
+      cv::Rect *rect = SG_GET_RECT(self);
+      return INT2FIX(rect->y);
+    }
+
+    static VALUE rb_set_y(VALUE self, VALUE y) {
+      Check_Type(y, T_FIXNUM);
+
+      cv::Rect *rect = SG_GET_RECT(self);
+
+      rect->y = FIX2INT(y);
+      return y;
+    }
+
+    VALUE from_cvrect(cv::Rect *rect) {
+      return Data_Wrap_Struct(RectClass, NULL, rb_free, rect);
+    }
+  }
+}

data/ext/spyglass/rect.h

@@ -0,0 +1,30 @@
+#ifndef SPYGLASS_RECT_H_
+#define SPYGLASS_RECT_H_
+
+#include "spyglass.h"
+
+namespace Spyglass {
+  namespace Rect {
+    void define_ruby_class();
+    VALUE get_ruby_class();
+
+    static VALUE rb_alloc(VALUE self);
+    static void rb_free(cv::Rect *rect);
+    static VALUE rb_initialize(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height);
+    static VALUE rb_get_area(VALUE self);
+    static VALUE rb_get_height(VALUE self);
+    static VALUE rb_get_point(VALUE self);
+    static VALUE rb_get_size(VALUE self);
+    static VALUE rb_get_width(VALUE self);
+    static VALUE rb_get_x(VALUE self);
+    static VALUE rb_get_y(VALUE self);
+    static VALUE rb_set_height(VALUE self, VALUE height);
+    static VALUE rb_set_width(VALUE self, VALUE width);
+    static VALUE rb_set_x(VALUE self, VALUE x);
+    static VALUE rb_set_y(VALUE self, VALUE y);
+
+    VALUE from_cvrect(cv::Rect *rect);
+  }
+}
+
+#endif // SPYGLASS_RECT_H_

data/ext/spyglass/size.cc

@@ -0,0 +1,89 @@
+#include "size.h"
+
+static VALUE SizeClass;
+
+namespace Spyglass {
+  namespace Size {
+    void define_ruby_class() {
+      // Class definition
+      SizeClass = rb_define_class_under(Spyglass::get_ruby_module(), "Size", rb_cObject);
+      rb_define_alloc_func(SizeClass, rb_alloc);
+      rb_define_method(SizeClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 2);
+
+      // Instance methods
+      rb_define_method(SizeClass, "area", RUBY_METHOD_FUNC(rb_get_area), 0);
+      rb_define_method(SizeClass, "height", RUBY_METHOD_FUNC(rb_get_height), 0);
+      rb_define_method(SizeClass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1);
+      rb_define_method(SizeClass, "width", RUBY_METHOD_FUNC(rb_get_width), 0);
+      rb_define_method(SizeClass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1);
+    }
+
+    VALUE get_ruby_class() {
+      return SizeClass;
+    }
+
+    static VALUE rb_alloc(VALUE self) {
+      cv::Size *size = new cv::Size();
+      return Data_Wrap_Struct(SizeClass, NULL, rb_free, size);
+    }
+
+    static void rb_free(cv::Size *size) {
+      delete size;
+    }
+
+    static VALUE rb_initialize(VALUE self, VALUE width, VALUE height) {
+      Check_Type(width, T_FIXNUM);
+      Check_Type(height, T_FIXNUM);
+
+      cv::Size *size = SG_GET_SIZE(self);
+
+      size->width = FIX2INT(width);
+      size->height = FIX2INT(height);
+
+      return self;
+    }
+
+    static VALUE rb_get_area(VALUE self) {
+      cv::Size *size = SG_GET_SIZE(self);
+      return INT2FIX(size->area());
+    }
+
+    static VALUE rb_get_height(VALUE self) {
+      cv::Size *size = SG_GET_SIZE(self);
+      return INT2FIX(size->height);
+    }
+
+    static VALUE rb_set_height(VALUE self, VALUE height) {
+      Check_Type(height, T_FIXNUM);
+
+      cv::Size *size = SG_GET_SIZE(self);
+
+      size->height = FIX2INT(height);
+      return height;
+    }
+
+    static VALUE rb_get_width(VALUE self) {
+      cv::Size *size = SG_GET_SIZE(self);
+      return INT2FIX(size->width);
+    }
+
+    static VALUE rb_set_width(VALUE self, VALUE width) {
+      Check_Type(width, T_FIXNUM);
+
+      cv::Size *size = SG_GET_SIZE(self);
+
+      size->width = FIX2INT(width);
+      return width;
+    }
+
+    VALUE from_cvmat(cv::Mat *mat) {
+      cv::Size *size = new cv::Size(mat->size());
+      return Data_Wrap_Struct(SizeClass, NULL, rb_free, size);
+    }
+
+    VALUE from_cvrect(cv::Rect *rect) {
+      cv::Size *size = new cv::Size(rect->size());
+      return Data_Wrap_Struct(SizeClass, NULL, rb_free, size);
+    }
+  }
+}