sqed 0.0.1

data/spec/lib/sqed/boundaries_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Sqed::Boundaries do
+
+  let(:s) { Sqed::Boundaries.new}
+  let(:layout) {:horizontal_split}
+
+  specify "#coordinates defaults to a Hash when no layout provided" do
+    expect(s.coordinates).to eq({})
+  end
+
+  context 'with a layout provided' do
+    before {
+      s.layout = layout
+    }
+
+    specify "coordinates can be initialized after the fact (bad idea likely)" do
+      expect(s.initialize_coordinates).to be_truthy
+    end
+
+    specify "#coordinates has one coordinate system for each section (key in layout)" do
+      s.initialize_coordinates
+      expect(s.coordinates.keys.sort).to eq([0,1])
+    end
+
+    specify "#each" do
+      s.initialize_coordinates
+      s.each do |k,v|
+        expect([0,1].include?(k)).to be(true) 
+        expect(v).to eq([nil, nil, nil, nil])
+      end
+    end
+  end
+
+end 

data/spec/lib/sqed/boundary_finder/color_line_finder_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Sqed::BoundaryFinder::ColorLineFinder do 
+
+  let(:image) { ImageHelpers.crossy_green_line_specimen }
+
+  let(:b) { Sqed::BoundaryFinder::StageFinder.new(image: image) }
+  let(:c) {b.boundaries}
+  let(:d) { image.crop(*c.for(0), true) }
+  
+  let(:e) { Sqed::BoundaryFinder::ColorLineFinder.new(image: d, layout: :right_t) }
+  let(:f) { e.boundaries }
+  let(:g) { Sqed::BoundaryFinder::ColorLineFinder.new(image: d, layout: :offset_cross)}
+  let(:h) { g.boundaries }
+  let(:gv) { Sqed::BoundaryFinder::ColorLineFinder.new(image: d, layout: :vertical_split) }
+  let(:hv) { gv.boundaries }
+ 
+  let(:ah) { ImageHelpers.offset_cross_red }
+  let(:bh) { Sqed::BoundaryFinder::StageFinder.new(image: ah) }
+  let(:ch) { bh.boundaries }
+  let(:dh) { ah.crop(*ch.for(0), true) }
+  let(:gh) { Sqed::BoundaryFinder::ColorLineFinder.new(image: dh, layout: :horizontal_split, boundary_color: :red) } # was :horizontal_split
+  let(:hh) { gh.boundaries }
+
+  let(:ibs) { ImageHelpers.black_stage_green_line_specimen } 
+  let(:bbs) { Sqed::BoundaryFinder::StageFinder.new(image: ibs) } 
+  let(:cbs) { bbs.boundaries }
+  let(:dbs) { ibs.crop(*cbs.for(0), true) }
+  let(:gbs) { Sqed::BoundaryFinder::ColorLineFinder.new(image: dbs, layout: :offset_cross) }
+  let(:hbs) { gbs.boundaries }
+
+  specify 'initial image columns are as expected for :image above' do
+    expect(image.columns).to eq(3264)
+    expect(image.rows).to eq(2452)
+  end
+
+  context 'stage image is properly found (sanity check, should be tests in stage finder)' do
+    specify 'stage image boundaries are correct' do
+      pct = 0.02
+      expect(in_range(c.x_for(0), pct, 407)).to be(true)
+      expect(in_range(c.y_for(0), pct, 301)).to be(true)
+      expect(in_range(c.width_for(0), pct, 2587)).to be(true)
+      expect(in_range(c.height_for(0), pct, 1990)).to be(true)
+    end
+
+    specify 'stage image size is correct' do
+      expect(d.columns).to be_within(50).of(2587)
+      expect(d.rows).to be_within(40).of(1990)
+    end
+  end
+
+  specify "CrossGreenLinesSpecimen using right_t layout should yield 3 rectangular boundaries" do
+    # use the f object for right_t
+    f.each do |i, coord| 
+      q = d.crop(*coord, true)
+      q.write("tmp/q0#{i}.jpg")
+    end
+
+    expect(f.count).to eq(3)
+    pct = 0.02
+    
+    expect(f.x_for(0)).to be_within(1).of(1)
+    expect(f.y_for(0)).to be_within(1).of(1)
+    expect(f.width_for(0)).to be_within(pct*2051).of(2051)
+    expect(f.height_for(0)).to be_within(pct*1990).of(1990)
+
+    expect(f.x_for(1)).to be_within(pct*2099).of(2099)
+    expect(f.y_for(1)).to be_within(1).of(1)
+    expect(f.width_for(1)).to be_within(pct*438).of(488)
+    expect(f.height_for(1)).to be_within(pct*987).of(987)
+
+    expect(f.x_for(2)).to be_within(pct*2099).of(2099)
+    expect(f.y_for(2)).to be_within(pct*1026).of(1026)
+    expect(f.width_for(2)).to be_within(pct*488).of(488)
+    expect(f.height_for(2)).to be_within(pct*964).of(964)
+  end
+
+  specify "CrossGreenLinesSpecimen using offset_cross layout should yield 4 rectangular boundaries" do
+    h.each do |i, coord|
+      q = d.crop(*coord, true)
+      q.write("tmp/q1#{i}.jpg")
+    end
+
+    expect(h.count).to eq(4)
+
+    pct = 0.02
+
+    expect(h.x_for(0)).to be_within(pct*2099).of(0)
+    expect(h.y_for(0)).to be_within(pct*0).of(0)
+    expect(h.width_for(0)).to be_within(pct*2051).of(2051)
+    expect(h.height_for(0)).to be_within(pct*1054).of(1054)
+
+    expect(h.x_for(1)).to be_within(pct*2099).of(2099)
+    expect(h.y_for(1)).to be_within(pct*0).of(0)
+    expect(h.width_for(1)).to be_within(pct*488).of(488)
+    expect(h.height_for(1)).to be_within(pct*987).of(987)
+
+    expect(h.x_for(2)).to be_within(pct*2099).of(2099)
+    expect(h.y_for(2)).to be_within(pct*1026).of(1026)
+    expect(h.width_for(2)).to be_within(pct*488).of(488)
+    expect(h.height_for(2)).to be_within(pct*964).of(964)
+
+    expect(h.x_for(3)).to be_within(0).of(0)
+    expect(h.y_for(3)).to be_within(pct*1093).of(1093)
+    expect(h.width_for(3)).to be_within(pct*2051).of(2051)
+    expect(h.height_for(3)).to be_within(pct*897).of(897)
+  end
+
+  specify "CrossGreenLinesSpecimen using vertical_split layout should yield 2 rectangular boundaries" do
+    hv.each do |k, v|
+      q = d.crop(*v, true)
+      q.write("tmp/q2#{k}.jpg")
+    end
+    expect(hv.count).to eq(2)
+
+    expect(hv.x_for(0)).to be_within(0.02*0).of(0)
+    expect(hv.y_for(0)).to be_within(0.02*0).of(0)
+    expect(hv.width_for(0)).to be_within(0.02*2051).of(2051)
+    expect(hv.height_for(0)).to be_within(0.02*1990).of(1990)
+
+    expect(hv.x_for(1)).to be_within(0.02*2099).of(2099)
+    expect(hv.y_for(1)).to be_within(0.02*0).of(0)
+    expect(hv.width_for(1)).to be_within(0.02*488).of(488)
+    expect(hv.height_for(1)).to be_within(0.02*1990).of(1990)
+  end
+
+  specify "boundary_offset_cross_red using horizontal_split layout should yield 2 rectangular boundaries" do
+    hh.each do |k, v|
+      q = dh.crop(*v, true)
+      q.write("tmp/q3#{k}.jpg")
+    end
+
+    expect(hh.count).to eq(2)
+    expect([[0, 0, 798, 146] , [0, 0, 799, 145]]).to include(hh.coordinates[0])    # for quadrant 0
+    expect(hh.coordinates[0]).to eq([0, 0, 799, 145]).or eq([0, 0, 798, 146])      # for quadrant 0
+    expect(hh.coordinates[1]).to eq([0, 154, 799, 445])                            # for quadrant 1
+  end
+
+  specify "offset cross method on black stage specimen should yield 4 rectangular boundaries for 0" do
+    (hbs.first[0]..hbs.count - 1).each do |j|
+      q = dbs.crop(*hbs.for(j), true)
+      q.write("tmp/qb#{j}.jpg")
+    end
+    expect(hbs.coordinates.keys.count).to eq(4)
+
+    pct = 0.02
+
+    expect(hbs.width_for(0)).to be_within(pct*2999).of(2999)
+    expect(hbs.height_for(0)).to be_within(pct*506).of(506)
+  end
+
+  specify "offset cross method on black stage specimen should yield 4 rectangular boundaries for 1" do
+    expect(hbs.width_for(1)).to be_within(0.02*447).of(447)
+    expect(hbs.height_for(1)).to be_within(0.02*487).of(487)
+  end
+
+  specify "offset cross method on black stage specimen should yield 4 rectangular boundaries for 2" do
+    expect(hbs.width_for(2)).to be_within(0.02*447).of(447)
+    expect(hbs.height_for(2)).to be_within(0.02*1680).of(1680)
+  end
+
+  specify "offset cross method on black stage specimen should yield 4 rectangular boundaries for 3" do
+    expect(hbs.width_for(3)).to be_within(0.02*2999).of(2999)
+    expect(hbs.height_for(3)).to be_within(0.02*1677).of(1677)
+  end
+
+end

data/spec/lib/sqed/boundary_finder/cross_finder_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Sqed::BoundaryFinder::CrossFinder do
+  let(:image) { ImageHelpers.of_size(800, 600) }
+  let(:b) {Sqed::BoundaryFinder::CrossFinder.new(image: image)}
+  let(:c) {b.boundaries}
+
+  specify '#boundaries returns a Sqed::Boundaries instance' do
+    expect(b.boundaries.class).to eq(Sqed::Boundaries)
+  end
+
+  specify 'the 0th image starts at x = 0' do
+    expect(c.x_for(0)).to eq(0)
+  end
+
+  specify 'the 0th image starts at y = 0' do
+    expect(c.y_for(0)).to eq(0)
+  end
+
+  specify 'the 0th image has width = 400' do
+    expect(c.width_for(0)).to eq(400)
+  end
+
+  specify 'the 0th image has height = 300' do
+    expect(c.height_for(0)).to eq(300)
+  end
+
+end 

data/spec/lib/sqed/boundary_finder/stage_finder_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Sqed::BoundaryFinder::StageFinder do 
+  let(:b) {Sqed::BoundaryFinder::StageFinder.new(image: ImageHelpers.standard_cross_green )}
+
+  specify '#is border contains a proc' do
+    expect(b.is_border.class).to eq(Proc)
+  end 
+end

data/spec/lib/sqed/boundary_finder_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Sqed::BoundaryFinder do
+
+  specify 'when no image provided, #new raises' do
+    expect { Sqed::BoundaryFinder.new() }.to raise_error
+  end
+
+  context 'when initiated with an image' do
+    let(:b) {Sqed::BoundaryFinder.new(image: ImageHelpers.standard_cross_green, layout: :offset_cross)}
+
+    context 'attributes' do
+      specify '#img' do
+        expect(b).to respond_to(:img)
+      end
+    end
+
+    specify '#boundaries' do
+      expect(b.boundaries.class).to eq(Sqed::Boundaries)
+    end
+  end
+
+  context '.color_boundary_finder(image: image, sample_subdivision: 10)' do
+    specify 'finds the vertical dividing line in a standard cross, with border still present' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.standard_cross_green)[1]
+      expect(center).to be > 492
+      expect(center).to be < 504
+    end
+
+    specify 'finds the vertical dividing line in a standard cross, with border still present, when more precise' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.standard_cross_green, sample_cutoff_factor: 0.7)[1]
+      expect(center).to be > 492
+      expect(center).to be < 504
+    end
+
+    specify 'finds the vertical dividing line in a right t green cross, with border still present' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.right_t_green)[1]
+      expect(center).to be > 695
+      expect(center).to be < 705 
+    end
+
+    specify 'finds the vertical dividing line a real image, with border still present' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.crossy_green_line_specimen)[1]
+      expect(center).to be > 2452
+      expect(center).to be < 2495 
+    end
+
+    specify 'finds the vertical dividing line a real image, with border still present, with 10x fewer subsamples' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.crossy_green_line_specimen, sample_subdivision_size: 100 )[1]
+      expect(center).to be > 2452
+      expect(center).to be < 2495 
+    end
+
+    specify 'finds the vertical dividing line a real image, with border still present, with 50x fewer subsamples' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.crossy_green_line_specimen, sample_subdivision_size: 500 )[1]
+      expect(center).to be > 2452
+      expect(center).to be < 2495 
+    end
+
+    specify 'FAILS to find the vertical dividing line a real image, with border still present, with 200x fewer subsamples' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.crossy_green_line_specimen, sample_subdivision_size: 2000 )
+      expect(center).to be nil
+    end
+
+    specify 'finds the vertical dividing line another real image, with border still present' do
+      center = Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.greenline_image)[1]
+      expect(center).to be > 2445
+      expect(center).to be < 2495
+    end
+
+    specify 'finds the vertical dividing line another real image, with border still present, and 20x fewer subsamples' do
+      center = Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.greenline_image, sample_subdivision_size: 200)[1]
+      expect(center).to be > 2445
+      expect(center).to be < 2495
+    end
+
+    specify 'finds the vertical dividing line another real image, with border still present, and 50x fewer subsamples' do
+      center = Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.greenline_image, sample_subdivision_size: 500)[1]
+      expect(center).to be > 2445
+      expect(center).to be < 2495
+    end
+
+    specify 'FAILS to find the vertical dividing line in a standard cross, with border still present, when even more precise' do
+      center =  Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.standard_cross_green, sample_cutoff_factor: 1)
+      expect(center).to be nil
+    end
+
+    specify 'finds the horizontal dividing line another real image, with border still present' do
+      center = Sqed::BoundaryFinder.color_boundary_finder(image: ImageHelpers.greenline_image, scan: :columns)[1]
+      expect(center).to be > 1282
+      expect(center).to be < 1332 
+    end
+
+  end
+
+  context '.frequency_stats(frequency_hash, samples_taken)' do
+    # i is a Hash of position => count (it is unordered, but constructed ordered here in assignment)
+    let(:i) { {1 => 1, 2 => 3, 3 => 15, 4 => 14, 5 => 13 }}
+    specify 'returns the median position (rounds up)' do
+      expect( Sqed::BoundaryFinder.frequency_stats(i, 12)).to eq([3, 4, 5])
+    end
+
+    specify 'returns nil if no count is greater than samples taken' do
+      expect( Sqed::BoundaryFinder.frequency_stats(i, 15)).to eq(nil)
+    end
+  end
+  
+end 

data/spec/lib/sqed/extractor_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Sqed::Extractor do
+
+  let(:s) {Sqed::Extractor.new}
+
+# context 'attributes' do
+#   specify '#image' do
+#     # expect that s.image is a method
+#     expect(s).to respond_to(:image)
+#   end
+
+#   specify 'autocropper/edgeDetector works' do
+#     this_image = ImageHelpers.ocr_image
+#     expect(Sqed::AutoCropper.new(this_image)).to be_truthy
+#   end
+
+#   specify 'Sqed.new(image: file) assigns to image' do
+#     specify 'Sqed.new(image:file) "works"' do
+#       expect(Sqed.new(image: ImageHelpers.test0_image)).to be_truthy
+#     end
+#   end
+
+#   specify 'green line parser does something' do
+#     this_image = ImageHelpers.greenline_image
+#     cropped_image = Sqed::AutoCropper.new(this_image).img
+#     a = Sqed::GreenLineFinder.new(cropped_image)
+#     b = 0
+#   end
+
+#   specify 'Sqed.new(image: file) assigns to image' do
+#     a = Sqed.new(image: ImageHelpers.test0_image)
+#     expect(a.image == ImageHelpers.test0_image).to be(true)
+#   end
+# end
+
+# specify 'zbar barcode decodes' do
+#   eb = Sqed::BarcodeParser.new(image: ImageHelpers.barcode_image)  # was barcode_image
+#   bc = eb.barcodes
+#   expect(bc).to be_truthy
+#   expect(bc[2]).to eq('CODE-128:013117001040986')
+#   expect(bc[3]).to eq('CODE-128:SDLXHD1QTDVGJ')
+#   expect(bc[4]).to eq('CODE-128:1PPD368LL/A')
+#   expect(bc[5]).to eq('EAN-13:0885909541171')
+#   expect(bc[6]).to eq('EAN-13:885909270334')
+#   expect(bc[7]).to be(nil)
+# end
+
+# specify 'INHS specimen labels' do
+#   eg = Sqed.new(image: ImageHelpers.labels_image)
+#   # eg = Sqed.new(image: ImageHelpers.foo3_image)
+#   eg.image.rotate!(270.0)
+#   eg.image.write('foo5.jpg')
+#   egt = eg.text_from_quadrant(3)
+#   expect(egt).to match(/529 234/)
+# end
+
+# context "foo.jpg" do
+#   let(:eg) { Sqed.new(image: ImageHelpers.ocr_image) }
+
+#   specify 'all together' do
+#     # eg = Sqed.new(image: ImageHelpers.ocr_image)
+#     egt = eg.text_from_quadrant(3)
+
+#     expect(egt).to match(/Designed by Apple in California/)
+#     expect(egt).to match(/8 85909 27035/)
+#     expect(egt).to match(/EASY/)
+#     expect(eg.text_from_quadrant(3)).to match(/013‘1700104U986/)  #ACTUALLY 013117001040986
+
+#     eg = Sqed.new(image: ImageHelpers.ocr_image)
+#     egb = eg.text_from_quadrant(2)
+#     u = 1  #pre-test breakpoint
+#     expect(egb.barcodes[0]).to eq('QR-Code:http://youtu.be/h9fkPPp8Y1c')
+#     expect(egb.barcodes[1]).to eq('EAN-13:0885909270354')
+#     expect(egb.barcodes[2]).to eq('CODE-128:013117001040986')
+#     expect(egb.barcodes[3]).to eq('CODE-128:SDLXHD1QTDVGJ')
+#     expect(egb.barcodes[4]).to eq('CODE-128:1PPD368LL/A')
+#     expect(egb.barcodes[5]).to eq('EAN-13:0885909541171')
+#     expect(egb.barcodes[6]).to be(nil)
+#   end
+# end
+end 

data/spec/lib/sqed/parser_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Sqed::Parser do
+
+  let(:s) {Sqed::Parser.new}
+end 

data/spec/lib/sqed/result_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Sqed::Result do
+  let(:r) {Sqed::Result.new}
+
+  context "attributes are derived from SqedConfig::LAYOUT_SECTION_TYPES" do
+    SqedConfig::LAYOUT_SECTION_TYPES.each do |type|
+      specify "##{type}" do 
+        expect(r.respond_to?(type.to_sym)).to be_truthy 
+      end
+
+      specify "##{type}_image" do 
+        expect(r.respond_to?("#{type}_image".to_sym)).to be_truthy 
+      end
+    end
+  end
+end