mork 0.0.1 → 0.0.2

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+tmp/*
+.rvmrc
+.rspec

data/Gemfile

@@ -1,4 +1,3 @@
 source "http://rubygems.org"
-
-# Specify your gem's dependencies in mork.gemspec
+gem 'prawn', git: 'git://github.com/prawnpdf/prawn', submodules: true
 gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+guard 'rspec', all_after_pass: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/mork/(.+)\.rb$})     { |m| "spec/mork/#{m[1]}_spec.rb" }
+end
+
+guard :shell do
+  watch "tmp/code_sample.pdf" do
+    system "open tmp/code_sample.pdf"
+  end
+end

data/config/grids.yml

@@ -0,0 +1,42 @@
+default:
+  page_size:
+    width:       210.0
+    height:      297.0
+  header:
+    name:
+      top:         3
+      left:        7.5
+      width:     120
+      size:       14
+    code:
+      top:         3
+      left:      170
+      width:      25
+      size:       12
+    title:
+      top:        12
+      left:       7.5
+      width:    180.0
+      size:      12
+    date:
+      top:        18
+      left:       7.5
+      width:    180.0
+      size:      12
+  responses:
+    columns:       4
+    column_width: 50.0
+    rows:         40
+    # from the top-left registration mark
+    # to the center of the first choice cell
+    first_x:      10.5
+    first_y:      35.5
+    # between choices
+    x_spacing:     7.0
+    # between rows
+    y_spacing:     6.0
+    # darkened area
+    cell_width:    6.0
+    cell_height:   4.0
+    # the maximum number of choices per question
+    max_cells:     5

data/lib/mork.rb

@@ -1,5 +1,9 @@
 require "mork/version"
-
-module Mork
-  # Your code goes here...
-end
+require 'mork/sheet'
+require 'mork/grid'
+require 'mork/grid_const'
+require 'mork/mimage'
+require 'mork/mimage_list'
+require 'mork/report'
+require 'mork/npatch'
+require 'mork/sheet_pdf'

data/lib/mork/grid.rb

@@ -0,0 +1,307 @@
+require 'yaml'
+
+module Mork
+  # The Grid is a set of expectations on what the response sheet should look like
+  # It knows nothing about the actual scanned image
+  # All returned values are in the arbitrary units given in the configuration file
+  class Grid
+    
+    def initialize(type = :default, fname="config/grids.yml")
+      # from the full YAML file, only get the requested grid type
+      c = YAML.load_file(fname)
+      @params = c[type.to_s]
+    end
+    
+    def set_page_size(x, y)
+      @px = x.to_f
+      @py = y.to_f
+    end
+    
+    def default_chlist
+      [@params["responses"]["max_cells"]] * max_questions
+    end
+    
+    def max_questions
+      columns * rows
+    end
+    
+    def max_choices_per_question
+      @params["responses"]["max_cells"]
+    end
+    
+    def code_bits
+      CODE_BITS
+    end
+    
+    def header
+      @params["header"]
+    end
+    
+    def reg_mark_search_area(n)
+      rmp = REG_MARGIN + REG_SEARCH
+      rmm = REG_MARGIN - REG_SEARCH
+      case n
+      when :top_left
+        reg_mark_sa rmm, rmm
+      when :top_right
+        reg_mark_sa page_width  - rmp, rmm
+      when :bottom_right
+        reg_mark_sa page_width - rmp, page_height - rmp
+      when :bottom_left
+        reg_mark_sa rmm, page_height - rmp
+      end
+    end
+
+    def reg_mark_sa(x, y)
+      cw = @px / page_width
+      ch = @py / page_height
+      {
+          x: (cw * x).round,
+          y: (ch * y).round,
+          w: (cw * REG_SEARCH * 2).round,
+          h: (ch * REG_SEARCH * 2).round
+      }      
+    end
+
+    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 white_calibration_area
+      code_cell_area -1
+    end
+    
+    def black_calibration_area
+      code_cell_area 0
+    end
+    
+    def code_bit_area(i)
+      code_cell_area i+1
+    end
+    
+    # ============
+    # = to Prawn =
+    # ============
+    def pdf_page_size
+      [page_width.mm, page_height.mm]
+    end
+    
+    def pdf_margins
+      REG_MARGIN.mm
+    end
+    
+    def pdf_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 pdf_dark_calibration_area
+      pdf_code_cell_area 0
+    end
+
+    def pdf_code_areas_for(code)
+      a = []
+      CODE_BITS.times do |bit|
+        a << pdf_code_cell_area(bit+1) if code[bit] == 1
+      end
+      a
+    end
+
+    def pdf_code_bit_areas
+      (1..CODE_BITS).collect do |bit|
+        pdf_code_cell_area bit
+      end
+    end
+    
+    def pdf_code_cell_area(i)
+      {
+        p: [code_cell_x(i).mm, (reg_frame_height - code_y).mm],
+        w: CODE_WIDTH.mm,
+        h: CODE_HEIGHT.mm * 2
+      }
+    end
+
+    def pdf_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 pdf_choice_letter_xy(q, c)
+      [
+        cell_x(q, c).mm + 2.mm,
+        (reg_frame_height - cell_y(q)).mm - 3.mm
+      ]
+    end
+
+    def pdf_qnum_xy(q)
+      [
+        cell_x(q, 0).mm - pdf_qnum_width - Q_NUM_GAP.mm,
+        (reg_frame_height - cell_y(q)).mm - 0.5.mm
+      ]
+    end
+
+    def pdf_qnum_width
+      Q_NUM_WIDTH.mm
+    end
+    
+    def pdf_header_xy(k)
+      [
+        header[k.to_s]["left"].to_f.mm,
+        (reg_frame_height - header[k.to_s]["top"].to_f).mm
+      ]
+    end
+    
+    def pdf_header_width(k)
+      header[k.to_s]["width"].to_f.mm
+    end
+
+    def pdf_header_size(k)
+      header[k.to_s]["size"].to_f
+    end
+
+  private
+  
+    def cx
+      @px / reg_frame_width
+    end
+    
+    def cy
+      @py / reg_frame_height
+    end
+    
+    # x, y = cell_xy(q,c)
+    # 
+    # the distances from the registration frame of the left and top edges
+    # of the c-th choice cell of the q-th question
+    def cell_xy(q, c)
+      return cell_x(q, c), cell_y(q)
+    end
+    
+    # cell_y(q)
+    # 
+    # the distance from the registration frame to the top edge
+    # of all choice cells in the q-th question
+    def cell_y(q)
+      first_y + response_spacing * (q % rows) - cell_height / 2
+    end
+    
+    # cell_x(q,c)
+    # 
+    # the distance from the registration frame to the left edge
+    # of the c-th choice cell of the q-th question
+    def cell_x(q,c)
+      first_x + column_width * (q / rows) + cell_spacing * c - cell_width / 2
+    end
+    
+    def cell_width
+      @params["responses"]["cell_width"].to_f
+    end
+  
+    def cell_height
+      @params["responses"]["cell_height"].to_f
+    end
+    
+    def cell_spacing
+      @params["responses"]["x_spacing"].to_f
+    end
+    
+    def response_spacing
+      @params["responses"]["y_spacing"].to_f
+    end
+    
+    def column_width
+      @params["responses"]["column_width"].to_f
+    end
+    
+    def row_spacing
+      @params["responses"]["y_spacing"].to_f
+    end
+
+    def first_x
+      @params["responses"]["first_x"].to_f
+    end
+
+    def first_y
+      @params["responses"]["first_y"].to_f
+    end
+    
+    def rows
+      @params["responses"]["rows"]
+    end
+    
+    def columns
+      @params["responses"]["columns"]
+    end
+    
+    # ==============
+    # = sheet code =
+    # ==============
+    def code_cell_area(i)
+      {
+        x: (cx * code_cell_x(i)  ).round,
+        y: (cy * code_y          ).round,
+        w: (cx * CODE_WIDTH ).round,
+        h: (cy * CODE_HEIGHT).round
+      }
+    end
+  
+    def code_cell_x(i)
+      CODE_LEFT + CODE_SPACING * i
+    end
+
+    def code_y
+      reg_frame_height - CODE_HEIGHT
+    end
+    
+    # ======================
+    # = registration sides =
+    # ======================
+    def reg_frame_width
+      page_width - REG_MARGIN * 2
+    end
+    
+    def reg_frame_height
+      page_height - REG_MARGIN * 2
+    end
+    
+    def page_width
+      @params["page_size"]["width"].to_f
+    end
+    
+    def page_height
+      @params["page_size"]["height"].to_f
+    end
+
+    # ============
+    # =   Header
+    # ============
+    def name_x
+      @params["header"]["name"]["top"].to_f
+    end
+
+    def name_y
+      @params["header"]["name"]["left"].to_f
+    end
+
+    def name_w
+      @params["header"]["name"]["width"].to_f
+    end
+
+    def name_size
+      @params["header"]["name"]["size"]
+    end
+  end
+end

data/lib/mork/grid_const.rb

@@ -0,0 +1,14 @@
+module Mork
+  REG_MARGIN    =  7.5
+  REG_RADIUS    =  2.5
+  REG_SEARCH    =  5.0
+  CODE_LEFT     =  7.5
+  CODE_WIDTH    =  2.0
+  CODE_HEIGHT   =  2.5
+  CODE_SPACING  =  2.5
+  CODE_BITS     = 64
+  Q_NUM_GAP     =  2.0  # distance between right side of q num and left side of first choice cell
+  Q_NUM_WIDTH   =  8.0  # width of question number text box
+  Q_NUM_SIZE    = 10
+  CH_LETTER_SZ  =  8
+end

data/lib/mork/mimage.rb

@@ -0,0 +1,86 @@
+require 'RMagick'
+
+module Mork
+  # The class Mimage is a wrapper for the core image library, currently RMagick
+  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
+    end
+    
+    # =============
+    # = Highlight =
+    # =============
+    def highlight!(c)
+      m = Magick::Image.new(c[:w], c[:h]) { self.background_color = "red" }
+      @image.composite! m, c[:x], c[:y], Magick::CopyCompositeOp
+    end
+    
+    # ============
+    # = Cropping =
+    # ============
+    def crop(c)
+      Mimage.new @image.crop(c[:x], c[:y], c[:w], c[:h])
+    end
+    
+    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
+    end
+    
+    # ==============
+    # = Stretching =
+    # ==============
+    def stretch(points)
+      Mimage.new @image.distort(Magick::PerspectiveDistortion, points)
+    end
+    
+    def stretch!(points)
+      @image = @image.distort(Magick::PerspectiveDistortion, points)
+      self
+    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")
+    end
+    
+    def width
+      @image.columns
+    end
+    
+    def height
+      @image.rows
+    end
+    
+    # write the underlying Magick::Image to disk
+    def write(fname)
+      @image.write fname
+    end
+  end
+end