sqed 0.0.1

data/lib/sqed/boundary_finder/color_line_finder.rb

@@ -0,0 +1,83 @@
+require 'RMagick'
+
+# This was "green" line finder attempting to be agnostic; now it is reworked to be color-specific line finder
+#
+class Sqed::BoundaryFinder::ColorLineFinder < Sqed::BoundaryFinder
+
+  def initialize(image: image, layout: layout, boundary_color: :green)
+    super(image: image, layout: layout)
+    raise 'No layout provided.' if @layout.nil?
+    @boundary_color = boundary_color
+    find_bands
+  end
+
+  private
+
+  def find_bands
+    case @layout    # boundaries.coordinates are referenced from stage image
+
+    when :vertical_split    # can vertical and horizontal split be re-used to do cross cases?
+      t = Sqed::BoundaryFinder.color_boundary_finder(image: img, boundary_color: @boundary_color)  #detect vertical division, green line
+      return if t.nil?
+      boundaries.coordinates[0] = [0, 0, t[0], img.rows]  # left section of image
+      boundaries.coordinates[1] = [t[2], 0, img.columns - t[2], img.rows]  # right section of image
+      boundaries.complete = true
+
+    when :horizontal_split
+      t = Sqed::BoundaryFinder.color_boundary_finder(image: img, scan: :columns, boundary_color: @boundary_color)  # set to detect horizontal division, (green line)
+      return if t.nil?
+      boundaries.coordinates[0] = [0, 0, img.columns, t[0]]  # upper section of image
+      boundaries.coordinates[1] = [0, t[2], img.columns, img.rows - t[2]]  # lower section of image
+      boundaries.complete = true
+      # boundaries.coordinates[2] = [0, 0, img.columns, t[1]]  # upper section of image
+      # boundaries.coordinates[3] = [0, t[1], img.columns, img.rows - t[1]]  # lower section of image
+
+    when :right_t   # only 3 zones expected, with horizontal division in right-side of vertical division
+      t = Sqed::BoundaryFinder.color_boundary_finder(image: img, boundary_color: @boundary_color)  #defaults to detect vertical division, green line
+      return if t.nil?
+      boundaries.coordinates[0] = [0, 0, t[0], img.rows]  # left section of image
+      boundaries.coordinates[1] = [t[2], 0, img.columns - t[2], img.rows]  # left section of image
+
+      # now subdivide right side
+      irt = img.crop(*boundaries.coordinates[1], true)
+      rt = Sqed::BoundaryFinder.color_boundary_finder(image: irt, scan: :columns, boundary_color: @boundary_color)  # set to detect horizontal division, (green line)
+      return if rt.nil?
+      boundaries.coordinates[1] = [t[2], 0, img.columns - t[2], rt[0]]  # upper section of image
+      boundaries.coordinates[2] = [t[2], rt[2], img.columns - t[2], img.rows - rt[2]]  # lower section of image
+      boundaries.complete = true
+      # will return 1, 2, or 3
+
+    when :offset_cross   # 4 zones expected, with horizontal division in right- and left- sides of vertical division
+      t = Sqed::BoundaryFinder.color_boundary_finder(image: img, boundary_color: @boundary_color)  # defaults to detect vertical division, green line
+      raise if t.nil?
+      boundaries.coordinates[0] = [0, 0, t[0], img.rows]  # left section of image
+      boundaries.coordinates[1] = [t[2], 0, img.columns - t[2], img.rows]  # right section of image
+
+      # now subdivide left side
+      ilt = img.crop(*boundaries.coordinates[0], true)
+
+      lt = Sqed::BoundaryFinder.color_boundary_finder(image: ilt, scan: :columns, boundary_color: @boundary_color)  # set to detect horizontal division, (green line)
+      if !lt.nil?
+        boundaries.coordinates[0] = [0, 0, t[0], lt[0]]  # upper section of image
+        boundaries.coordinates[3] = [0, lt[2], t[0], img.rows - lt[2]]  # lower section of image
+      end
+
+      # now subdivide right side
+      irt = img.crop(*boundaries.coordinates[1], true)
+      rt = Sqed::BoundaryFinder.color_boundary_finder(image: irt, scan: :columns, boundary_color: @boundary_color)  # set to detect horizontal division, (green line)
+      return if rt.nil?
+
+      boundaries.coordinates[1] = [t[2], 0, img.columns - t[2], rt[0]]  # upper section of image
+      boundaries.coordinates[2] = [t[2], rt[2], img.columns - t[2], img.rows - rt[2]]  # lower section of image
+      # will return 1, 2, 3, or 4  //// does not handle staggered vertical boundary case
+      boundaries.complete = true
+
+    else
+      boundaries.coordinates[0] = [0, 0, img.columns, img.rows]  # totality of image as default
+      return    # return original image boundary if no method implemented
+    end
+
+  end
+
+
+end

data/lib/sqed/boundary_finder/cross_finder.rb

@@ -0,0 +1,23 @@
+require 'RMagick'
+
+# Return four equal quadrants, no parsing through the image
+#
+class Sqed::BoundaryFinder::CrossFinder < Sqed::BoundaryFinder
+
+  def initialize(image: image)
+    @image = image
+    find_edges 
+  end
+
+  def find_edges
+    width = @image.columns / 2
+    height = @image.rows / 2
+
+    boundaries.coordinates[0] = [0, 0, width, height] 
+    boundaries.coordinates[1] = [width, 0, width, height] 
+    boundaries.coordinates[2] = [width, height, width, height] 
+    boundaries.coordinates[3] = [0, height, width, height] 
+    boundaries.complete = true
+  end
+
+end

data/lib/sqed/boundary_finder/stage_finder.rb

@@ -0,0 +1,139 @@
+require 'RMagick'
+
+# Some of this code was originally inspired by Emmanuel Oga's gist https://gist.github.com/EmmanuelOga/2476153.
+#
+class Sqed::BoundaryFinder::StageFinder < Sqed::BoundaryFinder
+  
+  # The proc containing the border finding algorithim
+  attr_reader :is_border
+
+  # assume white-ish image on dark-ish background
+
+  # How small we accept a cropped picture to be. E.G. if it was 100x100 and
+  # ratio 0.1, min output should be 10x10
+  MIN_CROP_RATIO = 0.1    
+
+  attr_reader :x0, :y0, :x1, :y1, :min_width, :min_height, :rows, :columns 
+
+  def initialize(image: image, is_border_proc: nil, min_ratio: MIN_CROP_RATIO)
+    super(image: image, layout: :internal_box)
+
+    @min_ratio =  min_ratio
+
+    # Initial co-ordinates
+    @x0, @y0 = 0, 0
+    @x1, @y1 = img.columns, img.rows 
+    @min_width, @min_height = img.columns * @min_ratio, img.rows * @min_ratio # minimum resultant area
+    @columns, @rows = img.columns, img.rows
+
+    # We need a border finder proc. Provide one if none was given.
+    @is_border = is_border_proc || self.class.default_border_finder(img)  # if no proc specified, use default below
+
+    @x00 = @x0
+    @y00 = @y0
+    @height0 = height
+    @width0 = width
+    find_edges
+  end
+
+  private
+
+  # Returns a Proc that, given a set of pixels (an edge of the image) decides
+  # whether that edge is a border or not.
+  # 
+  # (img, samples = 5, threshold = 0.95, fuzz_factor = 0.5)  # initially 
+  # (img, samples = 50, threshold = 0.9, fuzz_factor = 0.1)   # semi-working on synthetic images 08-dec-2014 (x)
+  # (img, samples = 20, threshold = 0.8, fuzz_factor = 0.2)   # WORKS with synthetic images and changes to x0, y0, width, height
+  # 
+  # appears to assume sharp transition will occur in 5 pixels x/y
+  #
+  # how is threshold defined?
+  # works for 0.5, >0.137; 0.60, >0.14 0.65, >0.146; 0.70, >0.1875; 0.75, >0.1875; 0.8, >0.237; 0.85, >0.24; 0.90, >0.28; 0.95, >0.25
+  # fails for 0.75, (0.18, 0.17,0.16,0.15); 0.70, 0.18;
+  #
+  def self.default_border_finder(img, samples = 5, threshold = 0.75, fuzz_factor = 0.40)   # working on non-synthetic images 04-dec-2014
+   fuzz = ((::QuantumRange + 1)  * fuzz_factor).to_i  
+    # Returns true if the edge is a border (border meaning outer region to be cropped)
+    lambda do |edge|
+      border, non_border = 0.0, 0.0 # maybe should be called outer, inner
+
+      pixels = (0...samples).map { |n| edge[n * edge.length / samples] }
+      pixels.combination(2).each do |a, b|
+        if a.fcmp(b, fuzz) then
+          border += 1
+        else
+          non_border += 1
+        end
+      end
+      bratio = border.to_f / (border + non_border)
+      if bratio > threshold
+        return true
+      else
+        return false
+      end
+      border.to_f / (border + non_border) > threshold # number of matching string of pixels/(2 x total pixels - a.k.a. samples?)
+    end
+  end
+
+  def find_edges
+    # handle this exception
+    return unless is_border # return if no process defined or set for @is_border
+
+    u = x1 - 1    # rightmost pixel (kind of)
+    # increment from left to right
+    x0.upto(u) do |x|
+      if width_croppable? && is_border[vline(x)] then
+        @x0 = x + 1
+      else
+        break
+      end
+    end
+    # increment from left to right
+    (u).downto(x0) { |x| width_croppable?  && is_border[vline(x)] ? @x1 = x - 1 : break }
+
+    u = y1 - 1
+    0.upto(u) do |y|
+      if height_croppable? && is_border[hline y] then
+        @y0 = y + 1
+      else
+        break
+      end
+    end
+    (u).downto(y0) { |y| height_croppable? && is_border[hline y] ? @y1 = y - 1 : break }
+    u = 0
+
+    delta_x = 0 #width/50    # 2% of cropped image to make up for trapezoidal distortion
+    delta_y = 0 #height/50   # 2% of cropped image to make up for trapezoidal distortion <- NOT 3%
+  
+    # TODO: add conditions
+    boundaries.complete = true 
+    boundaries.coordinates[0] = [x0 + delta_x, y0 + delta_y, width - 2*delta_x, height - 2*delta_y]
+  end
+
+  def width_croppable?
+    width > min_width
+  end
+
+  def height_croppable?
+    height > min_height
+  end
+
+  def vline(x)
+    img.get_pixels x, @y00, 1, @height0 - 1
+  end
+
+  def hline(y)
+    img.get_pixels @x00, y, @width0 - 1, 1
+  end
+
+  # actually  + 1 (starting at zero?)
+  def width   
+    @x1 - @x0  
+  end
+ 
+  # actually  + 1 (starting at zero?)
+  def height
+    @y1 - @y0 
+  end
+
+end

data/lib/sqed/extractor.rb

@@ -0,0 +1,45 @@
+require 'RMagick'
+
+# An Extractor takes Boundries object and a layout pattern and returns a Sqed::Result
+# 
+class Sqed::Extractor
+
+  attr_accessor :boundaries, :layout, :image
+
+  def initialize(boundaries: boundaries, layout: layout, image: image)
+    raise if boundaries.nil? || !boundaries.class == Sqed::Boundaries
+    raise if layout.nil? || !layout.class == Hash
+
+    @layout = layout
+    @boundaries = boundaries
+    @image = image
+  end
+
+  def result
+    r = Sqed::Result.new()
+   
+    # assign the images to the result
+    boundaries.each do |section, coords|
+      r.send("#{LAYOUT_SECTION_TYPES[section]}=", extract_image(coords))
+    end 
+
+    # assign the metadata to the result
+    layout.keys.each do |section_index, section_type|
+      # only extract data if a parser exists
+      if parser = SECTION_PARSERS[section_type]
+        r.send("#{section_type}=", parser.new(image: r.send(section_type + "_image").text) )
+      end
+    end
+
+    r
+  end
+
+  # coords are x1, y1, x2, y2
+  def extract_image(coords)
+    # crop takes x, y, width, height
+    # @image.crop(coords[0], coords[1], coords[2] - coords[0], coords[3] - coords[1] )
+    bp = 0
+    @image.crop(coords[0], coords[1], coords[2], coords[3], true)
+  end
+
+end

data/lib/sqed/parser.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+#
+# Base class for Parsers
+#
+class Sqed::Parser
+  attr_accessor :image
+
+  def initialize(image)
+    @image = image 
+  end
+end

data/lib/sqed/parser/barcode_parser.rb

@@ -0,0 +1,27 @@
+# Given an image, return an ordered array of detectable barcodes
+
+class Sqed::Parser::BarcodeParser < Sqed::Parser
+  attr_accessor :barcodes
+
+  def initialize(image)
+    super
+    @barcodes = bar_codes
+  end
+
+  def bar_codes
+    # process the images, spit out the barcodes
+    # return ZXing.decode_all(@image)   #['ABC 123', 'DEF 456']
+    # a = `/usr/local/Cellar/zbar/0.10_1/bin/zbarimg ~/src/sqed/spec/support/files/test_barcode.JPG`
+    # b = a.split("\n")
+    f = 'SessionID_BarcodeImage.JPG'
+    i = @image[:image]
+    if i.nil?
+      i = @image
+    end
+    i.write("tmp/#{f}")
+    c = `/usr/local/Cellar/zbar/0.10_1/bin/zbarimg #{f}`
+    d = c.split("\n")
+    return d
+  end
+
+end

data/lib/sqed/parser/ocr_parser.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+#
+# Given a single image return all text in that image.
+#
+# For past reference http://misteroleg.wordpress.com/2012/12/19/ocr-using-tesseract-and-imagemagick-as-pre-processing-task/
+#
+require 'rtesseract' 
+
+class Sqed::Parser::OcrParser < Sqed::Parser
+  attr_accessor  :text
+
+  def text
+    img = @image #.white_threshold(245)
+
+    # @jrflood: this is where you will have to do some research, tuning images so that they can be better ocr-ed,
+    # all of these methods are from RMagick.
+    # get potential border pixel color (based on quadrant?)
+    new_color = img.pixel_color(1, 1)
+    # img = img.scale(2)
+    # img.write('foo0.jpg.jpg')
+    # img = img.enhance
+    # img = img.enhance
+    # img = img.enhance
+    # img = img.enhance
+    # img.write('foo1.jpg')
+    # img = img.quantize(8, Magick::GRAYColorspace)
+    # img.write('foo1.jpg')
+    # img = img.sharpen(1.0, 0.2)
+    # img.write('foo2.jpg')
+    # border_color = img.pixel_color(img.columns - 1, img.rows - 1)
+    # img = img.color_floodfill(img.columns - 1, img.rows - 1, new_color)
+    # img.write('tmp/foo4.jpg')
+    # img = img.quantize(2, Magick::GRAYColorspace)
+    # #img = img.threshold(0.5)
+    # img.write('foo4.jpg') # for debugging purposes, this is the image that is sent to OCR
+    # img = img.equalize #(32, Magick::GRAYColorspace)
+    # img.write('foo5.jpg') # for debugging purposes, this is the image that is sent to OCR
+    # #img.write('foo3.jpg') # for debugging purposes, this is the image that is sent to OCR
+    #
+    # img.write('foo.jpg') # for debugging purposes, this is the image that is sent to OCR
+
+    r = RTesseract.new(img, lang: 'eng', psm: 3)
+
+
+    # img = img.white_threshold(245)
+
+    @text = r.to_s 
+  end
+
+  # Need to provide tuning methods here, i.e. image transormations that facilitate OCR
+
+end

data/lib/sqed/result.rb

@@ -0,0 +1,15 @@
+
+# A Sqed::Result is a wrapper for the results of the
+# full process of data extraction from an image.
+#
+#
+#
+class Sqed::Result
+
+  SqedConfig::LAYOUT_SECTION_TYPES.each do |k|
+    attr_accessor k
+    attr_accessor "#{k}_image".to_sym
+  end
+end
+
+

data/lib/sqed/version.rb

@@ -0,0 +1,3 @@
+class Sqed
+  VERSION = "0.0.1"
+end

data/lib/sqed_config.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+
+require_relative "sqed/parser"
+require_relative "sqed/parser/ocr_parser"
+require_relative "sqed/parser/barcode_parser"
+
+require_relative "sqed/boundaries"
+require_relative "sqed/boundary_finder"
+require_relative "sqed/boundary_finder/cross_finder"
+require_relative "sqed/boundary_finder/stage_finder"
+require_relative "sqed/boundary_finder/color_line_finder"
+
+# Sqed constants, including patterns for extraction etc.
+#
+module SqedConfig
+
+  # Layouts refer to the arrangement of the divided stage.
+  # Windows are enumerated from the top left, moving around the border 
+  # in a clockwise position.  For example:
+  #    0  | 1
+  #   ----|----  :equal_cross //probably obviated by offset_cross
+  #    3  | 2
+  #  
+  #       | 1
+  #    0  |----  :right_t
+  #       | 2
+  #
+  # should be an arbitrary cross layout
+  #    0  |  1
+  #       |
+  #   ---------  :offset_cross //does not match current code
+  #    3   | 2
+  #
+  #    0  |  1
+  #       |____
+  #   ----|      :offset_cross // matches current code
+  #    3  |  2
+  #
+  #        0
+  #    --------  :horizontal_split
+  #        1
+  #
+  #        |
+  #      0 | 1  :vertical_split
+  #        |
+  #
+  #   -----
+  #   | 0 |  :internal_box
+  #   -----
+  #
+
+  # Hash values are used to stub out
+  # the Sqed::Boundaries instance.
+  #
+  LAYOUTS = {
+    cross: [0,1,2,3],
+    offset_cross: [0,1,2,3],
+    horizontal_split: [0,1],
+    vertical_split: [0,1],
+    right_t: [0,1,2],
+    left_t: [0,1,2],
+    internal_box: [0]
+  }
+
+  #  Each element of the layout is a "section".  
+  LAYOUT_SECTION_TYPES = [
+    :stage,                 # the image contains the full stage 
+    :specimen,              # the specimen only, no metadata should be present
+    :annotated_specimen,    # a specimen is present, and metadata is too
+    :determination_labels,  # the section contains text that determines the specimen
+    :labels,                # the section contains collecting event and non-determination labels
+    :identifier,            # the section contains an identifier (e.g. barcode or unique number)
+    :image_registration     # the section contains only image registration information
+  ] 
+
+  # Links section types to data parsers
+  SECTION_PARSERS = {
+    labels: Sqed::Parser::OcrParser,
+    identifier: Sqed::Parser::BarcodeParser,
+    deterimination_labels: Sqed::Parser::OcrParser
+  }
+
+  EXTRACTION_PATTERNS = {
+    right_t: {
+      boundary_finder: Sqed::BoundaryFinder::ColorLineFinder,
+      layout: :right_t,
+      metadata_map: {0 => :annotated_specimen, 1 => :identifiers, 2 =>:image_registration }
+    },
+    offset_cross: {
+      boundary_finder: Sqed::BoundaryFinder::ColorLineFinder,
+      layout: :offset_cross,
+      metadata_map: {0 => :annotated_specimen, 1 => :identifiers, 2 =>:image_registration }
+    },
+    standard_cross: {
+      boundary_finder: Sqed::BoundaryFinder::CrossFinder,
+      layout: :cross, 
+      metadata_map: {0 => :labels, 1 => :specimen, 2 => :identifier, 3 => :specimen_determinations }
+    },
+    stage: {
+      boundary_finder: Sqed::BoundaryFinder::StageFinder,
+      layout: :internal_box, 
+      metadata_map: {0 => :stage}
+    }
+    # etc. ...
+  }
+
+  DEFAULT_TMP_DIR = "/tmp"
+
+  def self.index_for_section_type(pattern, section_type)
+    EXTRACTION_PATTERNS[pattern][:metadata_map].invert[section_type]
+  end
+end