mork 0.8.1 → 0.9.0

data/lib/mork/mimage.rb

@@ -2,8 +2,7 @@ require 'mork/npatch'
 require 'mork/magicko'
 
 module Mork
-  # The class Mimage processes the image.
-  # Note that Mimage is NOT intended as public API, it should only be called by SheetOMR
+  # @private
   class Mimage
     attr_reader :rm
 
@@ -13,7 +12,6 @@ module Mork
       @grom   = grom.set_page_size @mack.width, @mack.height
       @rm     = {} # registration mark centers
       @valid = register
-      # @writing = nil
     end
 
     def valid?
@@ -25,66 +23,91 @@ module Mork
         tl: @rm[:tl][:status],
         tr: @rm[:tr][:status],
         br: @rm[:br][:status],
-        bl: @rm[:bl][:status],
-        write: @writing
+        bl: @rm[:bl][:status]
       }
     end
 
-    def marked?(q,c)
-      shade_of(q,c) < choice_threshold
+    def marked
+      @logical_array_of_marked_cells ||= begin # memoization necessary?
+        itemator { |q, c| shade_of(q, c) < choice_threshold }
+      end
     end
 
-    def barcode_bit?(i)
-      reg_pixels.average(@grom.barcode_bit_area i+1) < barcode_threshold
+    def marked_int
+      marked.map do |q|
+        [].tap do |choices|
+          q.each_with_index do |choice, idx|
+            choices << idx if choice
+          end
+        end
+      end
     end
 
-    def outline(cells)
-      return if cells.empty?
-      @mack.outline coordinates_of(cells)
+    def barcode_bits
+      @barcode_bits ||= begin
+        @grom.barcode_bits.times.collect do |b|
+          reg_pixels.average(@grom.barcode_bit_area b+1) < barcode_threshold
+        end
+      end
     end
 
-    # highlight_cells(cells, roundedness)
-    #
-    # partially transparent yellow on top of choice cells
-    def highlight_cells(cells)
-      return if cells.empty?
-      @mack.highlight_cells coordinates_of(cells)
+    def overlay(what, where)
+      areas = case where
+              when :barcode
+                @grom.barcode_areas barcode_bits
+              when :cal
+                @grom.calibration_cell_areas
+              when :marked
+                choice_cell_areas marked_int
+              when :all
+                all_choice_cell_areas
+              when :max
+                @grom.max_questions.times.map { |i| (0...@grom.max_choices_per_question).to_a }
+              when Array
+                choice_cell_areas where
+              else
+                raise ArgumentError, 'Invalid overlay argument “where”'
+              end
+      round = where != :barcode
+      @mack.send what, areas, round
     end
 
-    def highlight_all_choices
-      cells = (0...@grom.max_questions).collect { |i| (0...@grom.max_choices_per_question).to_a }
-      highlight_cells cells
+    # write the underlying MiniMagick::Image to disk;
+    # if no file name is given, image is processed in-place;
+    # if the 2nd arg is false, then stretching is not applied
+    def save(fname=nil, reg=true)
+      pp = reg ? @rm : nil
+      @mack.save fname, pp
     end
 
-    def highlight_barcode(bitstring)
-      @mack.highlight_rect @grom.barcode_bit_areas bitstring
+    def save_registration(fname)
+      each_corner { |c| @mack.plus @rm[c][:x], @rm[c][:y], 30 }
+      each_corner { |c| @mack.outline [@grom.rm_crop_area(c)], false }
+      @mack.save fname, nil
     end
 
-    def highlight_rm_centers
-      each_corner { |c| @mack.plus @rm[c][:x], @rm[c][:y], 20 }
-    end
+    # ============================================================#
+    private                                                       #
+    # ============================================================#
 
-    def highlight_rm_areas
-      each_corner { |c| @mack.highlight_area @grom.rm_crop_area(c) }
+    def itemator(items=@nitems)
+      items.map.with_index do |cho, q|
+        if cho.is_a? Fixnum
+          cho.times.map { |c| yield q, c }
+        else
+          cho.map { |c| yield q, c }
+        end
+      end
     end
 
-    def cross(cells)
-      return if cells.empty?
-      cells = [cells] if cells.is_a? Hash
-      @mack.cross coordinates_of(cells)
+    def choice_cell_areas(cells)
+      itemator(cells) { |q,c| @grom.choice_cell_area q, c }.flatten
     end
 
-    # write the underlying MiniMagick::Image to disk;
-    # if no file name is given, image is processed in-place;
-    # if the 2nd arg is false, then stretching is not applied
-    def write(fname=nil, reg=true)
-      pp = reg ? @rm : nil
-      @mack.write fname, pp
+    def all_choice_cell_areas
+      @all_choice_cell_areas ||= choice_cell_areas(@nitems)
     end
 
-    # ============================================================#
-    private                                                       #
-    # ============================================================#
     def each_corner
       [:tl, :tr, :br, :bl].each { |c| yield c }
     end
@@ -95,17 +118,14 @@ module Mork
 
     def choice_cell_averages
       @choice_cell_averages ||= begin
-        @nitems.each_with_index.collect do |cho, q|
-          cho.times.collect do |c|
-            reg_pixels.average @grom.choice_cell_area(q, c)
-          end
-        end
+        itemator { |q, c| reg_pixels.average @grom.choice_cell_area(q, c) }
       end
     end
 
     # TODO: 0.75 should be a parameter
     def choice_threshold
-      @choice_threshold ||= (cal_cell_mean - darkest_cell_mean) * 0.75 + darkest_cell_mean
+      # puts "CT #{@grom.choice_threshold.inspect}"
+      @choice_threshold ||= (cal_cell_mean - darkest_cell_mean) * @grom.choice_threshold + darkest_cell_mean
     end
 
     def barcode_threshold
@@ -142,10 +162,6 @@ module Mork
     # plus the stdev of the search area as quality control
     def register
       each_corner { |c| @rm[c] = rm_centroid_on c }
-      # puts "TL: #{@rm[:tl].inspect}"
-      # puts "TR: #{@rm[:tr].inspect}"
-      # puts "BR: #{@rm[:br].inspect}"
-      # puts "BL: #{@rm[:bl].inspect}"
       @rm.all? { |k,v| v[:status] == :ok }
     end
 
@@ -154,7 +170,6 @@ module Mork
     def rm_centroid_on(corner)
       c = @grom.rm_crop_area(corner)
       p = @mack.rm_patch(c, @grom.rm_blur, @grom.rm_dilate)
-      # puts "REG #{@grom.rm_blur} - #{@grom.rm_dilate} - C #{c.inspect}"
       n = NPatch.new(p, c.w, c.h)
       cx, cy, sd = n.centroid
       st = (cx < 2) or (cy < 2) or (cy > c.h-2) or (cx > c.w-2)
@@ -197,3 +212,49 @@ end
 #   @mack.raw_patch
 # end
 
+# def outline(cells)
+#   return if cells.empty?
+#   @mack.outline coordinates_of(cells)
+# end
+
+# # highlight_cells(cells, roundedness)
+# #
+# # partially transparent yellow on top of choice cells
+# def highlight_cells(cells)
+#   return if cells.empty?
+#   @mack.highlight_cells coordinates_of(cells)
+# end
+
+# def highlight_all_choices
+#   cells = (0...@grom.max_questions).collect { |i| (0...@grom.max_choices_per_question).to_a }
+#   highlight_cells cells
+# end
+
+# def highlight_barcode(bitstring)
+#   @mack.highlight_rect @grom.barcode_bit_areas bitstring
+# end
+
+# def highlight_rm_centers
+#   each_corner { |c| @mack.plus @rm[c][:x], @rm[c][:y], 20 }
+# end
+
+# def highlight_rm_areas
+#   each_corner { |c| @mack.highlight_area @grom.rm_crop_area(c) }
+# end
+
+# def cross(cells)
+#   return if cells.empty?
+#   cells = [cells] if cells.is_a? Hash
+#   @mack.cross coordinates_of(cells)
+# end
+
+# def barcode_bit?(i)
+#   reg_pixels.average(@grom.barcode_bit_area i+1) < barcode_threshold
+# end
+
+# puts "TL: #{@rm[:tl].inspect}"
+# puts "TR: #{@rm[:tr].inspect}"
+# puts "BR: #{@rm[:br].inspect}"
+# puts "BL: #{@rm[:bl].inspect}"
+
+# puts "REG #{@grom.rm_blur} - #{@grom.rm_dilate} - C #{c.inspect}"

data/lib/mork/mimage_list.rb

@@ -1,7 +1,8 @@
 # require 'RMagick'
 
 module Mork
-  # The class MimageList
+  # @private
+  # The class MimageList, currently abandoned
   class MimageList
     def initialize(fname)
       raise "Initializing a MimageList requires a string" unless fname.class == String
@@ -11,21 +12,21 @@ module Mork
         @images = Magick::ImageList.new(fname)
       end
     end
-    
+
     def shift
       Mimage.new @images.shift
     end
-    
+
     def [] (i)
       # puts "I: #{i}"
       # puts @images[i].inspect
       Mimage.new @images[i]
     end
-    
+
     def each
       @images.each do |i|
         yield Mimage.new i
       end
     end
   end
-end
+end

data/lib/mork/npatch.rb

@@ -1,6 +1,7 @@
 require 'narray'
 
 module Mork
+  # @private
   # NPatch handles low-level computations on pixels by leveraging NArray
   class NPatch
     # NPatch.new(source, width, height) constructs an NPatch object
@@ -9,36 +10,28 @@ module Mork
     def initialize(source, width, height)
       @patch = NArray.float(width, height)
       @patch[true] = source
-      @width  = width
-      @height = height
+      # @width  = width
+      # @height = height
     end
 
-    def average(c)
-      @patch[c.x_rng, c.y_rng].mean
+    def average(coord)
+      @patch[coord.x_rng, coord.y_rng].mean
     end
 
-    def stddev(c)
-      @patch[c.x_rng, c.y_rng].stddev
+    def stddev(coord)
+      @patch[coord.x_rng, coord.y_rng].stddev
     end
 
-    def length
-      # is this only going to be used for testing purposes?
-      @patch.length
-    end
+    # def length
+    #   # is this only going to be used for testing purposes?
+    #   @patch.length
+    # end
 
     def centroid
       xp = @patch.sum(1).to_a
       yp = @patch.sum(0).to_a
       return xp.find_index(xp.min), yp.find_index(yp.min), @patch.stddev
     end
-
-    private
-
-    def sufficient_contrast?(p)
-      # puts "Contrast: #{p.stddev}"
-      # tested with the few examples: spec/samples/rm0x.jpeg
-      p.stddev > 20
-    end
   end
 end
 
@@ -61,3 +54,8 @@ end
 #   p
 # end
 
+# def sufficient_contrast?(p)
+#   # puts "Contrast: #{p.stddev}"
+#   # tested with the few examples: spec/samples/rm0x.jpeg
+#   p.stddev > 20
+# end