sqed 0.0.4 → 0.1.0

data/spec/lib/sqed/boundaries_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Sqed::Boundaries do
 
-  let(:s) { Sqed::Boundaries.new}
+  let(:s) { Sqed::Boundaries.new } 
   let(:layout) {:horizontal_split}
 
   specify "#coordinates defaults to a Hash when no layout provided" do
@@ -32,4 +32,29 @@ describe Sqed::Boundaries do
     end
   end
 
+  context '#offset' do
+    let(:s) { Sqed.new(image: ImageHelpers.crossy_green_line_specimen, pattern: :offset_cross) }
+    let(:offset_boundaries) { 
+      s.crop_image
+      s.boundaries.offset(s.stage_boundary) 
+    }
+
+    specify "offset and size should match internal found areas " do
+      sbx = s.stage_boundary.x_for(0)
+      sby = s.stage_boundary.y_for(0)
+
+      total_sections =  s.boundaries.coordinates.count
+      expect(offset_boundaries.complete).to be(true)
+
+      (0..total_sections - 1).each do |i|
+        # check all the x/y      
+        expect(offset_boundaries.x_for(i)).to eq(s.boundaries.x_for(i) + sbx)
+        expect(offset_boundaries.y_for(i)).to eq(s.boundaries.y_for(i) + sby)
+
+        # check all width/heights
+        expect(offset_boundaries.width_for(i)).to eq(s.boundaries.width_for(i))
+        expect(offset_boundaries.height_for(i)).to eq(s.boundaries.height_for(i))
+      end
+    end
+  end
 end 

data/spec/lib/sqed/boundary_finder_spec.rb

@@ -104,5 +104,93 @@ describe Sqed::BoundaryFinder do
       expect( Sqed::BoundaryFinder.frequency_stats(i, 15)).to eq(nil)
     end
   end
-  
+
+  context 'offset boundaries from crossy_black_line_specimen image ' do
+    before(:all) {
+      @s = Sqed.new(image: ImageHelpers.crossy_black_line_specimen, pattern: :offset_cross, boundary_color: :black)
+      @s.crop_image
+      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
+      true
+    }
+
+    ##**** actually fails (?!)
+    specify "offset and size should match internal found areas " do     
+      sbx = @s.stage_boundary.x_for(0)
+      sby = @s.stage_boundary.y_for(0)
+
+      sl =  @s.boundaries.coordinates.length  # may be convenient to clone this model for other than 4 boundaries found
+      expect(sl).to eq(4)    #for offset cross pattern and valid image
+      expect(@s.boundaries.complete).to be(true)
+      expect(@offset_boundaries.complete).to be(true)
+      (0..sl - 1).each do |i|
+        # check all the x/y
+        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
+        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
+
+        # check all width/heights
+        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
+        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
+      end
+    end
+  end
+
+  context 'offset boundaries from black_green_line_specimen image ' do
+    before(:all) {
+      @s = Sqed.new(image: ImageHelpers.black_stage_green_line_specimen, pattern: :offset_cross)
+      @s.crop_image
+      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
+      true 
+    }
+
+    specify "offset and size should match internal found areas " do
+      sbx = @s.stage_boundary.x_for(0)
+      sby = @s.stage_boundary.y_for(0)
+
+      sl =  @s.boundaries.coordinates.count  # may be convenient to clone this model for other than 4 boundaries found
+      expect(sl).to eq(4)    #for offset cross pattern and valid image
+      expect(@s.boundaries.complete).to be(true)
+      expect(@offset_boundaries.complete).to be(true)
+      (0..sl - 1).each do |i|
+        # check all the x/y
+        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
+        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
+
+        # check all width/heights
+        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
+        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
+      end
+    end
+  end 
+
+  context 'offset boundaries from original red_line image ' do
+    before(:all) {
+      @s = Sqed.new(image: ImageHelpers.offset_cross_red, pattern: :right_t, boundary_color: :red)
+      @s.crop_image
+      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
+    }
+
+    specify "offset and size should match internal found areas " do
+      sbx = @s.stage_boundary.x_for(0)  # only a single boundary
+      sby = @s.stage_boundary.y_for(0)
+      pct = 0.02
+
+      sl =  @s.boundaries.coordinates.count 
+      expect(sl).to eq(3)   
+      expect(@s.boundaries.complete).to be(true)
+      expect(@offset_boundaries.complete).to be(true)
+      expect(@s.stage_boundary.width_for(0)).to be_within(pct*800).of(800)
+      expect(@s.stage_boundary.height_for(0)).to be_within(pct*600).of(600)
+      (0..sl - 1).each do |i|
+        # check all the x/y
+        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
+        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
+
+        # check all width/heights
+        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
+        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
+      end
+    end
+  end
+
+
 end 

data/spec/lib/sqed/extractor_spec.rb

@@ -1,82 +1,56 @@
 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
+  let(:metadata_map) { 
+    {0 => :specimen, 1 => :identifier, 2 => :nothing, 3 => :image_registration }
+  } 
+ 
+  let(:image) { ImageHelpers.crossy_green_line_specimen }
+
+  let(:boundaries) { 
+    Sqed::BoundaryFinder::CrossFinder.new(
+      image: image
+    ).boundaries
+  }
+
+  let(:e) {
+    Sqed::Extractor.new(
+      boundaries: boundaries,
+      image: image,
+      metadata_map: metadata_map
+    )
+  }
+
+  context 'attributes' do
+    specify '#image' do
+      expect(e).to respond_to(:image)
+    end
+
+    specify '#metadata_map' do
+      expect(e).to respond_to(:metadata_map)
+    end
+ 
+    specify '#boundaries' do
+      expect(e).to respond_to(:boundaries)
+    end
+  end
+
+  context 'extracting to a #result' do
+    let(:r) { e.result }
+    
+    specify '#result retuns a Sqed::Result' do
+      expect(r.class.name).to eq('Sqed::Result')
+    end
+
+    specify '#result is populated with images' do
+      expect(r.images.values.first.class.name).to eq('Magick::Image') 
+    end
+
+    specify '#result is populated with text' do
+      expect(r.text_for(:identifier)).to match('000085067')
+    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)
+end 
 
-#     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/barcode_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+# Test barcodes where generated here: http://www.terryburton.co.uk/barcodewriter/generator/, thanks Terry!
+#
+# http://metafloor.github.io/bwip-js/demo/demo.html
+describe Sqed::Parser::BarcodeParser do
+
+  let(:image) { ImageHelpers.code_128_barcode_image  }
+  let(:p) { Sqed::Parser::BarcodeParser.new(image) }
+  
+
+  specify '#image' do
+    expect(p).to respond_to(:image)
+  end
+
+  specify '#barcode' do
+    expect(p).to respond_to(:barcode)
+  end
+
+  specify '#barcode returns some text' do
+    expect(p.barcode).to eq('Count01234567!')
+  end
+
+end 
+

data/spec/lib/sqed/parser/ocr_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Sqed::Parser::OcrParser do
+
+  let(:image) { ImageHelpers.readme_text  }
+  let(:p) { Sqed::Parser::OcrParser.new(image) }
+
+  specify '#image' do
+    expect(p).to respond_to(:image)
+  end
+
+  specify '#text returns some text' do
+    expect(p.text).to eq('README.md')
+  end
+
+end 

data/spec/lib/sqed/parser_spec.rb

@@ -2,5 +2,10 @@ require 'spec_helper'
 
 describe Sqed::Parser do
 
-  let(:s) {Sqed::Parser.new}
+  let(:image) { ImageHelpers.standard_cross_green  }
+  let(:p) { Sqed::Parser.new(image) }
+
+  specify '#image' do
+    expect(p).to respond_to(:image)
+  end
 end 

data/spec/lib/sqed/result_spec.rb

@@ -4,6 +4,7 @@ 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 
@@ -12,6 +13,29 @@ describe Sqed::Result do
       specify "##{type}_image" do 
         expect(r.respond_to?("#{type}_image".to_sym)).to be_truthy 
       end
+
+      specify "##{type} initializes to {}" do
+        expect(r.send(type.to_sym)).to eq({}) 
+      end
     end
   end
+
+  context 'with a new() result' do
+    specify '#text_for(section)' do
+      expect(r.text_for(:specimen)).to eq(nil)
+    end
+
+    specify '#barcode_text_for(section)' do
+      expect(r.barcode_text_for(:identifier)).to eq(nil)
+    end
+
+    specify '#text' do
+      expect(r.text).to eq({})
+    end
+
+    specify '#images' do
+      expect(r.text).to eq({})
+    end
+  end
+
 end 

data/spec/lib/sqed_spec.rb

@@ -16,6 +16,22 @@ describe Sqed do
     specify '#stage_image' do
       expect(s).to respond_to(:image)
     end
+
+    specify '#stage_boundary' do
+      expect(s).to respond_to(:stage_boundary)
+    end
+
+    specify '#boundaries' do
+      expect(s).to respond_to(:boundaries)
+    end
+
+    specify '#auto_detect_border' do
+      expect(s).to respond_to(:auto_detect_border)
+    end
+
+    specify '#boundary_color' do
+      expect(s).to respond_to(:boundary_color)
+    end
   end
 
   context 'initialization' do 
@@ -24,37 +40,26 @@ describe Sqed do
     end
   end
 
-  context 'asking for a result' do
+  context '#result' do
     specify 'without providing an image returns false' do
       expect(s.result).to eq(false)
     end
   end
 
-  context 'with a test image' do
-    let(:a) { ImageHelpers.test0_image }
-    before {
-      s.image = a
-    }
-
-    specify '#crop_image' do        #should expand to multiple cases of image border types
+  # test intent is to just test wrapping functionality, see
+  # other tests for specifics on finders
+  context '#crop_image (with bordered stage)' do 
+    specify 'finds a cropped image smaller than original' do 
+      s.image = ImageHelpers.test3_image
       expect(s.crop_image).to be_truthy
-      expect(s.stage_image.columns < a.columns).to be(true)
-      expect(s.stage_image.rows < a.rows).to be(true)
-    end
-
-    specify '#boundaries returns a Sqed::Boundaries instance' do
-      s.pattern = :standard_cross
-      expect(s.boundaries.class).to eq(Sqed::Boundaries)
+      expect(s.stage_image.columns < s.image.columns).to be(true)
+      expect(s.stage_image.rows < s.image.rows).to be(true)
     end
-  end
 
-  context 'stage image with a border' do
-    let(:a) { ImageHelpers.standard_cross_green }
-    before {
-      s.image = a
-      s.crop_image
-    }
-    specify 'stage boundary is created for standard_ cross_green ~ (100,94, 800, 600)' do
+    specify 'properly sets stage boundaries ' do
+      s.image = ImageHelpers.standard_cross_green
+      s.crop_image 
+      # ~ (100,94, 800, 600)
       expect(s.stage_boundary.x_for(0)).to be_within(2).of 100
       expect(s.stage_boundary.y_for(0)).to be_within(2).of 94
       expect(s.stage_boundary.width_for(0)).to be_within(2).of 800
@@ -62,139 +67,48 @@ describe Sqed do
     end
   end
 
-  context 'offset boundaries from original crossy_green_line_specimen image ' do
-    before(:all) {
-      @s = Sqed.new(image: ImageHelpers.crossy_green_line_specimen, pattern: :offset_cross)
-      @s.crop_image
-      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
-      wtf = 0
-    }
-
-    specify "offset and size should match internal found areas " do
-      sbx = @s.stage_boundary.x_for(0)
-      sby = @s.stage_boundary.y_for(0)
-
-      sl =  @s.boundaries.coordinates.length  # may be convenient to clone this model for other than 4 boundaries found
-      expect(sl).to eq(4)    #for offset cross pattern and valid image
-      expect(@s.boundaries.complete).to be(true)
-      expect(@offset_boundaries.complete).to be(true)
-      (0..sl - 1).each do |i|
-        # check all the x/y      
-        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
-        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
-
-        # check all width/heights
-        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
-        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
-      end
+  context 'all together' do
+    let(:image) { ImageHelpers.frost_stage }
+    let(:pattern) { :offset_cross }
+    let(:s) { Sqed.new(image: image, pattern: pattern) }
+
+    specify '#boundaries returns a Sqed::Boundaries instance' do
+      # s.pattern = :standard_cross
+      expect(s.boundaries.class.name).to eq('Sqed::Boundaries')
     end
 
-    specify "find image, barcode, and text content" do
-      bc = Sqed::Extractor.new(boundaries: [0, 0, @s.image.columns, @s.image.rows], image: @s.image, layout: :offset_cross)
-      poc = Sqed::Parser::OcrParser.new(bc.extract_image(@offset_boundaries.coordinates[1]))
-      expect(poc.text).to eq('000085067')
+    specify '#stage_image returns an Magick::Image' do
+      expect(s.stage_image.class.name).to eq('Magick::Image')
     end
 
-  end
+    specify '#crop_image returns an Magick::Image' do
+      expect(s.crop_image.class.name).to eq('Magick::Image')
+    end
 
-  context 'offset boundaries from crossy_black_line_specimen image ' do
-    before(:all) {
-      @s = Sqed.new(image: ImageHelpers.crossy_black_line_specimen, pattern: :offset_cross, boundary_color: :black)
-      @s.crop_image
-      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
-      wtf = 0
-    }
-
-    specify "offset and size should match internal found areas " do        ##**** actually fails
-
-      sbx = @s.stage_boundary.x_for(0)
-      sby = @s.stage_boundary.y_for(0)
-
-      sl =  @s.boundaries.coordinates.length  # may be convenient to clone this model for other than 4 boundaries found
-      expect(sl).to eq(4)    #for offset cross pattern and valid image
-      expect(@s.boundaries.complete).to be(true)
-      expect(@offset_boundaries.complete).to be(true)
-      (0..sl - 1).each do |i|
-        # check all the x/y
-        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
-        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
-
-        # check all width/heights
-        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
-        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
-      end
+    specify '#crop_image returns #stage_image' do
+      expect(s.crop_image).to eq(s.stage_image)
     end
-  end
 
-  context 'offset boundaries from  black_green_line_specimen image ' do
-    before(:all) {
-      @s = Sqed.new(image: ImageHelpers.black_stage_green_line_specimen, pattern: :offset_cross)
-      @s.crop_image
-      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
-      wtf = 0
-    }
-
-    specify "offset and size should match internal found areas " do
-      sbx = @s.stage_boundary.x_for(0)
-      sby = @s.stage_boundary.y_for(0)
-
-      sl =  @s.boundaries.coordinates.length  # may be convenient to clone this model for other than 4 boundaries found
-      expect(sl).to eq(4)    #for offset cross pattern and valid image
-      expect(@s.boundaries.complete).to be(true)
-      expect(@offset_boundaries.complete).to be(true)
-      (0..sl - 1).each do |i|
-        # check all the x/y
-        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
-        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
-
-        # check all width/heights
-        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
-        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
+    context '#result' do
+      let(:r) { s.result }
+      specify 'returns a Sqed::Result' do
+        expect(r.class.name).to eq('Sqed::Result')
       end
-    end
 
-    specify "find image, barcode, and text content" do
-      bc = Sqed::Extractor.new(boundaries: [0, 0, @s.image.columns, @s.image.rows], image: @s.image, layout: :offset_cross)
-      # ioc = bc.extract_image(@offset_boundaries.coordinates[3])
-      # iioc = ioc.crop(384, 140, 1420, 572, true)
-      poc = Sqed::Parser::OcrParser.new(bc.extract_image(@offset_boundaries.coordinates[3]).crop(400, 140, 1420, 600, true))
-      # expect(poc.text).to eq('000085067')
-      ppc = Sqed::Parser::OcrParser.new(ImageHelpers.black_stage_green_line_specimen_label)
-      poc.image.write('tmp/poc.jpg')
-      ppc.image.write('tmp/ppc.jpg')
-      expect(ppc.text).to eq(poc.text)
-    end
+      context 'extracted data' do
+        specify 'for an :identifier section' do
+          expect(r.text_for(:identifier)).to match('000041196')
+        end
 
-  end
+        specify 'for a specimen section' do
+          expect(r.text_for(:specimen)).to match('Saucier Creek')
+        end
 
-  context 'offset boundaries from original red_line image ' do
-    before(:all) {
-      @s = Sqed.new(image: ImageHelpers.offset_cross_red, pattern: :right_t, boundary_color: :red)
-      @s.crop_image
-      @offset_boundaries = @s.boundaries.offset(@s.stage_boundary)
-      wtf = 0
-    }
-
-    specify "offset and size should match internal found areas " do
-      sbx = @s.stage_boundary.x_for(0)  # only a single boundary
-      sby = @s.stage_boundary.y_for(0)
-      pct = 0.02
-
-      sl =  @s.boundaries.coordinates.length  # may be convenient to clone this model for other than 4 boundaries found
-      expect(sl).to eq(3)    #for offset cross pattern and valid image
-      expect(@s.boundaries.complete).to be(true)
-      expect(@offset_boundaries.complete).to be(true)
-      expect(@s.stage_boundary.width_for(0)).to be_within(pct*800).of(800)
-      expect(@s.stage_boundary.height_for(0)).to be_within(pct*600).of(600)
-      (0..sl - 1).each do |i|
-        # check all the x/y
-        expect(@offset_boundaries.x_for(i)).to eq(@s.boundaries.x_for(i) + sbx)
-        expect(@offset_boundaries.y_for(i)).to eq(@s.boundaries.y_for(i) + sby)
-
-        # check all width/heights
-        expect(@offset_boundaries.width_for(i)).to eq(@s.boundaries.width_for(i))
-        expect(@offset_boundaries.height_for(i)).to eq(@s.boundaries.height_for(i))
+        specify 'for a curator_metadata section' do
+          expect(r.text_for(:curator_metadata)).to match('Frost Entomological Museum')
+        end
       end
     end
   end
+
 end