mork 0.1.3 → 0.2.1

data/mork.gemspec

@@ -18,9 +18,9 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # dependencies:
-  s.add_dependency 'narray',    '~> 0.6'
-  s.add_dependency 'rmagick',   '~> 2.13'
-  s.add_runtime_dependency 'prawn', '~> 1.3', '>= 1.3.0'
+  s.add_dependency 'narray',      '~> 0.6'
+  s.add_dependency 'mini_magick', '~> 3.8'
+  s.add_dependency 'prawn',       '~> 1.3'
   s.add_development_dependency 'rake',          '~> 10.3'
   s.add_development_dependency 'rspec',         '~>  3.1'
   s.add_development_dependency 'guard',         '~>  2.6'

data/spec/mork/grid_omr_spec.rb

@@ -2,73 +2,76 @@ require 'spec_helper'
 
 module Mork
   describe GridOMR do
-    let(:grom) { GridOMR.new 1601, 2281, 'spec/samples/layout.yml' }
+    before(:each) do
+      @grom = GridOMR.new 'spec/samples/layout.yml'
+      @grom.set_page_size 1601, 2281
+    end
       
     describe '#choice_cell_area' do
       it 'returns the coordinates of the first choice cell' do
-        grom.choice_cell_area(0,0).should == {x: 63, y: 436, w: 51, h: 41}
+        @grom.choice_cell_area(0,0).should == {x: 63, y: 436, w: 51, h: 41}
       end
       
       it 'returns the coordinates of the last choice cell' do
-        grom.choice_cell_area(119,4).should == {x: 1411, y: 2108, w: 51, h: 41}
+        @grom.choice_cell_area(119,4).should == {x: 1411, y: 2108, w: 51, h: 41}
       end
     end
     
     describe '#barcode_bit_area' do
       # it 'returns the coordinates of the first barcode bit area' do
-      #   grom.barcode_bit_area(0).should == {x: 160, y: 2260, w: 25, h: 21}
+      #   @grom.barcode_bit_area(0).should == {x: 160, y: 2260, w: 25, h: 21}
       # end
       #
       # it 'returns the coordinates of the last barcode bit area' do
-      #   grom.barcode_bit_area(39).should == {x: 1475, y: 2260, w: 25, h: 21}
+      #   @grom.barcode_bit_area(39).should == {x: 1475, y: 2260, w: 25, h: 21}
       # end
       #
       # it 'fails if an invalid barcode bit is requested' do
-      #   lambda { grom.barcode_bit_area(40) }.should raise_error
+      #   lambda { @grom.barcode_bit_area(40) }.should raise_error
       # end
     end
 
     describe '#rm_search_area' do
       context 'on the first iteration' do
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tl reg_mark corner' do
-          c = grom.rm_search_area :tl, 0
+          c = @grom.rm_search_area :tl, 0
           c.should == {x: 15, y: 15, w: 91, h: 92}
         end
 
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tr reg_mark corner' do
-          c = grom.rm_search_area :tr, 0
+          c = @grom.rm_search_area :tr, 0
           c.should == { x: 1494, y: 15, w: 91, h: 92 }
         end
 
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :br reg_mark corner' do
-          c = grom.rm_search_area :br, 0
+          c = @grom.rm_search_area :br, 0
           c.should == { x: 1494, y: 2173, w: 91, h: 92 }
         end
 
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :bl reg_mark corner' do
-          c = grom.rm_search_area :bl, 0
+          c = @grom.rm_search_area :bl, 0
           c.should == { x: 15, y: 2173, w: 91, h: 92 }
         end
       end
 
       context 'on the third iteration' do
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tl reg_mark corner' do
-          c = grom.rm_search_area :tl, 2
+          c = @grom.rm_search_area :tl, 2
           c.should == { x: 15, y: 15, w: 130, h: 131 }
         end
 
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tr reg_mark corner' do
-          c = grom.rm_search_area :tr, 2
+          c = @grom.rm_search_area :tr, 2
           c.should == { x: 1456, y: 15, w: 130, h: 131 }
         end
 
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :br reg_mark corner' do
-          c = grom.rm_search_area :br, 2
+          c = @grom.rm_search_area :br, 2
           c.should == { x: 1456, y: 2135, w: 130, h: 131 }
         end
 
         it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :bl reg_mark corner' do
-          c = grom.rm_search_area :bl, 2
+          c = @grom.rm_search_area :bl, 2
           c.should == { x: 15, y: 2135, w: 130, h: 131 }
         end
       end
@@ -76,46 +79,46 @@ module Mork
     
     describe '#rm_edgy_x' do
       it 'returns the minimum acceptable number of pixels from the regmark center to the edge of the rm_search_area' do
-        grom.rm_edgy_x.should == 24
+        @grom.rm_edgy_x.should == 24
       end
       it 'returns an integer' do
-        grom.rm_edgy_x.should be_a Fixnum
+        @grom.rm_edgy_x.should be_a Fixnum
       end
     end
 
     describe '#rm_edgy_y' do
       it 'returns the minimum acceptable number of pixels from the regmark center to the edge of the rm_search_area' do
-        grom.rm_edgy_y.should == 24
+        @grom.rm_edgy_y.should == 24
       end
       it 'returns an integer' do
-        grom.rm_edgy_y.should be_a Fixnum
+        @grom.rm_edgy_y.should be_a Fixnum
       end
     end
     
     describe '#rm_max_search_area_side' do
       it 'returns the maximum extent of the regmark search area, 1/4 of the raw image horizontal pixels' do
-        grom.rm_max_search_area_side.should == 400
+        @grom.rm_max_search_area_side.should == 400
       end
       it 'returns an integer' do
-        grom.rm_max_search_area_side.should be_a Fixnum
+        @grom.rm_max_search_area_side.should be_a Fixnum
       end
     end
 
     describe '#max_choices_per_question' do
       it 'returns the maximum number of choice cells per question' do
-        grom.max_choices_per_question.should == 5
+        @grom.max_choices_per_question.should == 5
       end
     end
     
     describe '#paper_white_area' do
       it 'returns the coordinates of the white area used for barcode calibration' do
-        grom.paper_white_area.should == {x: 93, y: 2260, w: 25, h: 21}
+        @grom.paper_white_area.should == {x: 93, y: 2260, w: 25, h: 21}
       end
     end
     
     describe '#ink_black_area' do
       it 'returns the coordinates of the barcode calibration bar' do
-        grom.ink_black_area.should == {x: 126, y: 2260, w: 25, h: 21}
+        @grom.ink_black_area.should == {x: 126, y: 2260, w: 25, h: 21}
       end
     end
   end

data/spec/mork/mimage_list_spec.rb

@@ -1,37 +1,37 @@
 require 'spec_helper'
 
 module Mork
-  describe MimageList do
-    before(:all) do
-      tpg = sample_img(:two_pages)
-      @mlist = MimageList.new(tpg.filename)
-    end
-    
-    describe ".new" do
-      it "should raise an error unless called with a string" do
-        lambda {
-          MimageList.new(666)
-        }.should raise_error
-      end
-    end
-    
-    describe "[]" do
-      it "should return the 1st mimage in the stack" do
-        @mlist[0].should be_a(Mimage)
-      end
-      
-      it "should return the last mimage in the stack" do
-        @mlist[1].should be_a(Mimage)
-      end
-    end
-    
-    describe "each" do
-      it "should loop over all images" do
-        @mlist.each do |m|
-          puts m.inspect
-          m.should be_a(Mimage)
-        end
-      end
-    end
-  end
+  # describe MimageList do
+  #   before(:all) do
+  #     tpg = sample_img(:two_pages)
+  #     @mlist = MimageList.new(tpg.filename)
+  #   end
+  #
+  #   describe ".new" do
+  #     it "should raise an error unless called with a string" do
+  #       lambda {
+  #         MimageList.new(666)
+  #       }.should raise_error
+  #     end
+  #   end
+  #
+  #   describe "[]" do
+  #     it "should return the 1st mimage in the stack" do
+  #       @mlist[0].should be_a(Mimage)
+  #     end
+  #
+  #     it "should return the last mimage in the stack" do
+  #       @mlist[1].should be_a(Mimage)
+  #     end
+  #   end
+  #
+  #   describe "each" do
+  #     it "should loop over all images" do
+  #       @mlist.each do |m|
+  #         puts m.inspect
+  #         m.should be_a(Mimage)
+  #       end
+  #     end
+  #   end
+  # end
 end

data/spec/mork/mimage_spec.rb

@@ -2,46 +2,47 @@ require 'spec_helper'
 
 module Mork
   describe Mimage do
-    let(:smp) { sample_img(:sample01) }
-    let(:mim) { Mimage.new(smp.filename) }
+    let(:sgi) { sample_img 'sample-gray' }
+    let(:sg)  { Mimage.new sgi.filename, GridOMR.new(sgi.grid_file) }
     
-    describe ".new" do
-      it "should create a Mimage from a string pointing to an existing bitmap file" do
-        mim.should be_a(Mimage)
+    describe 'basics' do
+      it 'returns the width' do
+        expect(sg.width).to eq sgi.width
       end
-      it "should create a Mimage from an existing Magick::ImageList object" do
-        i = Magick::ImageList.new smp.filename
-        Mimage.new(i).should be_a(Mimage)
+      
+      it 'returns the height' do
+        expect(sg.height).to eq sgi.height
       end
-      it "should create a Mimage from an existing Magick::Image object" do
-        i = Magick::ImageList.new smp.filename
-        Mimage.new(i.first).should be_a(Mimage)
+      
+      it 'returns the pixels as an array' do
+        expect(sg.send :raw_pixels).to be_a NPatch
       end
-      it "should raise an error if called with a fixnum" do
-        lambda { Mimage.new 1 }.should raise_error
+      
+      it 'returns the correct number of pixels' do
+        expect(sg.send(:raw_pixels).length).to eq sgi.width * sgi.height
       end
-    end
-    
-    describe "#crop" do
-      it "should return a Mimage" do
-        mim.crop({x: 0, y: 0, w: 10, h: 10}).should be_a(Mimage)
-      end
-      it "should return a Mimage of the correct width" do
-        i = mim.crop({x: 0, y: 0, w: 20, h: 10})
-        i.width.should == 20
+
+      it 'returns the stretched array' do
+        expect(sg.send(:reg_pixels).length).to eq sgi.width * sgi.height
       end
-      it "should return a Mimage of the correct height" do
-        i = mim.crop({x: 0, y: 0, w: 10, h: 10})
-        i.height.should == 10
+      
+      it 'raises an error if the file is not found' do
+        expect { Mimage.new 'non_existing_file' }.to raise_error
       end
     end
-    
-    describe "#crop!" do
-      it "should reduce the Mimage to the correct width" do
-        mim.crop!({x: 0, y: 0, w: 20, h: 10}).width.should == 20
-      end
-      it "should reduce the Mimage to the correct height" do
-        mim.crop!({x: 0, y: 0, w: 20, h: 10}).height.should == 10
+
+    describe 'inspecting' do
+      it 'writes out average whiteness of choice cells' do
+        qz = sample_img 'silvia'
+        s = Mimage.new qz.filename, GridOMR.new(qz.grid_file)
+        File.open('spec/out/choices.txt', 'w') do |f|
+          120.times do |q|
+            t = (0..4).collect do |c|
+              s.send(:shade_of, q, c).round
+            end
+            f.puts "#{q+1}: #{t.join(' ')}"
+          end
+        end
       end
     end
   end

data/spec/mork/npatch_spec.rb

@@ -2,26 +2,49 @@ require 'spec_helper'
 
 module Mork
   describe NPatch do
-    let(:rgm) { sample_img(:reg_mark) }
-    let(:mim) { Mimage.new(rgm.filename) }
+    let(:rm) { NPatch.new 'spec/samples/rm01.jpeg', 134, 104 }
     
     describe ".new" do
       it "should create an NPatch" do
-        NPatch.new(mim).should be_an(NPatch)
+        expect(rm).to be_an NPatch
       end
     end
     
-    describe "#dark_centroid" do
-      it "should return the correct X" do
-        x, y = NPatch.new(mim).dark_centroid
-        x.should == rgm.info["centroid_x"]
+    describe '#dark_centroid' do
+      it 'computes centers for rm01' do
+        np = NPatch.new 'spec/samples/rm01.jpeg', 134, 104
+        expect(np.dark_centroid).to eq [50, 60]
+        np = NPatch.new 'spec/samples/rm02.jpeg', 114, 117
+        expect(np.dark_centroid).to eq [69, 71]
+        np = NPatch.new 'spec/samples/rm03.jpeg', 124, 105
+        expect(np.dark_centroid).to eq [71, 61]
+        np = NPatch.new 'spec/samples/rm04.jpeg', 144, 117
+        expect(np.dark_centroid).to eq [84, 52]
+        np = NPatch.new 'spec/samples/rm05.jpeg', 144, 117
+        expect(np.dark_centroid).to eq [84, 52]
       end
-      
-      it "should return the correct Y" do
-        x, y = NPatch.new(mim).dark_centroid
-        y.should == rgm.info["centroid_y"]
+    end
+    
+    describe '#average' do
+      it 'works' do
+        c = {x: 30, y: 35, w: 46, h: 46}
+        puts rm.average c
+        c = {x: 85, y: 10, w: 46, h: 46}
+        puts rm.average c
       end
     end
+    
+    # describe "#dark_centroid" do
+    #   it "should return the correct X" do
+    #     x, y = NPatch.new(mim).dark_centroid
+    #     x.should == rgm.info["centroid_x"]
+    #   end
+    #
+    #   it "should return the correct Y" do
+    #     x, y = NPatch.new(mim).dark_centroid
+    #     y.should == rgm.info["centroid_y"]
+    #   end
+    # end
   end
 end
 

data/spec/mork/sheet_omr_spec.rb

@@ -2,61 +2,58 @@ require 'spec_helper'
 
 module Mork
   describe SheetOMR do
+    
     context 'highlighting' do
       # since these specs change the @crop, they must be run in isolation
       # with the SheetOMR rebuilt each time, even though it is time consuming!
-      let(:sheet) { SheetOMR.new 'spec/samples/sample_gray.jpg', 'spec/samples/layout.yml' }
+      let(:shinfo) { sample_img 'sample-gray' }
+      let(:sheet)  { SheetOMR.new shinfo.filename, shinfo.grid_file }
       
       it 'highlights the registration areas and frame' do
-        sheet.highlight_reg_area
+        sheet.highlight_registration
         sheet.write_raw 'spec/out/reg_areas.jpg'
       end
       
-      it 'should highlight all areas' do
-        sheet.highlight_all
+      it 'highlights all choice cells' do
+        sheet.highlight_all_choices
         sheet.write 'spec/out/all_highlights.jpg'
       end
       
-      it 'should highlight marked cells and outline correct responses' do
+      it 'highlights marked cells' do
         sheet.highlight_marked
-        sheet.outline [[1],[1],[2],[2],[3,4],[],[0,1,2,3,4]]
         sheet.write 'spec/out/marked_highlights.jpg'
       end
+
+      it 'outlines some responses' do
+        sheet.outline [[1],[1],[2],[2],[3,4],[],[0,1,2,3,4], [],[1],[2],[2],[3,4],[],[0,1,2,3,4]]
+        sheet.write 'spec/out/outlines.jpg'
+      end
+
+      it 'highlights marked cells and outline correct responses', focus: true do
+        sheet.highlight_marked
+        sheet.outline [[1],[1],[2],[2],[3,4],[],[0,1,2,3,4], [],[1],[2],[2],[3,4],[],[0,1,2,3,4]]
+        sheet.write 'spec/out/marks_and_outs.jpg'
+      end
       
       it 'highlights marked cells of a problematic one' do
-        s = SheetOMR.new 'spec/samples/qzc013.jpg'
+        si = sample_img 'silvia'
+        s = SheetOMR.new si.filename, si.grid_file
         s.highlight_marked
         s.write 'spec/out/problem.jpg'
       end
       
-      it 'writes out average whiteness of choice cells' do
-        s = SheetOMR.new 'spec/samples/qzc013.jpg'
-        puts "Choice threshold: #{s.send :choice_threshold}"
-        File.open('spec/out/choices.txt', 'w') do |f|
-          120.times do |q|
-            t = (0..4).collect do |c|
-              s.send(:shade_of, q, c).round
-            end
-            f.puts "#{q+1}: #{t.join(' ')}"
-          end
-        end
-        
-        mf = File.open('spec/out/marked.txt',   'w')
-        uf = File.open('spec/out/unmarked.txt', 'w')
-        120.times do |q|
-          5.times do |c|
-            shade = s.send(:shade_of, q, c)
-            s.marked?(q,c) ? mf.puts(shade) : uf.puts(shade)
-          end
-        end
-        mf.close
-        uf.close
+      it 'highlights the barcode' do
+        si = sample_img 'sample-gray'
+        s = SheetOMR.new si.filename, si.grid_file
+        s.highlight_barcode
+        s.write 'spec/out/code_bits.jpg'
       end
     end
 
     context 'marking a nicely printed and scanned sheet' do
       before(:all) do
-        @sheet = SheetOMR.new('spec/samples/sample_gray.jpg', 'spec/samples/layout.yml')
+        @shinfo = sample_img 'sample-gray'
+        @sheet = SheetOMR.new @shinfo.filename, @shinfo.grid_file
       end
       
       describe '#valid?' do
@@ -78,27 +75,16 @@ module Mork
           expect(@sheet.marked?(2,3)).to be_falsy
         end
 
-        it 'writes out average whiteness of choice cells' do
+        it 'writes out markedness' do
           puts "Choice threshold: #{@sheet.send :choice_threshold}"
-          File.open('spec/out/choices.txt', 'w') do |f|
-            120.times do |q|
-              t = (0..4).collect do |c|
-                @sheet.send(:shade_of, q, c).round
-              end
-              f.puts "#{q+1}: #{t.join(' ')}"
-            end
-          end
-          
           mf = File.open('spec/out/marked.txt',   'w')
-          uf = File.open('spec/out/unmarked.txt', 'w')
           120.times do |q|
-            5.times do |c|
-              shade = @sheet.send(:shade_of, q, c)
-              @sheet.marked?(q,c) ? mf.puts(shade) : uf.puts(shade)
+            x = 5.times.collect do |c|
+              @sheet.marked?(q,c) ? '1' : '0'
             end
+            mf.puts x.join(' ')
           end
           mf.close
-          uf.close
         end
       end
 
@@ -139,25 +125,16 @@ module Mork
           s2 = SheetOMR.new('spec/samples/sample02.jpg')
           s2.barcode_string.should == barcode_string
           s2.barcode.should == 8608
-          s2.highlight_barcode
-          s2.write 'spec/out/code_bits.jpg'
         end
 
         it 'should read the 666 bit string' do
-          s2 = SheetOMR.new('spec/samples/sheet666.jpg')
-          s2.barcode.should == 666666666666
-          s2.highlight_barcode
-          s2.write 'spec/out/code_bits666.jpg'
+          sh = sample_img 'code666'
+          s2 = SheetOMR.new sh.filename, sh.grid_file
+          s2.barcode.should == sh.barcode_int
         end
       end
       
     end
-    
-    context 'a faded, b&w, distorted sheet' do
-      it 'should return the correct barcode' do
-        SheetOMR.new('spec/samples/sample03.jpg').barcode.should == 8608
-      end
-    end
 
     # context "multi-page pdf" do
     #   before(:all) do

data/spec/samples/info.yml

@@ -1,59 +1,59 @@
-registration:
-  filename: spec/samples/registration.png
-  pages:     1
-  width:  2484
-  height: 3512
-invalid_registration:
-  filename: spec/samples/invalid_registration.png
-  pages:     1
-  width:  2484
-  height: 3512
+code666:
+  filename: spec/samples/sheet666.jpg
+  grid-file: spec/samples/layout.yml
+  barcode-int: 666666666666
+
+silvia:
+  filename: spec/samples/qzc013.jpg
+  grid-file: spec/samples/layout.yml
+
+sample-gray:
+  filename:  spec/samples/sample_gray.jpg
+  grid-file: spec/samples/layout.yml
+  width: 1654
+  height: 2339
+  
+
 sample01:
   filename: spec/samples/sample01.jpg
   pages:     1
   width:  2334
   height: 3291
   
-  reg_marks: # registration marks
-    tl_x:     92
-    tl_y:     90
-    tr_x:   2245
-    tr_y:     97
-    br_x:   2230
-    br_y:   3217
-    bl_x:     78
-    bl_y:   3205
-  q_boxes:
+  reg-marks: # registration marks
+    tl-x:     92
+    tl-y:     90
+    tr-x:   2245
+    tr-y:     97
+    br-x:   2230
+    br-y:   3217
+    bl-x:     78
+    bl-y:   3205
+  q-boxes:
     q001:
-      tl_x: 175
-      tl_y: 379
+      tl-x: 175
+      tl-y: 379
     q160:
-      tl_x: 1818
-      tl_y: 2974
-bw_faded_sample:
-  filename: spec/samples/qzc006.jpg
-  pages: 1
-  width:    1196
-  height:   1682
-  code_int: 5512
+      tl-x: 1818
+      tl-y: 2974
   
-reg_mark:
+reg-mark:
   filename: spec/samples/reg_mark.jpg
-  centroid_x: 92
-  centroid_y: 91
+  centroid-x: 92
+  centroid-y: 91
 
 small:
   filename: spec/samples/small.jpg
 
-code_sample:
+code-sample:
   filename: spec/samples/code_sample.png
-  code_string: "0000000000000000000000000000000000000000000000000001110001010001" 
-  code_int:    7249
+  code-string: "0000000000000000000000000000000000000000000000000001110001010001" 
+  code-int:    7249
 
-code_zero:
+code-zero:
   filename: spec/samples/code_zero.png
 
-two_pages:
+two-pages:
   filename: spec/samples/two_pages.pdf
-  code_int: 17382938642823887837
+  code-int: 17382938642823887837