qrio 0.0.1

data/lib/qrio/region.rb

@@ -0,0 +1,113 @@
+module Qrio
+  # a rectangular matrix of bits
+  class Region
+    attr_reader :x1, :y1, :x2, :y2, :orientation
+
+    def initialize(x1, y1, x2, y2)
+      @x1 = x1
+      @y1 = y1
+      @x2 = x2
+      @y2 = y2
+
+      set_orientation
+    end
+
+    def left;   x1; end
+    def right;  x2; end
+    def top;    y1; end
+    def bottom; y2; end
+
+    def top_left
+      [x1, y1]
+    end
+
+    def bottom_right
+      [x2, y2]
+    end
+
+    def to_coordinates
+      [top_left, bottom_right].flatten
+    end
+
+    def to_point_size
+      [top_left, width, height].flatten
+    end
+
+    def to_s
+      "R[#{ to_coordinates.join(',') }]"
+    end
+
+    def hash
+      to_s.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def width
+      x2 - x1 + 1
+    end
+
+    def height
+      y2 - y1 + 1
+    end
+
+    def center
+      [left + width / 2, top + height / 2]
+    end
+
+    def horizontal?; orientation == :horizontal; end
+    def vertical?;   orientation == :vertical;   end
+
+    def orientation_matches?(other)
+      orientation == other.orientation
+    end
+
+    def union(other)
+      self.class.new(
+        [left,   other.left].min,
+        [top,    other.top].min,
+        [right,  other.right].max,
+        [bottom, other.bottom].max
+      )
+    end
+
+    def translate(xoffset, yoffset)
+      self.class.new(
+        left   - xoffset,
+        top    - yoffset,
+        right  - xoffset,
+        bottom - yoffset
+      )
+    end
+
+    # return a new region that would be the result of rotating
+    # a matrix of width x height containing this region
+    def rotate(mw, mh)
+      self.class.new(
+        mh - bottom - 1,
+        left,
+        mh - top - 1,
+        right
+      )
+    end
+
+    private
+
+    def set_orientation
+      @orientation = case
+      when width > height
+        :horizontal
+      when height > width
+        :vertical
+      else
+        :square
+      end
+    end
+  end
+end

data/lib/qrio/sampling_grid.rb

@@ -0,0 +1,152 @@
+module Qrio
+  class SamplingGrid
+    attr_reader :origin_corner, :top_right, :bottom_left,
+                :orientation, :bounds, :angles,
+                :block_width, :block_height, :provisional_version,
+                :finder_patterns, :matrix
+
+    def initialize(matrix, finder_patterns)
+      @matrix          = matrix
+      @finder_patterns = finder_patterns
+      @angles          = []
+
+      find_origin_corner
+      detect_orientation
+    end
+
+    def find_origin_corner(normalized=false)
+      build_finder_pattern_neighbors
+
+      shared_corners = @finder_patterns.select do |fp|
+        fp.neighbors.select(&:right_angle?).count > 1
+      end
+
+      # TODO : handle multiple possible matches
+      if @origin_corner = shared_corners.first
+        if normalized
+          # we have correct orientation, identify fp positions
+          @top_right = non_origin_finder_patterns.map(&:destination).detect{|fp| fp.center.last < @matrix.height / 2.0 }
+          @bottom_left = non_origin_finder_patterns.map(&:destination).detect{|fp| fp.center.first < @matrix.width / 2.0 }
+        else
+          set_bounds
+        end
+      end
+    end
+
+    def set_bounds
+      @bounds = @origin_corner.dup
+      @bounds.neighbors.select(&:right_angle?).each do |n|
+        @bounds = @bounds.union(n.destination)
+      end
+    end
+
+    # which way is the QR rotated?
+    #   0) normal - shared finder patterns in top left
+    #   1)        - shared finder patterns in top right
+    #   2)        - shared finder patterns in bottom right
+    #   3)        - shared finder patterns in bottom left
+    def detect_orientation
+      # TODO : handle multiple possible matches
+      other_corners = non_origin_finder_patterns
+
+      dc = other_corners.map(&:distance).inject(0){|s,d| s + d } / 2.0
+      threshold = dc / 2.0
+
+      other_corners = other_corners.map(&:destination)
+
+      set_block_dimensions(@origin_corner, *other_corners)
+      @provisional_version = ((dc / @block_width).round - 10) / 4
+
+      xs = other_corners.map{|fp| fp.center.first }
+      ys = other_corners.map{|fp| fp.center.last }
+
+      above = ys.select{|y| y < (@origin_corner.center.last - threshold) }
+      left  = xs.select{|x| x < (@origin_corner.center.first - threshold) }
+
+      @orientation = if above.any?
+        left.any? ? 2 : 3
+      else
+        left.any? ? 1 : 0
+      end
+    end
+
+    def non_origin_finder_patterns
+      @origin_corner.neighbors.select(&:right_angle?)[0,2]
+    end
+
+    def build_finder_pattern_neighbors
+      @finder_patterns.each do |source|
+        @finder_patterns.each do |destination|
+          next if source.center == destination.center
+          @angles << Neighbor.new(source, destination)
+        end
+      end
+    end
+
+    def set_block_dimensions(*finder_patterns)
+      @block_width  = finder_patterns.inject(0){|s,f| s + f.width } / 21.0
+      @block_height = finder_patterns.inject(0){|s,f| s + f.height } / 21.0
+    end
+
+    def logical_width
+      @matrix.width / @block_width
+    end
+
+    def logical_height
+      @matrix.height / @block_height
+    end
+
+    def normalize
+      @matrix = @matrix.extract(*@bounds.to_point_size)
+      translate(*@bounds.top_left)
+
+      if @orientation > 0
+        (4 - @orientation).times do
+          rotate
+        end
+      end
+
+      find_origin_corner(true)
+    end
+
+    def translate(x, y)
+      @angles = []
+      other_corners = non_origin_finder_patterns.map(&:destination)
+
+      @origin_corner = @origin_corner.translate(x, y)
+      translated = [@origin_corner]
+      translated += other_corners.map{|c| c.translate(x, y) }
+
+      @finder_patterns = translated
+    end
+
+    def rotate
+      @matrix = @matrix.rotate
+      @finder_patterns.map!{|f| f.rotate(@bounds.width, @bounds.height) }
+    end
+
+    def extracted_pixels
+      start_x = @origin_corner.center.first - (@block_width  * 3.0)
+      start_y = @origin_corner.center.last  - (@block_height * 3.0)
+
+      dest_x = @bottom_left.center.first - (@block_width * 3.0)
+      dest_y = @top_right.center.last  - (@block_height * 3.0)
+
+      # TODO : take bottom right alignment pattern into consideration
+      dy = (dest_y - start_y) / logical_width
+      dx = (dest_x - start_x) / logical_height
+
+      logical_height.round.times do |row_index|
+        row_start_x = start_x + row_index * dx
+        row_start_y = start_y + (row_index * @block_height)
+
+        logical_width.round.times do |col_index|
+          x = row_start_x + (col_index * @block_width)
+          y = row_start_y + (col_index * dy)
+
+          yield x.round, y.round
+        end
+      end
+    end
+  end
+end

data/lib/qrio/version.rb

@@ -0,0 +1,3 @@
+module Qrio
+  VERSION = "0.0.1"
+end

data/lib/qrio/vertical_match.rb

@@ -0,0 +1,31 @@
+module Qrio
+  class VerticalMatch < FinderPatternSlice
+    def self.build(offset, origin, terminus)
+      new(offset, origin, offset, terminus)
+    end
+
+    def offset;   left;   end
+    def origin;   top;    end
+    def terminus; bottom; end
+
+    def length
+      height
+    end
+
+    def breadth
+      width
+    end
+
+    def left_of?(other)
+      right < other.left
+    end
+
+    def right_of?(other)
+      left > other.right
+    end
+
+    def offset_diff(other)
+      left_of?(other) ? other.left - right : left - other.right
+    end
+  end
+end

data/qrio.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "qrio/version"
+
+Gem::Specification.new do |s|
+  s.name        = "qrio"
+  s.version     = Qrio::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Solomon White"]
+  s.email       = ["rubysolo@gmail.com"]
+  s.homepage    = "http://github.com/rubysolo/qrio"
+  s.licenses    = %w(MIT)
+  s.summary     = %q(QR code decoder)
+  s.description = %q(QR code decoder in pure Ruby)
+
+  s.add_runtime_dependency "chunky_png"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end
+

data/test/finder_pattern_slice_test.rb

@@ -0,0 +1,121 @@
+require_relative '../lib/qrio'
+require 'test/unit'
+
+class TestFinderPatternSlice < Test::Unit::TestCase
+  def test_ratio_matching
+    [
+      [ 1, 1, 3, 1, 1],
+      [10,10,30,10,10],
+      [11, 9,28,10,12],
+      [ 8, 8,19, 9, 8],
+      [11,12,34,13,12],
+      [12,20,46,19,14],
+      [10,13,32,14, 8],
+      [10,12,34,13, 7],
+      [11,13,32,14, 8],
+    ].each{|b| assert_matches_ratio b }
+
+    (9..12).to_a.each do |a|
+      (11..13).to_a.each do |b|
+        (31..34).to_a.each do |c|
+          (13..15).to_a.each do |d|
+            (7..9).to_a.each do |e|
+              assert_matches_ratio [a, b, c, d, e]
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_intersection_detection
+   slice1 = Qrio::HorizontalMatch.build(27, 16, 62)
+   slice1 = slice1.union Qrio::HorizontalMatch.build(45, 16, 62)
+
+   slice2 = Qrio::VerticalMatch.build(27, 16, 62)
+   slice2 = slice2.union Qrio::VerticalMatch.build(44, 16, 62)
+
+   assert slice1.length_matches?(slice2)
+   assert slice1.breadth_matches?(slice2)
+   assert slice1.intersects? slice2
+
+   slice1 = Qrio::HorizontalMatch.build(21, 5, 57)
+   slice1 = slice1.union Qrio::HorizontalMatch.build(35, 5, 57)
+
+   slice2 = Qrio::VerticalMatch.build(22, 3, 54)
+   slice2 = slice2.union Qrio::VerticalMatch.build(38, 3, 54)
+
+   assert slice1.intersects? slice2
+  end
+
+=begin
+  def test_slice_ratio
+    correct = [
+      [16, 27, 62, 45],
+      [27, 16, 44, 62],
+      [10, 27, 62, 45],
+      [27, 10, 44, 62],
+      [ 5, 21, 57, 35]
+    ].map{|a| @s.new(*a) }
+
+    correct.each do |slice|
+      assert slice.has_correct_ratio?, slice.ratio
+    end
+
+    incorrect = [
+      [16, 27, 62, 28],
+      [27, 16, 30, 62],
+    ].map{|a| @s.new(*a) }
+
+    incorrect.each do |slice|
+      assert ! slice.has_correct_ratio?, slice.ratio
+    end
+  end
+=end
+
+  def test_slice_builder
+    slice = Qrio::FinderPatternSlice.build_matching(
+      10, 5,
+      [1, 1, 3, 1, 1],
+      :horizontal
+    )
+
+    assert slice.is_a?(Qrio::HorizontalMatch)
+    assert_equal 10, slice.offset
+    assert_equal 5, slice.origin
+    assert_equal 11, slice.terminus
+    assert_equal 5, slice.left
+    assert_equal 11, slice.right
+    assert_equal 10, slice.top
+    assert_equal 10, slice.bottom
+    assert_equal 1, slice.height
+    assert_equal 7, slice.width
+
+    slice = Qrio::FinderPatternSlice.build_matching(
+      23, 15,
+      [1, 1, 3, 1, 1],
+      :vertical
+    )
+
+    assert slice.is_a?(Qrio::VerticalMatch)
+    assert_equal 23, slice.offset
+    assert_equal 15, slice.origin
+    assert_equal 21, slice.terminus
+    assert_equal 23, slice.left
+    assert_equal 23, slice.right
+    assert_equal 15, slice.top
+    assert_equal 21, slice.bottom
+    assert_equal 7, slice.height
+    assert_equal 1, slice.width
+  end
+
+  private
+
+  def assert_matches_ratio(widths)
+    norm = Qrio::FinderPatternSlice.normalized_ratio(widths)
+    norm = norm.map{|n| '%.2f' % n }
+    msg  = "Expected #{ widths.join('|') } [#{ norm.join('|') }]"
+    msg << " to match finder pattern ratio"
+    assert Qrio::FinderPatternSlice.matches_ratio?(widths), msg
+  end
+end