spyglass 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 368c20a70c719acceb1244b9cab1ad6274622eaa
-  data.tar.gz: 00e92f3dd911a30304ec83269b254420f5acdc57
+  metadata.gz: ea79e0513a6b15e030d22e55cb61f1281976d6d2
+  data.tar.gz: a90524336749778e856803ace12316f3ae0fd88e
 SHA512:
-  metadata.gz: b4fac2a901002853912daf86ce7192a6b6fe05d8167c26bcdf7c30ff14e46dacab58c55186527084fcb5eeb80eabc76ac65933e962ad4cbfefbc44dbf0ef6bf3
-  data.tar.gz: 6880d0ee03bd34737d78fa8609b0feaf672618074612386ee22e27750da780f120f0246f3996a7a197962ea62715c180d19357c544d269bd451a6bde3e58bc35
+  metadata.gz: a103029705c35d69271b0f527d7bd94e19eaff10218677ec4c70d715164696df900a837b0feea5d4dab35dec14dfff2044c98d2fdf3a38c393a31556d9e2dfad
+  data.tar.gz: e01a216cab093e8db29631f3db6224d6525a2197a38e24c7ac6d2ef169b6a10f42437e0dc2102ba8803d5f06528faf342390443ca57fc0f19408a4be68d320c8

data/examples/background_subtractor.rb

@@ -32,4 +32,6 @@ loop do
   result.copy!(frame, delta);
 
   window.show result
+
+  break if GUI::wait_key(10) > 0
 end

data/examples/cascade_classifier.rb

@@ -12,7 +12,7 @@ loop do
   cap >> frame
 
   rects = classifier.detect(frame, scale_factor: 1.5, min_size: Size.new(30, 30))
-  rects.map { |r| frame.draw_rectangle(r) }
+  rects.map { |r| frame.draw_rectangle(r, Color.new(255, 0, 0)) }
 
   window.show(frame)
 

data/examples/contours.rb

@@ -13,7 +13,7 @@ canny.canny!(200, 300)
 
 result = Image.new
 result.copy!(apple)
-result.draw_contours(canny.contours)
+result.draw_contours(canny.contours, Color.new(255, 0, 0))
 
 result_window = GUI::Window.new "Contours"
 result_window.show(result)

data/examples/corners.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift('lib')
+require 'spyglass'
+
+include Spyglass 
+
+window  = GUI::Window.new "Original"
+output  = GUI::Window.new "Output"
+card    = Image.load File.expand_path('images/card.jpg', File.dirname(__FILE__))
+
+window.show(card)
+
+canny = card.convert(ColorSpace[:BGR => :Gray])
+
+canny.canny!(200, 300)
+contours  = canny.contours
+corners   = contours[0].corners
+
+warped = card.warp_perspective(corners, Size.new(220, 300))
+
+output.show(warped)
+
+loop do
+  break if GUI::wait_key(10) > 0
+end

data/ext/spyglass/contour.cc

@@ -11,7 +11,12 @@ namespace Spyglass {
       rb_define_method(ContourClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
 
       // Instance methods
+      rb_define_method(ContourClass, "corners", RUBY_METHOD_FUNC(rb_get_corners), 0);
+      rb_define_method(ContourClass, "convex?", RUBY_METHOD_FUNC(rb_is_convex), 0);
       rb_define_method(ContourClass, "rect", RUBY_METHOD_FUNC(rb_get_rect), 0);
+
+      // Aliases
+      rb_define_alias(ContourClass, "closed?", "convex?");
     }
 
     VALUE get_ruby_class() {
@@ -52,6 +57,57 @@ namespace Spyglass {
       return self;
     }
 
+    static VALUE rb_get_corners(VALUE self) {
+      // This method is a bit of a misnomer in terms of how OpenCV works,
+      // seen as it's not a simple getter. It's implemented for ease of
+      // use. This code was blatantly based on:
+      //
+      // http://opencv-code.com/tutorials/automatic-perspective-correction-for-quadrilateral-objects/
+      std::vector<cv::Point> contour = to_value_vector(SG_GET_CONTOUR(self));
+      cv::approxPolyDP(contour, contour, cv::arcLength(cv::Mat(contour), true) * 0.02, true);
+      if (contour.size() != 4) {
+        // TODO: Throw exception here?
+        std::cout << "The object is not quadrilateral!" << std::endl;
+        return Qnil;
+      }
+
+      // Get mass center
+      cv::Point center(0,0);
+      for (int i = 0; i < contour.size(); i++)
+        center += contour[i];
+      center *= (1. / contour.size());
+
+      // Grab TL, TR, BL, and BR corners.
+      std::vector<cv::Point> top, bot;
+      for (int i = 0; i < contour.size(); i++) {
+        if (contour[i].y < center.y)
+          top.push_back(contour[i]);
+        else
+          bot.push_back(contour[i]);
+      }
+
+      cv::Point tl = top[0].x > top[1].x ? top[1] : top[0];
+      cv::Point tr = top[0].x > top[1].x ? top[0] : top[1];
+      cv::Point bl = bot[0].x > bot[1].x ? bot[1] : bot[0];
+      cv::Point br = bot[0].x > bot[1].x ? bot[0] : bot[1];
+
+      contour.clear();
+      contour.push_back(tl);
+      contour.push_back(tr);
+      contour.push_back(br);
+      contour.push_back(bl);
+
+      return from_cvpoint_vector(contour);
+    }
+
+    static VALUE rb_is_convex(VALUE self) {
+      std::vector<cv::Point> contour = to_value_vector(SG_GET_CONTOUR(self));
+      std::vector<cv::Point> simplified;
+      cv::approxPolyDP(contour, simplified, cv::arcLength(cv::Mat(contour), true) * 0.02, true);
+
+      return cv::isContourConvex(simplified) ? Qtrue : Qfalse;
+    }
+
     static VALUE rb_get_rect(VALUE self) {
       std::vector<cv::Point *> *contour = SG_GET_CONTOUR(self);
       cv::Rect rect = cv::boundingRect(to_value_vector(contour));

data/ext/spyglass/contour.h

@@ -11,7 +11,9 @@ namespace Spyglass {
     static VALUE rb_alloc(VALUE self);
     static void rb_free(std::vector<cv::Point *> *contour);
     static VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_get_corners(VALUE self);
     static VALUE rb_get_rect(VALUE self);
+    static VALUE rb_is_convex(VALUE self);
 
     std::vector<cv::Point> to_value_vector(std::vector<cv::Point *> *contour);
     VALUE from_cvpoint_vector(std::vector<cv::Point> contours);

data/ext/spyglass/image.cc

@@ -33,12 +33,15 @@ namespace Spyglass {
       rb_define_method(ImageClass, "fill", RUBY_METHOD_FUNC(rb_fill), -1);
       rb_define_method(ImageClass, "fill!", RUBY_METHOD_FUNC(rb_fill_inplace), -1);
       rb_define_method(ImageClass, "mean", RUBY_METHOD_FUNC(rb_mean), -1);
+      rb_define_method(ImageClass, "resize", RUBY_METHOD_FUNC(rb_resize), 1);
+      rb_define_method(ImageClass, "resize!", RUBY_METHOD_FUNC(rb_resize_inplace), 1);
       rb_define_method(ImageClass, "rows", RUBY_METHOD_FUNC(rb_get_rows), 0);
       rb_define_method(ImageClass, "size", RUBY_METHOD_FUNC(rb_get_size), 0);
       rb_define_method(ImageClass, "threshold", RUBY_METHOD_FUNC(rb_threshold), -1);
       rb_define_method(ImageClass, "threshold!", RUBY_METHOD_FUNC(rb_threshold_inplace), -1);
       rb_define_method(ImageClass, "threshold_inv", RUBY_METHOD_FUNC(rb_threshold_inv), -1);
       rb_define_method(ImageClass, "threshold_inv!", RUBY_METHOD_FUNC(rb_threshold_inv_inplace), -1);
+      rb_define_method(ImageClass, "warp_perspective", RUBY_METHOD_FUNC(rb_warp_perspective), 2);
       rb_define_method(ImageClass, "write", RUBY_METHOD_FUNC(rb_write), 1);
 
       // Constants
@@ -312,9 +315,10 @@ namespace Spyglass {
 
     static VALUE rb_get_contours(VALUE self) {
       cv::Mat *img = SG_GET_IMAGE(self);
+      cv::Mat tmp(*img);
 
       std::vector<std::vector<cv::Point> > contours;
-      cv::findContours(*img, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
+      cv::findContours(tmp, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
 
       return Contour::from_contour_vector(contours);
     }
@@ -408,6 +412,33 @@ namespace Spyglass {
       return Size::from_cvmat(img);
     }
 
+    cv::Mat *_do_resize(VALUE self, VALUE size, bool inplace) {
+      cv::Mat *img = SG_GET_IMAGE(self);
+      cv::Mat *dest;
+
+      cv::Size *_size = SG_GET_SIZE(size);
+
+      if(inplace)
+        dest = img;
+      else
+        dest = new cv::Mat();
+
+      cv::resize(*img, *dest, *_size);
+
+      return dest;
+    }
+
+    static VALUE rb_resize(VALUE self, VALUE size) {
+      cv::Mat *img = _do_resize(self, size, false);
+      return Data_Wrap_Struct(ImageClass, NULL, rb_free, img);
+    }
+
+    static VALUE rb_resize_inplace(VALUE self, VALUE size) {
+      _do_resize(self, size, true);
+      return self;
+    }
+
+
     cv::Mat *_do_threshold(int argc, VALUE *argv, VALUE self, bool inverse, bool inplace) {
       VALUE threshold, replacement, opts;
       rb_scan_args(argc, argv, "21", &threshold, &replacement, &opts);
@@ -449,6 +480,33 @@ namespace Spyglass {
       return self;
     }
 
+    static VALUE rb_warp_perspective(VALUE self, VALUE corners, VALUE size) {
+      std::vector<cv::Point> _corners = Contour::to_value_vector(SG_GET_CONTOUR(corners));
+      cv::Size *_size = SG_GET_SIZE(size);
+      cv::Mat *img    = SG_GET_IMAGE(self);
+      cv::Mat *result = new cv::Mat(_size->height, _size->width, CV_8UC3);
+
+      // Convert the corner points to `Point2f`, as `getPerspectiveTransform` only
+      // works with that kind of array.
+      std::vector<cv::Point2f> corner_pts;
+      for(int i = 0; i < _corners.size(); i++) {
+        cv::Point2f pt;
+        pt.x = _corners[i].x;
+        pt.y = _corners[i].y;
+        corner_pts.push_back(pt);
+      }
+
+	    std::vector<cv::Point2f> quad_pts;
+    	quad_pts.push_back(cv::Point2f(0, 0));
+    	quad_pts.push_back(cv::Point2f(_size->width, 0));
+	    quad_pts.push_back(cv::Point2f(_size->width, _size->height));
+	    quad_pts.push_back(cv::Point2f(0, _size->height));
+
+     	cv::Mat transmtx = cv::getPerspectiveTransform(corner_pts, quad_pts);
+    	cv::warpPerspective(*img, *result, transmtx, result->size());
+      return Data_Wrap_Struct(ImageClass, NULL, rb_free, result);
+    }
+
     static VALUE rb_write(VALUE self, VALUE filename) {
       Check_Type(filename, T_STRING);
 

data/ext/spyglass/image.h

@@ -28,6 +28,8 @@ namespace Spyglass {
     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_resize(VALUE self, VALUE size);
+    static VALUE rb_resize_inplace(VALUE self, VALUE size);
     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);
@@ -36,6 +38,7 @@ namespace Spyglass {
     static VALUE rb_get_contours(VALUE self);
     static VALUE rb_get_rows(VALUE self);
     static VALUE rb_get_size(VALUE self);
+    static VALUE rb_warp_perspective(VALUE self, VALUE corners, VALUE size);
     static VALUE rb_write(VALUE self, VALUE filename);
     static VALUE rb_zeros(int argc, VALUE *argv, VALUE klass);
 

data/lib/spyglass/version.rb

@@ -1,3 +1,3 @@
 module Spyglass 
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/spyglass/image_spec.rb

@@ -113,4 +113,22 @@ describe Spyglass::Image do
       expect( im.cols ).to eq(512)
     end
   end
+
+  describe '#resize' do
+    it 'should resize the image' do
+      new_img = lena.resize(Spyglass::Size.new(1024, 1024))
+
+      expect( new_img.rows ).to eq(1024)
+      expect( new_img.cols ).to eq(1024)
+    end
+  end
+
+  describe '#resize!' do
+    it 'should resize the image in place' do
+      lena.resize!(Spyglass::Size.new(1024, 1024))
+
+      expect( lena.rows ).to eq(1024)
+      expect( lena.cols ).to eq(1024)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spyglass
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - André Medeiros
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-06 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,8 +84,10 @@ files:
 - examples/background_subtractor.rb
 - examples/cascade_classifier.rb
 - examples/contours.rb
+- examples/corners.rb
 - examples/images/apple.jpg
 - examples/images/beach.jpg
+- examples/images/card.jpg
 - examples/video_capture.rb
 - ext/spyglass/background_subtractor.cc
 - ext/spyglass/background_subtractor.h