spyglass 0.0.2

data/spec/matchers/close_to.rb

@@ -0,0 +1,6 @@
+RSpec::Matchers.define :be_close_to do |expected, opts|
+  threshold = opts[:threshold] || 10
+  match do |actual|
+    (expected-threshold..expected+threshold).include? actual
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'spyglass'
+require 'tmpdir'
+
+require 'matchers/close_to'
+
+def fixture_path(fixture)
+  File.join(File.dirname(__FILE__), 'fixtures', fixture)
+end

data/spec/spyglass/background_subtractor_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Spyglass::BackgroundSubtractor do
+  let(:bg) { Spyglass::BackgroundSubtractor.new }
+  let(:lena) { Spyglass::Image.load(fixture_path('lena.jpg')) }
+
+  describe '.new' do
+    it 'should work with no arguments' do
+      expect( bg ).to be_a Spyglass::BackgroundSubtractor
+    end
+
+    it 'should work with an options hash' do
+      expect { Spyglass::BackgroundSubtractor.new(history: 50, threshold: 64) }.not_to raise_error
+    end
+  end
+
+  describe '#subtract' do
+    it 'should return a Spyglass::Image' do
+      delta = bg.subtract(lena, 1)
+      expect( delta ).to be_a Spyglass::Image
+    end
+  end
+end

data/spec/spyglass/cascade_classifier_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Spyglass::CascadeClassifier do
+  let(:classifier) { Spyglass::CascadeClassifier.new(fixture_path('haarcascade_frontalface_default.xml')) }
+  let(:lena) { Spyglass::Image.load(fixture_path('lena.jpg')) }
+
+  describe '.new' do
+    it 'should receive an argument' do
+      expect { Spyglass::CascadeClassifier.new }.to raise_error ArgumentError;
+      expect( classifier ).to be_a Spyglass::CascadeClassifier
+    end
+  end
+
+  describe '.detect' do
+    it 'should return an array of Spyglass::Rect' do
+      rects = classifier.detect(lena, scale_factor: 1.3)
+
+      expect( rects ).to be_a Array
+
+      rect = rects.first
+      expect( rect ).to         be_a Spyglass::Rect
+      expect( rect.x ).to       be_close_to 215, threshold: 10
+      expect( rect.y ).to       be_close_to 202, threshold: 10
+      expect( rect.width ).to   be_close_to 174, threshold: 10
+      expect( rect.height ).to  be_close_to 174, threshold: 10
+    end
+  end
+end

data/spec/spyglass/color_space_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Spyglass::ColorSpace do
+  describe '[]' do
+    it 'should return a valid color space code when the conversion is defined' do
+      expect(Spyglass::ColorSpace[:RGB => :Gray]).to eq(7)
+    end
+    
+    it 'should throw an exception when a conversion isnt defined' do
+      expect { Spyglass::ColorSpace[:RGB => :FairyDust] }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/spyglass/color_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Spyglass::Color do
+  let(:color) { Spyglass::Color.new(255, 123, 234) }
+
+  describe '.new' do
+    it 'should accept between 1 to 4 arguments' do
+      expect( Spyglass::Color.new(255) ).to be_a Spyglass::Color
+      expect( Spyglass::Color.new(255, 255) ).to be_a Spyglass::Color
+      expect( Spyglass::Color.new(255, 255, 255) ).to be_a Spyglass::Color
+      expect( Spyglass::Color.new(255, 255, 255, 255) ).to be_a Spyglass::Color
+
+      expect { Spyglass::Color.new }.to raise_error ArgumentError
+    end
+  end
+
+  describe 'getters' do
+    describe '#to_a' do
+      it 'should return an array with the color values' do
+        expected  = [255, 123, 234, 0]
+        colors    = color.to_a
+
+        expect( colors ).to eq(expected)
+      end
+    end
+
+    describe '#[]' do
+      it 'should return the correct color values for indices between 0..3' do
+        expected  = [255, 123, 234, 0]
+        colors    = color.to_a
+
+        4.times do |idx|
+          expect( color[idx] ).to eq(expected[idx])
+        end
+      end
+
+      it 'should return nil for anything < 0 or > 3' do
+        expect( color[-2] ).to be_nil
+        expect( color[4] ).to be_nil
+      end
+    end
+
+    describe '#zeros?' do
+      it 'should return true when the color is comprised only by zeros' do
+        zeros = Spyglass::Color.new(0, 0, 0, 0)
+        expect( zeros.zeros? ).to be_true
+      end
+
+      it 'should return false when the color has at least one element that is not zero' do
+        expect( color.zeros? ).to be_false
+      end
+    end
+  end
+end

data/spec/spyglass/contour_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Spyglass::Contour do
+  let(:empty_contour) { Spyglass::Contour.new }
+  let(:contour) do
+    points = 10.times.map { |i| Spyglass::Point.new(i + 1, i + 1) }
+    Spyglass::Contour.new points
+  end
+
+  describe '.new' do
+    it 'should work without arguments' do
+      expect( empty_contour ).to be_a Spyglass::Contour
+    end
+
+    it 'should work with an array of points' do
+      expect { contour }.not_to raise_error
+    end
+  end
+
+  describe '#rect' do
+    it 'should return the bounding rect' do
+      expect( contour.rect.size.width ).to eq(10)
+      expect( contour.rect.size.height ).to eq(10)
+    end
+  end
+end

data/spec/spyglass/gui/window_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Spyglass::GUI::Window, gui: true do
+  let(:window)  { Spyglass::GUI::Window.new("Image preview") }
+  let(:lena)    { Spyglass::Image.load(fixture_path('lena.jpg')) }
+
+  describe '.new' do
+    it 'should require one argument' do
+      expect { Spyglass::GUI::Window.new }.to raise_error ArgumentError
+      expect( window ).to be_a Spyglass::GUI::Window
+    end
+  end
+
+  describe 'accessors' do
+    describe '#title' do
+      it 'should return the correct title' do
+        expect( window.title ).to eq("Image preview")
+      end
+    end
+  end
+end

data/spec/spyglass/image_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Spyglass::Image do
+  let(:lena) { Spyglass::Image.load(fixture_path('lena.jpg')) }
+
+  describe '.load' do
+    it 'should require an argument' do
+      expect { Spyglass::Image.load }.to raise_error ArgumentError
+    end
+
+    it 'should return an instance of OpenCV::Image when passing a path' do
+      expect( Spyglass::Image.load(fixture_path('lena.jpg')) ).to be_a described_class
+    end
+  end
+
+  describe '.zeros' do
+    it 'should require a size' do
+      expect { Spyglass::Image.zeros }.to raise_error ArgumentError
+
+      expect( Spyglass::Image.zeros(Spyglass::Size.new(20, 20)) ).to be_a Spyglass::Image
+    end
+
+    it 'should create an image filled with zeros' do
+      img = Spyglass::Image.zeros Spyglass::Size.new(50, 50)
+      mean = img.mean
+
+      expect( mean.zeros? ).to be_true
+    end
+  end
+
+  describe 'accessors' do
+    describe '#rows' do
+      it 'should return the right number of rows for an image' do
+        expect( lena.rows ).to eq(512)
+      end
+    end
+
+    describe '#cols' do
+      it 'should return the right number of columns for an image' do
+        expect( lena.cols ).to eq(512)
+      end
+    end
+
+    describe '#size' do
+      it 'should be an instance of Spyglass::Size' do
+        expect( lena.size ).to be_a Spyglass::Size
+      end
+
+      it 'should return the correct values' do
+        expect( lena.size.width ).to eq( lena.cols )
+        expect( lena.size.height ).to eq( lena.rows )
+      end
+    end
+  end
+
+  describe '#erode' do
+    it 'should erode the image' do
+      eroded = lena.erode
+
+      expect( eroded.cols ).to eq( lena.cols )
+      expect( eroded.rows ).to eq( lena.rows )
+    end
+  end
+
+  describe '#crop' do
+    it 'should crop the image to the correct proportions' do
+      rect = Spyglass::Rect.new(0, 0, 256, 256)
+      cropped = lena.crop(rect)
+
+      expect( cropped.cols ).to eq(256)
+      expect( cropped.rows ).to eq(256)
+    end
+  end
+
+  describe '#crop!' do
+    it 'should crop the image in place to the correct proportions' do
+      rect = Spyglass::Rect.new(0, 0, 256, 256)
+      lena.crop!(rect)
+
+      expect( lena.cols ).to eq(256)
+      expect( lena.rows ).to eq(256)
+    end
+  end
+
+  describe '#mean' do
+    it 'should return a Spyglass::Color' do
+      expect( lena.mean ).to be_a Spyglass::Color
+    end
+  end
+
+  describe '#write' do
+    it 'should write the image onto disk' do
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, 'lena.jpg')
+
+        res = lena.write(path)
+        expect( File.exists?(path) ).to be_true
+        expect( res ).to be_true
+      end
+    end
+  end
+
+  describe '#copy!' do
+    it 'should copy the image inplace' do
+      im = Spyglass::Image.new
+
+      expect( im.rows ).to eq(0)
+      expect( im.cols ).to eq(0)
+
+      im.copy!(lena)
+
+      expect( im.rows ).to eq(512)
+      expect( im.cols ).to eq(512)
+    end
+  end
+end

data/spec/spyglass/point_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Spyglass::Point do
+  let(:point) { Spyglass::Point.new(10, 20) }
+
+  describe '.new' do
+    it 'should require two arguments' do
+      expect { Spyglass::Point.new }.to raise_error ArgumentError
+      expect( point ).to be_a Spyglass::Point
+    end
+  end
+  
+  describe 'accessors' do
+    describe '#x' do
+      it 'should return the correct X coordinate' do
+        expect( point.x ).to eq(10)
+      end
+    end
+
+    describe '#y' do
+      it 'should return the correct Y coordinate' do
+        expect( point.y ).to eq(20)
+      end
+    end
+  end
+
+  describe 'setters' do
+    describe '#x=' do
+      it 'should set the value of the X coordinate' do
+        point.x = 20
+        expect( point.x ).to eq(20)
+      end
+    end
+    describe '#y=' do
+      it 'should set the value of the Y coordinate' do
+        point.y = 40
+        expect( point.y ).to eq(40)
+      end
+    end
+  end
+end

data/spec/spyglass/rect_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Spyglass::Rect do
+  let(:rect) { Spyglass::Rect.new(10, 20, 100, 200) }
+
+  describe '.new' do
+    it 'should require four arguments' do
+      expect { Spyglass::Rect.new }.to raise_error ArgumentError
+      expect( rect ).to be_a Spyglass::Rect
+    end
+  end
+
+  describe 'accessors' do
+    describe '#x' do
+      it 'should return the correct X coordinate' do
+        expect( rect.x ).to eq(10)
+      end
+    end
+
+    describe '#y' do
+      it 'should return the correct Y coordinate' do
+        expect( rect.y ).to eq(20)
+      end
+    end
+
+    describe '#width' do
+      it 'should return the correct value' do
+        expect( rect.width ).to eq(100)
+      end
+    end
+
+    describe '#height' do
+      it 'should return the correct value' do
+        expect( rect.height ).to eq(200)
+      end
+    end
+
+    describe '#area' do
+      it 'should return `width * height`' do
+        expect( rect.area ).to eq(20_000)
+      end
+    end
+
+    describe '#size' do
+      it 'should be an instance of Spyglass::Size' do
+        expect( rect.size ).to be_a Spyglass::Size
+      end
+
+      it 'should return the correct values' do
+        expect( rect.size.width ).to eq( rect.width )
+        expect( rect.size.height ).to eq( rect.height )
+      end
+    end
+
+    describe '#point' do
+      it 'should be an instance of Spyglass::Point' do
+        expect( rect.point ).to be_a Spyglass::Point
+      end
+
+      it 'should return the correct values' do
+        expect( rect.point.x ).to eq( rect.x )
+        expect( rect.point.y ).to eq( rect.y )
+      end
+    end
+  end
+
+  describe 'setters' do
+    describe '#height=' do
+      it 'should set the value of the height' do
+        rect.height = 150
+
+        expect( rect.height ).to eq(150)
+        expect( rect.area ).to eq(15_000)
+      end
+    end
+
+    describe '#width=' do
+      it 'should set the value of the width' do
+        rect.width = 300
+
+        expect( rect.width ).to eq(300)
+        expect( rect.area ).to eq(60_000)
+      end
+    end
+
+    describe '#x=' do
+      it 'should set the value of the X coordinate' do
+        rect.x = 20
+
+        expect( rect.x ).to eq(20)
+      end
+    end
+
+    describe '#y=' do
+      it 'should set the value of the Y coordinate' do
+        rect.y = 40
+
+        expect( rect.y ).to eq(40)
+      end
+    end
+  end
+
+end