mork 0.0.1 → 0.0.2

data/lib/mork/mimage_list.rb

@@ -0,0 +1,29 @@
+require 'RMagick'
+
+module Mork
+  # The class MimageList
+  class MimageList
+    def initialize(fname)
+      raise "Initializing a MimageList requires a string" unless fname.class == String
+      if File.extname(fname) == '.pdf'
+        @images = Magick::ImageList.new(fname) { self.density = 200 }
+      else
+        @images = Magick::ImageList.new(fname)
+      end
+    end
+    
+    def shift
+      Mimage.new @images.shift
+    end
+    
+    def [] (i)
+      Mimage.new @images[i]
+    end
+    
+    def each
+      @images.each do |i|
+        yield Mimage.new i
+      end
+    end
+  end
+end

data/lib/mork/npatch.rb

@@ -0,0 +1,51 @@
+require 'narray'
+
+module Mork
+  # Handles low-level computations on a Mimage
+  # Typically used on smaller patches
+  class NPatch
+    def initialize(mim)
+      @mim = mim
+      @width  = mim.width
+      @height = mim.height
+    end
+    
+    def average
+      narr.mean
+    end
+    
+    def dark_centroid
+      return nil, nil unless sufficient_contrast?
+      xp = patch.sum(1).to_a
+      yp = patch.sum(0).to_a
+      # find the intensity trough
+      ctr_x = xp.find_index(xp.min)
+      ctr_y = yp.find_index(yp.min)
+      return nil, nil if edgy?(ctr_x, ctr_y)
+      return ctr_x, ctr_y
+    end
+    
+  private
+    def patch
+      @the_npatch ||= blurry_narr.reshape!(@width, @height)
+    end
+    
+    def narr
+      @narr ||= NArray[@mim.pixels]
+    end
+    
+    def blurry_narr
+      @blurry_narr ||= NArray[@mim.blur!(10,5).pixels]
+    end
+
+    def sufficient_contrast?
+      # just a wild guess for now
+      blurry_narr.stddev > 5000
+    end
+    
+    def edgy?(x, y)
+      tol = 5
+      (x < tol) or (y < tol) or (y > @height - tol) or (x > @width - tol)
+    end
+  end
+end

data/lib/mork/report.rb

@@ -0,0 +1,39 @@
+module Mork
+  class Report
+    def initialize(im, opts={})
+      grid_type = opts[:grid_type] || :default
+      grid_file = opts[:grid_file] || 'config/grids.yml'
+      @grid = Grid.new grid_type, grid_file
+      @sheet = Sheet.new(im, @grid)
+      @chlist = opts[:chlist] || @grid.default_chlist
+    end
+    
+    def sheet_code
+      @sheet.code
+    end
+    
+    def selected_choices
+      # sc = []
+      # @chlist.each_with_index do |ch, i|
+      #   sc[i] = (0...ch).collect do |x|
+      #     puts "Q.#{i} Ch.#{x}"
+      #     @mimage.darkened? @ruler.cell(i, x)
+      #   end
+      # end
+      # sc
+    end
+    
+    def highlight_all_choices
+      @chlist.each_with_index do |ch, i|
+        (0...ch).each do |x|
+          @sheet.highlight_choice(i, x)
+        end
+      end
+      @sheet.highlight_code
+    end
+    
+    def write_sheet(fname)
+      @sheet.write(fname)
+    end
+  end
+end

data/lib/mork/sheet.rb

@@ -0,0 +1,144 @@
+module Mork
+  class Sheet
+    def initialize(im, grid)
+      im = Mimage.new(im) if im.class == String
+      raise "A new sheet requires either a Mimage or the name of the source image file" unless im.class == Mimage
+      # grid = Grid.new(grid) if grid.class == String
+      # raise "A new sheet requires either a Mimage or the name of the source image file" unless im.class == Mimage
+      @grid = grid
+      @mimage = register(im)
+    end
+    
+    # code
+    # 
+    # returns the sheet code as an integer
+    def code
+      code_string.to_i(2)
+    end
+    
+    # code_string
+    # 
+    # returns the sheet code as a string of 0s and 1s. The string is CODE_BITS
+    # bits long, with most significant bits to the left
+    def code_string
+      cs = (0...@grid.code_bits).inject("") { |c, v| c << code_cell_value(v) }
+      cs.reverse
+    end
+    
+    # marked?(question, choice)
+    # 
+    # returns true if the specified question/choice cell has been darkened
+    # false otherwise
+    def marked?(q, c)
+      shade_of(q, c) < dark_threshold
+    end
+    
+    # mark_array(range)
+    # 
+    # returns an array of arrays of marked choices.
+    # takes either a range of questions, an array of questions, or a fixnum,
+    # in which case the choices for the first n questions will be returned.
+    # if called without arguments, all available choices will be evaluated
+    def mark_array(r = nil)
+      question_range(r).collect do |q|
+        cho = []
+        (0...@grid.max_choices_per_question).each do |c|
+          cho << c if marked?(q, c)
+        end
+        cho
+      end
+    end
+    
+    def mark_logical_array(r = nil)
+      question_range(r).collect do |q|
+        (0...@grid.max_choices_per_question).collect {|c| marked?(q, c)}
+      end
+    end
+    
+    def highlight_choice(q, c)
+      @mimage.highlight! @grid.choice_cell_area(q, c)
+    end
+
+    def highlight_code_bit(i)
+      @mimage.highlight! @grid.code_bit_area(i)
+    end
+
+    def highlight_dark_calibration_bit
+      @mimage.highlight! @grid.black_calibration_area
+    end
+    
+    def highlight_light_calibration_bit
+      @mimage.highlight! @grid.white_calibration_area
+    end
+
+    def write(fname)
+      @mimage.write(fname)
+    end
+    
+    def dark_code_bit_shade
+      NPatch.new(@mimage.crop @grid.black_calibration_area).average
+    end
+    
+    def light_code_bit_shade
+      NPatch.new(@mimage.crop @grid.white_calibration_area).average
+    end
+    
+  private
+    def shade_of(q, c)
+      NPatch.new(@mimage.crop @grid.choice_cell_area(q, c)).average
+    end
+
+    def dark_threshold
+      50000
+    end
+    
+    def question_range(r)
+      if r.nil?
+        (0...@grid.max_questions)
+      elsif r.is_a? Fixnum
+        (0...r)
+      else
+        r
+      end
+    end
+    
+    def shade_of_code_bit(i)
+      NPatch.new(@mimage.crop @grid.code_bit_area(i)).average
+    end
+    
+    def code_cell_value(i)
+      shade_of_code_bit(i) < dark_threshold ? "1" : "0"
+    end
+    
+    # ================
+    # = Registration =
+    # ================
+    
+    def register(img)
+      # send page size to the grid, so that all later measurements can be done within the
+      # grid itself. WARNING: this method assumes a 'stretch' strategy, i.e. where the
+      # image after registration has the same size in pixels as the original scanned file
+      @grid.set_page_size img.width, img.height
+      # find the XY coordinates of the 4 registration marks
+      x1, y1 = reg_centroid_on(img, @grid.reg_mark_search_area(:top_left))
+      x2, y2 = reg_centroid_on(img, @grid.reg_mark_search_area(:top_right))
+      x3, y3 = reg_centroid_on(img, @grid.reg_mark_search_area(:bottom_right))
+      x4, y4 = reg_centroid_on(img, @grid.reg_mark_search_area(:bottom_left))
+      # stretch the 4 points to fit the original size and return the resulting image
+      img.stretch [
+        x1, y1,         0,          0,
+        x2, y2, img.width,          0,
+        x3, y3, img.width, img.height,
+        x4, y4,         0, img.height
+      ]
+    end
+    
+    # returns the centroid of the dark region within the given area
+    # in the XY coordinates of the entire image
+    def reg_centroid_on(img, c)
+      cx, cy = NPatch.new(img.crop(c)).dark_centroid
+      return nil, nil if cx.nil?
+      return cx + c[:x], cy + c[:y]
+    end
+  end
+end

data/lib/mork/sheet_pdf.rb

@@ -0,0 +1,97 @@
+require 'prawn'
+
+module Mork
+  class SheetPDF < Prawn::Document
+    def initialize(grid, info)
+      @grid = grid
+      @info = info
+      super my_page_params
+      registration_marks
+      calibration_and_code @info[:code]
+      header
+      questions_and_choices
+    end
+    
+    def my_page_params
+      {
+        page_size: @grid.pdf_page_size,
+        margin: @grid.pdf_margins
+      }
+    end
+    
+    def registration_marks
+      fill {
+        @grid.pdf_reg_marks.each do |r|
+          circle r[:p], r[:r]
+        end
+      }
+    end
+    
+    def calibration_and_code(code)
+      fill do
+        # draw the dark calibration bar
+        c = @grid.pdf_dark_calibration_area
+        rectangle c[:p], c[:w], c[:h]
+        # draw the bars corresponding to the code
+        # least to most significant bit, left to right
+        @grid.pdf_code_areas_for(code).each do |c|
+          rectangle c[:p], c[:w], c[:h]
+        end
+      end
+    end
+    
+    def header
+      @info[:header].each do |k,v|
+        text_box v, at:    @grid.pdf_header_xy(k),
+                    width: @grid.pdf_header_width(k),
+                    size:  @grid.pdf_header_size(k) || 12
+      end
+    end
+
+    def questions_and_choices
+      stroke do
+        line_width 0.3
+        nquestions.times do |q|
+          fill_color "000000"
+          text_box "#{q+1}", at: @grid.pdf_qnum_xy(q),
+                             width: @grid.pdf_qnum_width,
+                             align: :right,
+                             size: Q_NUM_SIZE
+          stroke_color "ff0000"
+          font_size CH_LETTER_SZ
+          nchoices(q).times do |c|
+            a = @grid.pdf_choice_cell_area q, c
+            rounded_rectangle a[:p], a[:w], a[:h], 2.mm
+            fill_color "ff0000"
+            draw_text (65+c).chr, at: @grid.pdf_choice_letter_xy(q, c)
+          end
+        end
+      end
+    end
+
+    def save(fn)
+      render_file fn
+    end
+
+  private
+    def nquestions
+      @info[:choices].length
+    end
+
+    def nchoices(i)
+      @info[:choices][i]
+    end
+  end
+end
+
+class Fixnum
+  def mm
+    self * 2.83464566929134
+  end
+end
+
+class Float
+  def mm
+    self * 2.83464566929134
+  end
+end

data/lib/mork/version.rb

@@ -1,3 +1,3 @@
 module Mork
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/mork.gemspec

@@ -10,7 +10,6 @@ Gem::Specification.new do |s|
   s.homepage    = ""
   s.summary     = %q{Optical mark recognition of multiple-choice response sheets}
   s.description = %q{Coming soon}
-
   s.rubyforge_project = "mork"
 
   s.files         = `git ls-files`.split("\n")
@@ -19,6 +18,14 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
+  s.add_dependency "narray"
+  s.add_dependency "rmagick"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "cucumber"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "guard-shell"
+  s.add_development_dependency "rb-fsevent"
+  
   # s.add_runtime_dependency "rest-client"
 end

data/spec/mork/grid_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module Mork
+  describe Grid do
+    let(:grid) { Grid.new(:default) }
+
+    describe "#initialize" do
+      it "returns a Grid object" do
+        grid.should be_a(Grid)
+      end
+    end
+    
+    describe "#cell_x" do
+      context "for 1st-column questions" do
+        it "returns the distance from the registration frame of the left edge of the 1st choice" do
+          grid.send(:cell_x,0,0).should == 7.5
+        end
+        
+        it "returns the distance from the registration frame of the left edge of the 2nd choice" do
+          grid.send(:cell_x,0,1).should == 14.5
+        end
+      end
+
+      context "for 4th-column questions" do
+        it "returns the distance from the registration frame of the left edge of the 1st choice" do
+          grid.send(:cell_x,120,0).should == 157.5
+        end
+        
+        it "returns the distance from the registration frame of the left edge of the 2nd choice" do
+          grid.send(:cell_x,120,1).should == 164.5
+        end
+      end
+    end
+    
+    describe "#cell_y" do
+      it "returns the distance from the registration frame of the top edge of the 1st row of cells" do
+        grid.send(:cell_y,0).should == 33.5
+      end
+      
+      it "returns the distance from the registration frame of the 40th row of cells" do
+        grid.send(:cell_y,39).should == 267.5
+      end
+    end
+    
+    describe "#cell_xy" do
+      it "returns the left and top distances from the registration frame of a sample cell" do
+        x, y = grid.send(:cell_xy,54, 3)
+        x.should == 78.5
+        y.should == 117.5
+      end
+    end
+  end
+end
+
+# describe "#question_area" do
+#   before(:each) do
+#     grid.reg_marks(@image)
+#   end
+#   it "returns a hash" do
+#     grid.question_area(1).should be_an_instance_of(Hash)
+#   end
+#   
+#   it "returns the location in pixels of the first question patch" do
+#     c = grid.question_area(1)
+#     c[:x].should be_within(4).of(90)
+#     c[:y].should be_within(4).of(388)
+#   end
+#   it "returns the location in pixels of the 40th question patch" do
+#     c = grid.question_area(40)
+#     c[:x].should be_within(4).of(90)
+#     c[:y].should be_within(4).of(3120)
+#   end
+# 
+#   it "returns the location in pixels of the 121th question patch" do
+#     c = grid.question_area(121)
+#     c[:x].should be_within(4).of(1887)
+#     c[:y].should be_within(4).of(388)
+#   end
+# 
+#   it "returns the location in pixels of the last question patch" do
+#     c = grid.question_area(160)
+#     c[:x].should be_within(4).of(1887)
+#     c[:y].should be_within(4).of(3120)
+#   end
+# end