spyglass 0.0.2

checksums.yaml

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

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.bundle
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,6 @@
+--color
+--format progress
+<% if ENV['TRAVIS'] %>
+--tag ~gui
+<% end %>
+

data/.travis.yml

@@ -0,0 +1,11 @@
+before_install:
+  - bundle
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+
+install:
+  - sudo add-apt-repository -y ppa:limparissoft/opencv-ppa
+  - sudo apt-get -y update
+  - sudo apt-get -y install pkg-config opencv

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spyglass.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 André Medeiros
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+Spyglass
+========
+
+OpenCV in Ruby, made simple.
+
+Why?
+====
+
+Because I've been working on a computer vision project for 2 months and missed Ruby. Also, I wanted a nice, coherent API that would make me happy to use.
+
+Requirements
+============
+
+This gem requires OpenCV 2.4.5 or better. For an in-depth OpenCV installation guide, refer to the [OpenCV Wiki page](http://opencv.willowgarage.com/wiki/InstallGuide). It also depends on `pkg-config` being installed. I'm also accepting pull requests for Windows.
+
+TODO
+====
+
+There is a lot left to implement, as I've really only ported the parts of the API that I've used so far. Apart from that, there's:
+
+* Documentation
+* More tests
+
+Code Status
+===========
+
+* [![Build Status](https://travis-ci.org/andremedeiros/spyglass.png?branch=master)](https://travis-ci.org/andremedeiros/spyglass)
+* [![Dependency Status](https://gemnasium.com/andremedeiros/spyglass.png)](https://gemnasium.com/andremedeiros/spyglass)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake'
+
+Dir['tasks/*.rake'].sort.each { |f| load f }
+
+task :default => [:clean, :compile, :spec]

data/examples/background_subtractor.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift('lib')
+require 'spyglass'
+
+include Spyglass
+
+puts <<-eos
+WARNING: This demo might not work well with cameras that do auto-exposure.
+         If you can, disable those features for a better feel of this demo.
+
+eos
+
+bg      = BackgroundSubtractor.new
+window  = GUI::Window.new("Beach!")
+cap     = VideoCapture.new 0, width: 640, height: 480
+frame   = Image.new
+result  = Image.new
+beach   = Image.load File.expand_path('images/beach.jpg', File.dirname(__FILE__))
+
+puts "Step off the camera's field of vision!"
+3.times { |sec| puts "... #{ 3 - sec }"; sleep(1) }
+
+puts "Training background subtractor..."
+20.times { cap >> frame; bg.subtract frame, 0.05 }
+
+puts "Show yourself ;-)"
+
+loop do
+  cap >> frame
+
+  result.copy!(beach)
+  delta = bg.subtract(frame, 0)
+  result.copy!(frame, delta);
+
+  window.show result
+end

data/examples/cascade_classifier.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift('lib')
+require 'spyglass'
+
+include Spyglass 
+
+classifier  = CascadeClassifier.new("spec/fixtures/haarcascade_frontalface_default.xml")
+window      = GUI::Window.new "Video"
+cap         = VideoCapture.new 0
+frame       = Image.new
+
+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) }
+
+  window.show(frame)
+
+  break if GUI::wait_key(10) > 0
+end
+

data/examples/contours.rb

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

data/examples/video_capture.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift('lib')
+require 'spyglass'
+
+include Spyglass
+
+window  = GUI::Window.new "Video"
+cap     = VideoCapture.new 0
+frame   = Image.new
+
+loop do
+  cap >> frame
+  window.show(frame)
+
+  break if GUI::wait_key(100) > 0
+end

data/ext/spyglass/background_subtractor.cc

@@ -0,0 +1,78 @@
+#include "background_subtractor.h"
+
+static VALUE BackgroundSubtractorClass;
+
+namespace Spyglass {
+  namespace BackgroundSubtractor {
+    void define_ruby_class() {
+      // Class definition
+      BackgroundSubtractorClass = rb_define_class_under(Spyglass::get_ruby_module(), "BackgroundSubtractor", rb_cObject);
+      rb_define_alloc_func(BackgroundSubtractorClass, rb_alloc);
+      rb_define_method(BackgroundSubtractorClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+
+      // Instance methods
+      rb_define_method(BackgroundSubtractorClass, "subtract", RUBY_METHOD_FUNC(rb_subtract), -1);
+    }
+
+    VALUE get_ruby_class() {
+      return BackgroundSubtractorClass;
+    }
+
+    static VALUE rb_alloc(VALUE self) {
+      cv::BackgroundSubtractorMOG2 *bg = new cv::BackgroundSubtractorMOG2();
+      return Data_Wrap_Struct(BackgroundSubtractorClass, NULL, rb_free, bg);
+    }
+
+    static void rb_free(cv::BackgroundSubtractorMOG2 *bg) {
+      bg->~BackgroundSubtractorMOG2();
+      delete bg;
+    }
+
+    static VALUE rb_initialize(int argc, VALUE *argv, VALUE self) {
+      VALUE opts;
+      rb_scan_args(argc, argv, "01", &opts);
+
+      if(!RTEST(opts))
+        return self;
+
+      cv::BackgroundSubtractorMOG2 *bg = SG_GET_BG_SUBTRACTOR(self);
+
+      SG_OPTION(opts, int,    history,          500,  NUM2INT);
+      SG_OPTION(opts, double, threshold,        8.0,  NUM2DBL);
+      SG_OPTION(opts, bool,   shadow_detection, true, RTEST);
+
+      bg->set("history", history);
+      bg->set("varThreshold", threshold);
+      bg->set("detectShadows", shadow_detection);
+
+      return self;
+    }
+
+    static VALUE rb_subtract(int argc, VALUE *argv, VALUE self) {
+      VALUE image, learn_rate;
+      double rate;
+
+      rb_scan_args(argc, argv, "11", &image, &learn_rate);
+
+      if(CLASS_OF(image) != Image::get_ruby_class()) {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected Spyglass::Image)",
+            rb_obj_classname(image));
+      }
+
+
+      if(RTEST(learn_rate) && TYPE(learn_rate) != T_FLOAT && TYPE(learn_rate) != T_FIXNUM)
+          rb_raise(rb_eTypeError, "wrong argument type %s (expected Float or Fixnum)",
+              rb_obj_classname(learn_rate));
+
+      rate = RTEST(learn_rate) ? NUM2DBL(learn_rate) : -1.0;
+
+      cv::BackgroundSubtractorMOG2 *bg  = SG_GET_BG_SUBTRACTOR(self);
+      cv::Mat *img                      = SG_GET_IMAGE(image);
+
+      cv::Mat *delta = new cv::Mat();
+      (*bg)(*img, *delta, rate);
+
+      return Image::from_cvmat(delta);
+    }
+  }
+}

data/ext/spyglass/background_subtractor.h

@@ -0,0 +1,18 @@
+#ifndef SPYGLASS_BACKGROUND_SUBTRACTOR_H_
+#define SPYGLASS_BACKGROUND_SUBTRACTOR_H_
+
+#include "spyglass.h"
+
+namespace Spyglass {
+  namespace BackgroundSubtractor {
+    void define_ruby_class();
+    VALUE get_ruby_class();
+
+    static VALUE rb_alloc(VALUE self);
+    static void rb_free(cv::BackgroundSubtractorMOG2 *bg);
+    static VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+    static VALUE rb_subtract(int argc, VALUE *argv, VALUE self);
+  }
+}
+
+#endif // SPYGLASS_BACKGROUND_SUBTRACTOR_H_

data/ext/spyglass/cascade_classifier.cc

@@ -0,0 +1,70 @@
+#include "cascade_classifier.h"
+
+static VALUE CascadeClassifierClass;
+
+namespace Spyglass {
+  namespace CascadeClassifier {
+    void define_ruby_class() {
+      // Class definition
+      CascadeClassifierClass = rb_define_class_under(Spyglass::get_ruby_module(), "CascadeClassifier", rb_cObject);
+      rb_define_alloc_func(CascadeClassifierClass, rb_alloc);
+      rb_define_method(CascadeClassifierClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 1);
+
+      // Instance methods
+      rb_define_method(CascadeClassifierClass, "detect", RUBY_METHOD_FUNC(rb_detect), -1);
+    }
+
+    VALUE get_ruby_class() {
+      return CascadeClassifierClass;
+    }
+
+    static VALUE rb_alloc(VALUE self) {
+      cv::CascadeClassifier *classifier = new cv::CascadeClassifier();
+      return Data_Wrap_Struct(CascadeClassifierClass, NULL, rb_free, classifier);
+    }
+
+    static void rb_free(cv::CascadeClassifier *classifier) {
+      classifier->~CascadeClassifier();
+      delete classifier;
+    }
+
+    static VALUE rb_initialize(VALUE self, VALUE src) {
+      Check_Type(src, T_STRING);
+
+      cv::CascadeClassifier *classifier = SG_GET_CLASSIFIER(self);
+
+      classifier->load(StringValueCStr(src));
+
+      return self;
+    }
+
+    static VALUE rb_detect(int argc, VALUE *argv, VALUE self) {
+      VALUE image, opts;
+      rb_scan_args(argc, argv, "11", &image, &opts);
+
+      if(CLASS_OF(image) != Image::get_ruby_class()) {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected Spyglass::Image)",
+            rb_obj_classname(image));
+      }
+
+      cv::CascadeClassifier *classifier = SG_GET_CLASSIFIER(self);
+      cv::Mat *img                      = SG_GET_IMAGE(image);
+
+      SG_OPTION(opts, double,     scale_factor,   1.1,            NUM2DBL);
+      SG_OPTION(opts, int,        min_neighbors,  3,              NUM2INT);
+      SG_OPTION(opts, cv::Size *, min_size,       new cv::Size(), SG_GET_SIZE);
+      SG_OPTION(opts, cv::Size *, max_size,       new cv::Size(), SG_GET_SIZE);
+
+      std::vector<cv::Rect> results;
+      classifier->detectMultiScale(*img, results, scale_factor, min_neighbors, 0, *min_size, *max_size);
+
+      VALUE result = rb_ary_new2(results.size());
+      for(size_t i = 0; i < results.size(); i++) {
+        cv::Rect *rect = new cv::Rect(results[i]);
+        rb_ary_store(result, (long)i, Rect::from_cvrect(rect));
+      }
+
+      return result;
+    }
+  }
+}

data/ext/spyglass/cascade_classifier.h

@@ -0,0 +1,18 @@
+#ifndef SPYGLASS_CASCADE_CLASSIFIER_H_
+#define SPYGLASS_CASCADE_CLASSIFIER_H_
+
+#include "spyglass.h"
+
+namespace Spyglass {
+  namespace CascadeClassifier {
+    void define_ruby_class();
+    VALUE get_ruby_class();
+
+    static VALUE rb_alloc(VALUE self);
+    static void rb_free(cv::CascadeClassifier *classifier);
+    static VALUE rb_initialize(VALUE self, VALUE src);
+    static VALUE rb_detect(int argc, VALUE *argv, VALUE self);
+  }
+}
+
+#endif // SPYGLASS_CASCADE_CLASSIFIER_H_

data/ext/spyglass/color.cc

@@ -0,0 +1,83 @@
+#include "color.h"
+
+static VALUE ColorClass;
+
+namespace Spyglass {
+  namespace Color {
+    void define_ruby_class() {
+      // Class definition
+      ColorClass = rb_define_class_under(Spyglass::get_ruby_module(), "Color", rb_cObject);
+      rb_define_alloc_func(ColorClass, rb_alloc);
+      rb_define_method(ColorClass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+
+      // Instance methods
+      rb_define_method(ColorClass, "[]", RUBY_METHOD_FUNC(rb_get_color), 1);
+      rb_define_method(ColorClass, "to_a", RUBY_METHOD_FUNC(rb_to_a), 0);
+      rb_define_method(ColorClass, "zeros?", RUBY_METHOD_FUNC(rb_is_zeros), 0);
+    }
+
+    VALUE get_ruby_class() {
+      return ColorClass;
+    }
+
+    static VALUE rb_alloc(VALUE self) {
+      cv::Scalar *color = new cv::Scalar(0, 0, 0, 0);
+      return Data_Wrap_Struct(ColorClass, NULL, rb_free, color);
+    }
+
+    static void rb_free(cv::Scalar *color) {
+      delete color;
+    }
+
+    static VALUE rb_initialize(int argc, VALUE *argv, VALUE self) {
+      if(argc < 1 || argc > 4)
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..4)", argc);
+
+      cv::Scalar *color = SG_GET_COLOR(self);
+
+      for(int idx = 0; idx < argc; idx++) {
+        (*color)[idx] = NUM2DBL(argv[idx]);
+      }
+
+      return self;
+    }
+
+    static VALUE rb_get_color(VALUE self, VALUE index) {
+      Check_Type(index, T_FIXNUM);
+
+      int idx = NUM2INT(index);
+
+      if(idx < 0 || idx > 3)
+        return Qnil;
+
+      cv::Scalar *color = SG_GET_COLOR(self);
+      double val = (*color)[idx];
+      return DBL2NUM(val);
+    }
+
+    static VALUE rb_to_a(VALUE self) {
+      cv::Scalar *color = SG_GET_COLOR(self);
+      VALUE ary = rb_ary_new2(4);
+
+      for(int idx = 0; idx < 4; idx++)
+        rb_ary_store(ary, idx, DBL2NUM((*color)[idx]));
+
+      return ary;
+    }
+
+    static VALUE rb_is_zeros(VALUE self) {
+      cv::Scalar *color = SG_GET_COLOR(self);
+      bool all_zeros = true;
+      for(int idx = 0; idx < 4; idx++) {
+        if((*color)[idx] > 0)
+          all_zeros = false;
+      }
+
+      return all_zeros ? Qtrue : Qfalse;
+    }
+
+    VALUE from_cvscalar(cv::Scalar *color) {
+      return Data_Wrap_Struct(ColorClass, NULL, rb_free, color);
+    }
+  }
+}