mork 0.0.9 → 0.0.10

data/lib/mork/grid_const.rb

@@ -4,24 +4,24 @@ module Mork
     # default units are millimiters
     page_size: {
       # this is A4
-      width:       210,
-      height:      297
+      width:      210,
+      height:     297
     }, # page end
     regmarks: {
-      margin:  10,
-      radius:  2.5,
-      search:  10,
-      offset:   2
+      margin:      10,
+      radius:       2.5,
+      search:      10,
+      offset:       2
     }, # regmarks end
     header: {
       name: {
         top:        5,
-        left:        7.5,
-        width:     170,
-        size:       14,
+        left:       7.5,
+        width:    170,
+        size:      14,
       },
       title: {
-        top:        15,
+        top:       15,
         left:       7.5,
         width:    180,
         size:      12
@@ -34,7 +34,7 @@ module Mork
       },
       signature: {
         top:        30,
-        left:      7.5,
+        left:        7.5,
         width:     120,
         height:     15,
         size:        7,
@@ -43,43 +43,41 @@ module Mork
     }, # header end
     items: {
       columns:       4, 
-      column_width: 49,
+      column_width: 44,
       rows:         30,
       # from the top-left registration mark
       # to the center of the first choice cell
       first_x:      10.5,
       first_y:      55.5,
       # between choices
-      x_spacing:     7.0,
+      x_spacing:     7,
       # between rows
-      y_spacing:     7.0,
+      y_spacing:     7,
       # darkened area
-      cell_width:    6.0,
-      cell_height:   5.0,
+      cell_width:    6,
+      cell_height:   5,
       # the maximum number of choices per question
-      max_cells:      5,
-      # font size for the question number
-      number_size:   10,
+      max_cells:     5,
+      # font size for the question number and choice letters
+      font_size:     9,
       # distance between right side of q num and left side of first choice cell
-      number_width:   8,
+      number_width:  8,
       # width of question number text box
-      number_margin:  2,
-      # font size for the choice letter
-      letter_size:    8
+      number_margin: 2,
     }, # items end
-    code: {
-      bits:    40,
-      left:     15,
-      width:    3.0,
-      height:   2.5,
-      spacing:  4
-    }, # code end
+    barcode: {
+      bits:         40,
+      left:         15,
+      width:         3,
+      height:        2.5,
+      spacing:       4
+    }, # barcode end
     control: {
-      top:       40,
-      left:     123,
-      width:     50,
-      size:       9,
-      margin:     2.5
+      top:          40,
+      left:        123,
+      width:        50,
+      size:          9,
+      margin:        2.5
     } # control end
   }
 end

data/lib/mork/grid_omr.rb

@@ -0,0 +1,94 @@
+require 'mork/grid'
+
+module Mork
+  class GridOMR < Grid
+    def initialize(page_width, page_height, options=nil)
+      super options
+      @px = page_width.to_f
+      @py = page_height.to_f
+    end
+    
+    def barcode_bit_areas(code = 2**barcode_bits-1)
+      barcode_bits.times.collect { |b| barcode_bit_area b }
+    end
+    
+    # ====================================================
+    # = Returning {x, y, w, h} hashes for area locations =
+    # ====================================================
+    def choice_cell_area(q, c)
+      {
+        x: (cx * cell_x(q,c)).round,
+        y: (cy * cell_y(q)  ).round,
+        w: (cx * cell_width ).round,
+        h: (cy * cell_height).round
+      }
+    end
+    
+    def calibration_cell_areas
+      rows.times.collect do |q|
+        {
+          x: (cx * cal_cell_x ).round,
+          y: (cy * cell_y(q)  ).round,
+          w: (cx * cell_width ).round,
+          h: (cy * cell_height).round
+        }
+      end
+    end
+    
+    def barcode_bit_area(bit)
+      {
+        x: (cx * barcode_bit_x(bit)).round,
+        y: (cy * barcode_y         ).round,
+        w: (cx * barcode_width     ).round,
+        h: (cy * barcode_height    ).round
+      }
+    end
+    
+    # the 4 values needed to locate a single registration mark
+    # 
+    def rm_search_area(corner, i)
+      {
+        x: (ppu_x * rmx(corner, i)).round,
+        y: (ppu_y * rmy(corner, i)).round,
+        w: (ppu_x * (reg_search + reg_radius * i)).round,
+        h: (ppu_y * (reg_search + reg_radius * i)).round
+      }
+    end
+    
+    # a safe distance to determine
+    def rm_edgy_x()                (ppu_x * reg_radius).round + 5    end
+    def rm_edgy_y()                (ppu_y * reg_radius).round + 5    end
+    # areas on the sheet that are certainly white/black
+    def paper_white_area()         barcode_bit_area -1               end
+    def ink_black_area()           barcode_bit_area  0               end
+    def max_choices_per_question() @params[:items][:max_cells].to_i  end
+    def rm_max_search_area_side()  (ppu_x * page_width / 4).round    end
+    
+    private
+    
+    def cx()    @px / reg_frame_width  end
+    def cy()    @py / reg_frame_height end
+    def ppu_x() @px / page_width       end
+    def ppu_y() @py / page_height      end
+      
+    # finding the width of the registration area based on iteration
+    def rmx(corner, i)
+      case corner
+      when :tl; reg_off
+      when :tr; page_width - reg_search - reg_off - reg_radius * i
+      when :br; page_width - reg_search - reg_off - reg_radius * i
+      when :bl; reg_off
+      end
+    end
+  
+    # finding the height of the registration area based on iteration
+    def rmy(corner, i)
+      case corner
+      when :tl; reg_off
+      when :tr; reg_off
+      when :br; page_height - reg_search - reg_off - reg_radius * i
+      when :bl; page_height - reg_search - reg_off - reg_radius * i
+      end
+    end
+  end
+end

data/lib/mork/grid_pdf.rb

@@ -0,0 +1,107 @@
+require 'mork/grid'
+
+module Mork
+  # GridPDF gets coordinates and measurements from a Grid and
+  # provides SheetPDF with the properly computed values
+  class GridPDF < Grid
+    def initialize(options=nil)
+      super options
+    end
+    
+    def reg_marks
+      r = reg_radius.mm
+      [
+        { p: [0,                  0                  ], r: r },
+        { p: [0,                  reg_frame_height.mm], r: r },
+        { p: [reg_frame_width.mm, reg_frame_height.mm], r: r },
+        { p: [reg_frame_width.mm, 0                  ], r: r }
+      ]
+    end
+    
+    def barcode_bit_areas_for(code)
+      black = barcode_bits.times.reject { |x| (code>>x)[0]==0 }
+      black.collect { |x| barcode_area x+1 }
+    end
+    
+    def calibration_cell_areas
+      rows.times.collect do |q|
+        {
+          p: [(reg_frame_width-cell_spacing).mm, (reg_frame_height - cell_y(q)).mm],
+          w: cell_width.mm,
+          h: cell_height.mm
+        }
+      end
+    end
+    
+    # Coordinates at which to place calibration cell labels (usually an ‘X’)
+    def calibration_letter_xy(q)
+      [
+        (reg_frame_width-cell_spacing).mm + 2.mm,
+        item_text_y(q)
+      ]
+    end
+    
+    # Coordinates at which to place item numbers
+    def qnum_xy(q)
+      [
+        cell_x(q, 0).mm - qnum_width - @params[:items][:number_margin].to_f.mm,
+        item_text_y(q)
+      ]
+    end
+    
+    # Coordinates at which to place choice labels
+    def choice_letter_xy(q, c)
+      [
+        cell_x(q, c).mm + 2.mm,
+        item_text_y(q)
+      ]
+    end
+    
+    def choice_cell_area(q, c)
+      {
+        p: [cell_x(q, c).mm, (reg_frame_height - cell_y(q)).mm],
+        w: cell_width.mm,
+        h: cell_height.mm
+      }
+    end
+
+    def page_size()      [page_width.mm, page_height.mm]        end
+    def margins()        reg_margin.mm                          end
+    def ink_black_area() barcode_area(0)                        end
+    def qnum_width()     @params[:items][:number_width].to_f.mm end
+    def item_font_size() @params[:items][:font_size].to_f       end
+    def header_width(k)  @params[:header][k][:width].to_f.mm    end
+    def header_height(k) @params[:header][k][:height].to_f.mm   end
+    def header_size(k)   @params[:header][k][:size].to_f        end
+    def header_boxed?(k) @params[:header][k][:box] == true      end
+
+    def header_xy(k)
+      [
+        @params[:header][k][:left].to_f.mm,
+        (reg_frame_height - @params[:header][k][:top].to_f).mm
+      ]
+    end
+
+    def header_padding(k)
+      [
+        1.mm,
+        header_height(k) - 1.mm
+      ]
+    end
+  
+
+    private
+    
+    def item_text_y(q)
+      (reg_frame_height - cell_y(q) - cell_height/4).mm
+    end
+    
+    def barcode_area(i)
+      {
+        p: [barcode_bit_x(i).mm, (reg_frame_height - barcode_y).mm],
+        w: barcode_width.mm,
+        h: barcode_height.mm * 2
+      }
+    end
+  end
+end

data/lib/mork/mimage.rb

@@ -39,7 +39,7 @@ module Mork
     # =============
     # = Highlight =
     # =============
-    def highlight!(cells, roundedness=nil)
+    def highlight_cells!(cells, roundedness=nil)
       cells = [cells] if cells.is_a? Hash
       roundedness ||= [cells[0][:h], cells[0][:w]].min / 2
       cells.each do |c|
@@ -51,12 +51,24 @@ module Mork
       end
     end
     
+    def highlight_rect!(areas)
+      areas = [areas] if areas.is_a? Hash
+      areas.each do |c|
+        out = Magick::Draw.new
+        out.fill_opacity 0
+        out.stroke 'yellow'
+        out.stroke_width 3
+        out.rectangle c[:x], c[:y], c[:x]+c[:w], c[:y]+c[:h]
+        out.draw @image
+      end
+    end
+    
     def join!(p)
       poly = Magick::Draw.new
       poly.fill_opacity 0
       poly.stroke 'green'
       poly.stroke_width 3
-      poly.polygon p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]
+      poly.polygon p[0][:x], p[0][:y], p[1][:x], p[1][:y], p[2][:x], p[2][:y], p[3][:x], p[3][:y]
       poly.draw @image
     end
     

data/lib/mork/npatch.rb

@@ -44,7 +44,6 @@ module Mork
     end
     
     def edgy?(x, y)
-      puts "PATCH: (#{@width},#{@height})  EDGY: x=#{x}, y=#{y}"
       tol = 5
       (x < tol) or (y < tol) or (y > @height - tol) or (x > @width - tol)
     end

data/lib/mork/{sheet.rb → sheet_omr.rb}

@@ -1,19 +1,25 @@
+require 'mork/grid_omr'
+require 'mork/mimage'
+require 'mork/mimage_list'
+require 'mork/npatch'
+
 module Mork
-  class Sheet
-    def initialize(im, grid=Grid.new)
-      @raw = case im.class.to_s
-             when "String"
-               Mimage.new im
-             when "Mork::Mimage"
-               im
-             else
-               raise "A new sheet requires either a Mimage or the name of the source image file, but it was a: #{im.class}"
-             end
-      @grid = grid
-      # send page size to the grid, so that all later measurements can be done within the
-      # grid itself; 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 @raw.width, @raw.height
+  class SheetOMR
+    def initialize(im, grom=nil)
+      @raw   = case im
+               when String
+                 Mimage.new im
+               when Mork::Mimage
+                 im
+               else
+                 raise "A new sheet requires either a Mimage or the name of the source image file, but it was a: #{im.class}"
+               end
+      @grom = case grom
+               when String, Hash, NilClass
+                 GridOMR.new @raw.width, @raw.height, grom
+               else
+                 raise 'Invalid argument in SheetOMR initialization'
+               end
       @rm   = {}
       @rmsa = {}
       @ok_reg = register @raw
@@ -23,25 +29,21 @@ module Mork
       @ok_reg
     end
     
-    def status
-      @rm
-    end
-    
-    # code
+    # barcode
     # 
-    # returns the sheet code as an integer
-    def code
+    # returns the sheet barcode as an integer
+    def barcode
       return if not_registered
-      code_string.to_i(2)
+      barcode_string.to_i(2)
     end
     
-    # code_string
+    # barcode_string
     # 
-    # returns the sheet code as a string of 0s and 1s. The string is code_bits
+    # returns the sheet barcode as a string of 0s and 1s. The string is barcode_bits
     # bits long, with most significant bits to the left
-    def code_string
+    def barcode_string
       return if not_registered
-      cs = (0...@grid.code_bits).inject("") { |c, v| c << code_cell_value(v) }
+      cs = @grom.barcode_bits.times.inject("") { |c, v| c << barcode_bit_value(v) }
       cs.reverse
     end
     
@@ -51,7 +53,6 @@ module Mork
     # false otherwise
     def marked?(q, c)
       return if not_registered
-      # puts "SHADE: #{shade_of(q, c)}, Q: #{q}, C: #{c}, THR: #{choice_threshold}"
       shade_of(q, c) < choice_threshold
     end
     
@@ -67,7 +68,7 @@ module Mork
       return if not_registered
       question_range(r).collect do |q|
         cho = []
-        (0...@grid.max_choices_per_question).each do |c|
+        (0...@grom.max_choices_per_question).each do |c|
           cho << c if marked?(q, c)
         end
         cho
@@ -77,7 +78,7 @@ module Mork
     def mark_logical_array(r = nil)
       return if not_registered
       question_range(r).collect do |q|
-        (0...@grid.max_choices_per_question).collect {|c| marked?(q, c)}
+        (0...@grom.max_choices_per_question).collect {|c| marked?(q, c)}
       end
     end
     
@@ -90,55 +91,36 @@ module Mork
       @crop.outline! array_of cells
     end
     
-    def highlight_ctrl
-      return if not_registered
-      @crop.highlight! [@grid.ctrl_area_dark, @grid.ctrl_area_light]
-    end
-    
     def highlight_all
       return if not_registered
-      cells = (0...@grid.max_questions).collect { |i| (0...@grid.max_choices_per_question).to_a }
-      @crop.highlight! array_of cells
-    end
-    
-    def highlight
-      return if not_registered
-      @crop.highlight! array_of mark_array
+      cells = (0...@grom.max_questions).collect { |i| (0...@grom.max_choices_per_question).to_a }
+      @crop.highlight_cells! array_of cells
+      @crop.highlight_cells! @grom.calibration_cell_areas
+      @crop.highlight_rect! [@grom.ink_black_area, @grom.paper_white_area]
+      @crop.highlight_rect! @grom.barcode_bit_areas
+      # @grom.barcode_bits.times do |bit|
+      #   @crop.highlight_rect! @grom.barcode_bit_area bit
+      # end
     end
     
-    def highlight_code_areas
+    def highlight_marked
       return if not_registered
-      @grid.code_bits.times do |bit|
-        @crop.highlight! @grid.code_bit_area bit
-      end
+      @crop.highlight_cells! array_of mark_array
     end
     
-    def highlight_code
+    def highlight_barcode
       return if not_registered
-      @grid.code_bits.times do |bit|
-        if code_string.reverse[bit] == '1'
-          @crop.highlight! @grid.code_bit_area bit
+      @grom.barcode_bits.times do |bit|
+        if barcode_string.reverse[bit] == '1'
+          @crop.highlight_rect! @grom.barcode_bit_area bit+1
         end
       end
     end
     
-    def highlight_dark_calibration_bit
-      return if not_registered
-      @crop.highlight!(@grid.cal_area_black)
-    end
-    
-    def highlight_light_calibration_bit
-      return if not_registered
-      @crop.highlight!(@grid.cal_area_white)
-    end
-    
     def highlight_reg_area
-      @raw.highlight! @rmsa[:tl]
-      @raw.highlight! @rmsa[:tr]
-      @raw.highlight! @rmsa[:br]
-      @raw.highlight! @rmsa[:bl]
+      @raw.highlight_rect! [@rmsa[:tl], @rmsa[:tr], @rmsa[:br], @rmsa[:bl]]
       return if not_registered
-      @raw.join!(@rm)
+      @raw.join! [@rm[:tl],@rm[:tr],@rm[:br],@rm[:bl]]
     end
 
     def write(fname)
@@ -150,13 +132,20 @@ module Mork
       @raw.write(fname)
     end
     
+    # =================================
+    # = compute shading with NPatches =
+    # =================================
+    def shade_of(q, c)
+      naverage @grom.choice_cell_area(q, c)
+    end
+    
   private
   
     def array_of(cells)
       out = []
       cells.each_with_index do |q, i|
         q.each do |c|
-          out << @grid.choice_cell_area(i, c)
+          out << @grom.choice_cell_area(i, c)
         end
       end
       out
@@ -164,7 +153,7 @@ module Mork
 
     def question_range(r)
       if r.nil?
-        (0...@grid.max_questions)
+        (0...@grom.max_questions)
       elsif r.is_a? Fixnum
         (0...r)
       elsif r.is_a? Array
@@ -174,35 +163,44 @@ module Mork
       end
     end
     
-    # =================================
-    # = compute shading with NPatches =
-    # =================================
-    def shade_of(q, c)
-      naverage @grid.choice_cell_area(q, c)
-    end
-    
-    def shade_of_code_bit(i)
-      naverage @grid.code_bit_area(i)
+    def barcode_bit_value(i)
+      shade_of_barcode_bit(i) < barcode_threshold ? "1" : "0"
     end
     
-    def code_cell_value(i)
-      shade_of_code_bit(i) < code_threshold ? "1" : "0"
+    def shade_of_barcode_bit(i)
+      naverage @grom.barcode_bit_area i+1
     end
 
+    def barcode_threshold
+      @barcode_threshold ||= (paper_white + ink_black) / 2
+    end
+    
     def choice_threshold
-      @choice_threshold ||= (naverage(@grid.ctrl_area_dark)   +
-                             naverage(@grid.ctrl_area_light)) / 2
+      @choice_threshold ||= ccmeans.mean - ccmeans.stdev * 7
+    end
+    
+    def ccmeans
+      @calcmeans ||= @grom.calibration_cell_areas.collect { |c| naverage c }
+    end
+    
+    def paper_white
+      @paper_white ||= naverage @grom.paper_white_area
+    end
+    
+    def ink_black
+      @ink_black ||= naverage @grom.ink_black_area
     end
     
-    def code_threshold
-      @code_threshold ||= (naverage(@grid.cal_area_black)  +
-                           naverage(@grid.cal_area_white)) / 2
+    def shade_of_blank_cells
+      # @grom.
     end
     
     # ================
     # = Registration =
     # ================
     
+    # this method uses a 'stretch' strategy, i.e. where the image after
+    # registration has the same size in pixels as the original scanned file
     def register(img)
       # find the XY coordinates of the 4 registration marks
       @rm[:tl] = reg_centroid_on(img, :tl)
@@ -224,19 +222,19 @@ module Mork
     # in the XY coordinates of the entire image
     def reg_centroid_on(img, corner)
       1000.times do |i|
-        @rmsa[corner] = @grid.rm_search_area(corner, i)
+        @rmsa[corner] = @grom.rm_search_area(corner, i)
         cx, cy = NPatch.new(img.crop(@rmsa[corner])).dark_centroid
         if cx.nil?
           status = :insufficient_contrast  
-        elsif (cx < @grid.rm_edgy_x) or
-              (cy < @grid.rm_edgy_y) or
-              (cy > @rmsa[corner][:h] - @grid.rm_edgy_y) or
-              (cx > @rmsa[corner][:w] - @grid.rm_edgy_x)
+        elsif (cx < @grom.rm_edgy_x) or
+              (cy < @grom.rm_edgy_y) or
+              (cy > @rmsa[corner][:h] - @grom.rm_edgy_y) or
+              (cx > @rmsa[corner][:w] - @grom.rm_edgy_x)
           status = :edgy
         else
           return {status: :ok, x: cx + @rmsa[corner][:x], y: cy + @rmsa[corner][:y]}
         end
-        return {status: status, x: nil, y: nil} if @rmsa[corner][:w] > @grid.rm_max_search_area_side
+        return {status: status, x: nil, y: nil} if @rmsa[corner][:w] > @grom.rm_max_search_area_side
       end
     end