mork 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f334aa5882675284d8700705af5fe1015045234f
-  data.tar.gz: 5d516e96fe0453f29179b08ded1d3d9786c27bff
+  metadata.gz: 023acadd6339d125a7764a4af516d86b7da951c3
+  data.tar.gz: fffbcdd3a134b60d02f46a380ba5192812c13b76
 SHA512:
-  metadata.gz: fafa8bd3db5eb7a0c5f0c15274daf62046e2285bfee46704cf849eca984eb59edb0866b85d1fc489d44f2b3c6a452cfc166ffd06674b2c7242550a32d216097b
-  data.tar.gz: 6b9244e99322ee533905329240618e0ed52bc729e313d99cb03078e3c63554d7194ab8956894f1c4917ff5ba0d72fad85e2f1bb3d1a15e94606a5597593dcd75
+  metadata.gz: 8bb3ec4c6ec605ce6d7866550ab7d66025520d99961a388ae303b513a2a5f57252818725ae8d8d64f891eab54f55d0f7c3d61cae3c16cea873612f53344ac31a
+  data.tar.gz: ad6e6df8e2ce80126e270760bc2909a2810555d1f68196e919f635feec29d55974444b98bda28e93dfdd510d938566289e4882ce4f96cb04460e0b385f2f3f59

data/Gemfile

@@ -1,3 +1,2 @@
 source "http://rubygems.org"
-# gem 'prawn', git: 'git://github.com/prawnpdf/prawn', submodules: true
 gemspec

data/lib/mork/grid_omr.rb

@@ -2,14 +2,21 @@ require 'mork/grid'
 
 module Mork
   class GridOMR < Grid
-    def initialize(page_width, page_height, options=nil)
+    def initialize(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 }
+    def set_page_size(width, height)
+      @px = width.to_f
+      @py = height.to_f
+    end
+    
+    def barcode_bit_areas(bitstring = '1' * barcode_bits)
+      areas = []
+      bitstring.reverse.each_char.with_index do |c, i|
+        areas << barcode_bit_area(i+1) if c=='1'
+      end
+      areas
     end
     
     # ====================================================

data/lib/mork/mimage.rb

@@ -1,67 +1,103 @@
-require 'RMagick'
+require 'mini_magick'
+require 'mork/npatch'
 
 module Mork
-  # The class Mimage is a wrapper for the core image library, currently RMagick
+  # The class Mimage is a wrapper for the core image library, currently mini_magick
   class Mimage
-    def initialize(img, page=0)
-      if img.class == String
-        if File.extname(img) == '.pdf'
-          @image = Magick::Image.read(img) { self.density = 200 }[page]
-        else
-          @image = Magick::ImageList.new(img)[page]
-        end
-      elsif img.class == Magick::ImageList
-        @image = img[page]
-      elsif img.class == Magick::Image
-        @image = img
-      else
-        raise "Invalid initialization argument"
-      end
+    def initialize(path, grom, page=0)
+      raise "File '#{path}' not found" unless File.exists? path
+      @path = path
+      @grom = grom
+      @grom.set_page_size width, height
+      @status = register
+      @cmd = []
+    end
+    
+    def status
+      @status
+    end
+    
+    def ink_black
+      reg_pixels.average @grom.ink_black_area
+    end
+    
+    def paper_white
+      reg_pixels.average @grom.paper_white_area
+    end
+    
+    def cal_cell_mean
+      @grom.calibration_cell_areas.collect { |c| reg_pixels.average c }.mean
+    end
+    
+    def shade_of_barcode_bit(i)
+      reg_pixels.average @grom.barcode_bit_area i+1
+    end
+    
+    def shade_of(q,c)
+      reg_pixels.average @grom.choice_cell_area(q, c)
+    end
+    
+    def width
+      img_size[0].to_i
     end
     
-    # outline!(cells, roundedness)
+    def height
+      img_size[1].to_i
+    end
+        
+    # outline(cells, roundedness)
     # 
     # draws on the Mimage a set of cell outlines
     # typically used to highlight the expected responses
-    def outline!(cells, roundedness=nil)
-      cells = [cells] if cells.is_a? Hash
+    def outline(cells, roundedness=nil)
       return if cells.empty?
-      roundedness ||= [cells[0][:h], cells[0][:w]].min / 2
-      out = Magick::Draw.new
-      out.stroke 'green'
-      out.stroke_width 4
-      out.fill_opacity 0
-      cells.each do |c|
-        out.roundrectangle c[:x], c[:y], c[:x]+c[:w], c[:y]+c[:h], roundedness, roundedness
-        out.draw @image
+      @cmd << [:stroke, 'green']
+      @cmd << [:strokewidth, '4']
+      @cmd << [:fill, 'none']
+      array_of(cells).each do |c|
+        roundedness ||= [c[:h], c[:w]].min / 2
+        pts = [c[:x], c[:y], c[:x]+c[:w], c[:y]+c[:h], roundedness, roundedness].join ' '
+        @cmd << [:draw, "roundrectangle #{pts}"]
       end
     end
     
-    # =============
-    # = Highlight =
-    # =============
-    def highlight_cells!(cells, roundedness=nil)
-      cells = [cells] if cells.is_a? Hash
+    def highlight_all_choices
+      cells = (0...@grom.max_questions).collect { |i| (0...@grom.max_choices_per_question).to_a }
+      highlight_cells cells
+    end
+    
+    # highlight_cells(cells, roundedness)
+    # 
+    # partially transparent yellow on top of choice cells
+    def highlight_cells(cells, roundedness=nil)
       return if cells.empty?
-      roundedness ||= [cells[0][:h], cells[0][:w]].min / 2
-      cells.each do |c|
-        out = Magick::Draw.new
-        out.fill 'yellow'
-        out.opacity '40%'
-        out.roundrectangle c[:x], c[:y], c[:x]+c[:w], c[:y]+c[:h], roundedness, roundedness
-        out.draw @image
+      @cmd << [:stroke, 'none']
+      @cmd << [:fill, 'rgba(255, 255, 0, 0.3)']
+      array_of(cells).each do |c|
+        roundedness ||= [c[:h], c[:w]].min / 2
+        pts = [c[:x], c[:y], c[:x]+c[:w], c[:y]+c[:h], roundedness, roundedness].join ' '
+        @cmd << [:draw, "roundrectangle #{pts}"]
       end
     end
     
-    def highlight_rect!(areas)
-      areas = [areas] if areas.is_a? Hash
+    def highlight_reg_area
+      highlight_rect [@rmsa[:tl], @rmsa[:tr], @rmsa[:br], @rmsa[:bl]]
+      return unless @status
+      join [@rm[:tl], @rm[:tr], @rm[:br], @rm[:bl]]
+    end
+    
+    def highlight_barcode(bitstring)
+      highlight_rect @grom.barcode_bit_areas bitstring
+    end
+    
+    def highlight_rect(areas)
+      return if areas.empty?
+      @cmd << [:fill, 'none']
+      @cmd << [:stroke, 'yellow']
+      @cmd << [:strokewidth, 3]
       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
+        pts = [c[:x], c[:y], c[:x]+c[:w], c[:y]+c[:h]].join ' '
+        @cmd << [:draw, "rectangle #{pts}"]
       end
     end
     
@@ -75,69 +111,98 @@ module Mork
       end
     end
     
-    def join!(p)
-      poly = Magick::Draw.new
-      poly.fill_opacity 0
-      poly.stroke 'green'
-      poly.stroke_width 3
-      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
+    # write the underlying MiniMagick::Image to disk;
+    # if the 2nd arg is false, then stretching is not applied
+    def write(fname, reg=true)
+      img = MiniMagick::Image.open @path
+      img.combine_options do |c|
+        c.distort(:perspective, perspective_points) if reg
+        @cmd.each do |cmd|
+          c.send *cmd
+        end
+      end
+      img.write fname
     end
     
-    # ============
-    # = Cropping =
-    # ============
-    def crop(c)
-      Mimage.new @image.crop(c[:x], c[:y], c[:w], c[:h])
-    end
+    # ============================================================#
+    private                                                       #
+    # ============================================================#
     
-    def crop!(c)
-      @image.crop!(c[:x], c[:y], c[:w], c[:h])
-      self
-    end
-    
-    # ============
-    # = Blurring =
-    # ============
-    def blur(a, b)
-      Mimage.new @image.blur_image(a, b)
-    end
-
-    def blur!(a, b)
-      @image = @image.blur_image(a, b)
-      self
+    def img_size
+      @img_size ||= IO.read("|identify -format '%w,%h' #{@path}").split ','
     end
     
-    # ==============
-    # = Stretching =
-    # ==============
-    def stretch(points)
-      Mimage.new @image.distort(Magick::PerspectiveDistortion, points)
+    def raw_pixels
+      @raw_pixels ||= begin
+        bytes = IO.read("|convert #{@path} gray:-").unpack 'C*'
+        NPatch.new bytes, width, height
+      end
     end
     
-    def stretch!(points)
-      @image = @image.distort(Magick::PerspectiveDistortion, points)
-      self
+    def reg_pixels
+      @reg_pixels ||= begin
+        bytes = IO.read("|convert #{@path} -distort Perspective '#{perspective_points}' gray:-").unpack 'C*'
+        NPatch.new bytes, width, height
+      end
     end
     
-    # returns the raw pixels from the entire image or from the area
-    # defined in opts
-    def pixels(opts = {})
-      c = {x: 0, y: 0, w: width, h: height}.merge(opts)
-      @image.export_pixels(c[:x], c[:y], c[:w], c[:h], "I")
+    def perspective_points
+      [
+        @rm[:tl][:x], @rm[:tl][:y],     0,      0,
+        @rm[:tr][:x], @rm[:tr][:y], width,      0,
+        @rm[:br][:x], @rm[:br][:y], width, height,
+        @rm[:bl][:x], @rm[:bl][:y],     0, height
+      ].join ' '
     end
-    
-    def width
-      @image.columns
+
+    def join(p)
+      @cmd << [:fill, 'none']
+      @cmd << [:stroke, 'green']
+      @cmd << [:strokewidth, 3]
+      pts = [p[0][:x], p[0][:y], p[1][:x], p[1][:y], p[2][:x], p[2][:y], p[3][:x], p[3][:y]].join ' '
+      @cmd << [:draw, "polygon #{pts}"]
+    end
+        
+    def array_of(cells)
+      out = []
+      cells.each_with_index do |q, i|
+        q.each do |c|
+          out << @grom.choice_cell_area(i, c)
+        end
+      end
+      out
     end
-    
-    def height
-      @image.rows
+
+    def register
+      # find the XY coordinates of the 4 registration marks
+      @rm   = {} # registration mark centers
+      @rmsa = {} # registration mark search area
+      @rm[:tl] = reg_centroid_on(:tl)
+      @rm[:tr] = reg_centroid_on(:tr)
+      @rm[:br] = reg_centroid_on(:br)
+      @rm[:bl] = reg_centroid_on(:bl)
+      # return the status
+      @rm.all? { |k,v| v[:status] == :ok }
     end
     
-    # write the underlying Magick::Image to disk
-    def write(fname)
-      @image.write fname
+    # returns the centroid of the dark region within the given area
+    # in the XY coordinates of the entire image
+    def reg_centroid_on(corner)
+      1000.times do |i|
+        @rmsa[corner] = @grom.rm_search_area(corner, i)
+        cx, cy = raw_pixels.dark_centroid @rmsa[corner]
+        if cx.nil?
+          status = :insufficient_contrast  
+        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] > @grom.rm_max_search_area_side
+      end
     end
   end
-end
+end

data/lib/mork/mimage_list.rb

@@ -1,4 +1,4 @@
-require 'RMagick'
+# require 'RMagick'
 
 module Mork
   # The class MimageList

data/lib/mork/npatch.rb

@@ -1,51 +1,75 @@
 require 'narray'
 
 module Mork
-  # Handles low-level computations on a Mimage
-  # Typically used on smaller patches
+  # NPatch handles low-level computations on pixels
+  # it is basically a wrapper around NArray
   class NPatch
-    def initialize(mim)
-      @mim = mim
-      @width  = mim.width
-      @height = mim.height
+    def initialize(source, width, height)
+      @patch = NArray.byte(width, height)
+      @patch[true] = case source
+                     when Array
+                       source
+                     when String
+                       IO.read("|convert #{source} gray:-").unpack 'C*'
+                     else
+                       raise 'Invalid NPatch init param'
+                     end
+      @width  = width
+      @height = height
     end
     
-    def average
-      narr.mean
+    def average(c=nil)
+      crop(c).mean
     end
     
-    def dark_centroid
-      sufficient_contrast? or return
-      xp = patch.sum(1).to_a
-      yp = patch.sum(0).to_a
+    def length
+      @patch.length
+    end
+    
+    def dark_centroid(c = nil)
+      p = crop c
+      sufficient_contrast?(p) or return
+      xp = p.sum(1).to_a
+      yp = p.sum(0).to_a
       # find the intensity trough
       ctr_x = xp.find_index(xp.min)
       ctr_y = yp.find_index(yp.min)
-      # return :edgy if edgy?(ctr_x, ctr_y)
       return ctr_x, ctr_y
     end
     
-  private
-    def patch
-      @the_npatch ||= blurry_narr.reshape!(@width, @height)
-    end
+    private
     
-    def narr
-      NArray[@mim.pixels]
+    def crop(c)
+      c =  {x: 0, y: 0, w: @width, h: @height} if c.nil?
+      x = c[:x]...c[:x]+c[:w]
+      y = c[:y]...c[:y]+c[:h]
+      p = NArray.float c[:w], c[:h]
+      p[true,true] = @patch[x, y]
+      p
     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)
+    def sufficient_contrast?(p)
+      # tested with the few examples: spec/samples/rm0x.jpeg
+      p.stddev > 20
     end
   end
-end
+end
+
+
+# def edgy?(x, y)
+#   tol = 5
+#   (x < tol) or (y < tol) or (y > @height - tol) or (x > @width - tol)
+# end
+#
+# def patch
+#   @the_npatch ||= blurry_narr.reshape!(@width, @height)
+# end
+#
+# def narr
+#   NArray[@mim.pixels]
+# end
+#
+# def blurry_narr
+#   @blurry_narr ||= NArray[@mim.blur!(10,5).pixels]
+# end
+#

data/lib/mork/sheet_omr.rb

@@ -1,28 +1,13 @@
 require 'mork/grid_omr'
 require 'mork/mimage'
 require 'mork/mimage_list'
-require 'mork/npatch'
 
 module Mork
   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
+    def initialize(path, grom=nil)
+      @grom = GridOMR.new grom
+      @mim = Mimage.new path, @grom
+      @ok_reg = @mim.status
     end
     
     def valid?
@@ -53,7 +38,7 @@ module Mork
     # false otherwise
     def marked?(q, c)
       return if not_registered
-      shade_of(q, c) < choice_threshold
+      @mim.shade_of(q, c) < choice_threshold
     end
     
     # TODO: define method ‘mark’ to retrieve the choice array for a single item
@@ -88,65 +73,41 @@ module Mork
     
     def outline(cells)
       return if not_registered
-      @crop.outline! array_of cells
+      raise "Invalid ‘cells’ argument" unless cells.kind_of? Array
+      @mim.outline cells
     end
     
-    def highlight_all
+    def highlight_marked
       return if not_registered
-      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
+      @mim.highlight_cells mark_array
     end
     
-    def highlight_marked
+    def highlight_all_choices
       return if not_registered
-      @crop.highlight_cells! array_of mark_array
+      @mim.highlight_all_choices
     end
     
     def highlight_barcode
       return if not_registered
-      @grom.barcode_bits.times do |bit|
-        if barcode_string.reverse[bit] == '1'
-          @crop.highlight_rect! @grom.barcode_bit_area bit+1
-        end
-      end
+      @mim.highlight_barcode barcode_string
     end
     
-    def highlight_reg_area
-      @raw.highlight_rect! [@rmsa[:tl], @rmsa[:tr], @rmsa[:br], @rmsa[:bl]]
-      return if not_registered
-      @raw.join! [@rm[:tl],@rm[:tr],@rm[:br],@rm[:bl]]
+    def highlight_registration
+      @mim.highlight_reg_area
     end
 
     def write(fname)
       return if not_registered
-      @crop.write(fname)
+      @mim.write(fname)
     end
     
     def write_raw(fname)
-      @raw.write(fname)
-    end
-    
-    # =================================
-    # = compute shading with NPatches =
-    # =================================
-    def shade_of(q, c)
-      naverage @grom.choice_cell_area(q, c)
+      @mim.write(fname, false)
     end
     
-  private
-  
-    def array_of(cells)
-      out = []
-      cells.each_with_index do |q, i|
-        q.each do |c|
-          out << @grom.choice_cell_area(i, c)
-        end
-      end
-      out
-    end
+    # ============================================================#
+    private                                                       #
+    # ============================================================#
 
     def question_range(r)
       if r.nil?
@@ -161,82 +122,19 @@ module Mork
     end
     
     def barcode_bit_value(i)
-      shade_of_barcode_bit(i) < barcode_threshold ? "1" : "0"
+      @mim.shade_of_barcode_bit(i) < barcode_threshold ? "1" : "0"
     end
     
-    def shade_of_barcode_bit(i)
-      naverage @grom.barcode_bit_area i+1
-    end
-
     def barcode_threshold
-      @barcode_threshold ||= (paper_white + ink_black) / 2
+      @barcode_threshold ||= (@mim.paper_white + ink_black) / 2
     end
     
     def choice_threshold
-      @choice_threshold ||= (ccmeans.mean - ink_black) * 0.9 + ink_black
-    end
-    
-    def ccmeans
-      @calcmeans ||= @grom.calibration_cell_areas.collect { |c| naverage c }
-    end
-    
-    def paper_white
-      @paper_white ||= naverage @grom.paper_white_area
+      @choice_threshold ||= (@mim.cal_cell_mean - ink_black) * 0.9 + ink_black
     end
     
     def ink_black
-      @ink_black ||= naverage @grom.ink_black_area
-    end
-    
-    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)
-      @rm[:tr] = reg_centroid_on(img, :tr)
-      @rm[:br] = reg_centroid_on(img, :br)
-      @rm[:bl] = reg_centroid_on(img, :bl)
-      return false if @rm.any? { |k,v| v[:status] != :ok }
-      # stretch the 4 points to fit the original size and return the resulting image
-      @crop = img.stretch [
-        @rm[:tl][:x], @rm[:tl][:y],         0,          0,
-        @rm[:tr][:x], @rm[:tr][:y], img.width,          0,
-        @rm[:br][:x], @rm[:br][:y], img.width, img.height,
-        @rm[:bl][:x], @rm[:bl][:y],         0, img.height
-      ]
-      true
-    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, corner)
-      1000.times do |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 < @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] > @grom.rm_max_search_area_side
-      end
-    end
-    
-    def naverage(where)
-      NPatch.new(@crop.crop where).average
+      @ink_black ||= @mim.ink_black
     end
     
     def not_registered

data/lib/mork/version.rb

@@ -1,3 +1,3 @@
 module Mork
-  VERSION = "0.1.3"
+  VERSION = "0.2.1"
 end