qrest 1.0.0

data/lib/qrest/modules.rb

@@ -0,0 +1,300 @@
+#
+#  qrest/modules.rb  --  Modules
+#
+
+require "qrest/base"
+require "qrest/bitstream"
+require "qrest/demerits"
+require "qrest/bch"
+
+
+module QRest
+
+  class Modules
+
+    POSITIONPATTERNLENGTH = (7 + 1) * 2 + 1
+
+    ERRORCORRECTLEVEL = { l: 1, m: 0, q: 3, h: 2 }
+
+    # http://web.archive.org/web/20110710094955/http://www.denso-wave.com/qrcode/vertable1-e.html
+    # http://web.archive.org/web/20110710094955/http://www.denso-wave.com/qrcode/vertable2-e.html
+    # http://web.archive.org/web/20110710094955/http://www.denso-wave.com/qrcode/vertable3-e.html
+    # http://web.archive.org/web/20110710094955/http://www.denso-wave.com/qrcode/vertable4-e.html
+    MAXBITS = {
+      l: [152, 272, 440, 640, 864, 1088, 1248, 1552, 1856, 2192, 2592, 2960, 3424, 3688, 4184, 4712, 5176, 5768, 6360, 6888, 7456, 8048, 8752, 9392, 10_208, 10_960, 11_744, 12_248, 13_048, 13_880, 14_744, 15_640, 16_568, 17_528, 18_448, 19_472, 20_528, 21_616, 22_496, 23_648],
+      m: [128, 224, 352, 512, 688, 864, 992, 1232, 1456, 1728, 2032, 2320, 2672, 2920, 3320, 3624, 4056, 4504, 5016, 5352, 5712, 6256, 6880, 7312, 8000, 8496, 9024, 9544, 10_136, 10_984, 11_640, 12_328, 13_048, 13_800, 14_496, 15_312, 15_936, 16_816, 17_728, 18_672],
+      q: [104, 176, 272, 384, 496, 608, 704, 880, 1056, 1232, 1440, 1648, 1952, 2088, 2360, 2600, 2936, 3176, 3560, 3880, 4096, 4544, 4912, 5312, 5744, 6032, 6464, 6968, 7288, 7880, 8264, 8920, 9368, 9848, 10288, 10832, 11408, 12016, 12656, 13328],
+      h: [72, 128, 208, 288, 368, 480, 528, 688, 800, 976, 1120, 1264, 1440, 1576, 1784, 2024, 2264, 2504, 2728, 3080, 3248, 3536, 3712, 4112, 4304, 4768, 5024, 5288, 5608, 5960, 6344, 6760, 7208, 7688, 7888, 8432, 8768, 9136, 9776, 10_208],
+    }
+
+    MASK_PATTERNS = [
+      proc { |i,j| (i + j) % 2                     },
+      proc { |i,j| i % 2                           },
+      proc { |i,j| j % 3                           },
+      proc { |i,j| (i + j) % 3                     },
+      proc { |i,j| ((i / 2) + (j / 3)) % 2         },
+      proc { |i,j| (i * j) % 2 + (i * j) % 3       },
+      proc { |i,j| ((i * j) % 2 + (i * j) % 3) % 2 },
+      proc { |i,j| ((i * j) % 3 + (i + j) % 2) % 2 },
+    ]
+
+    attr_reader :version, :count, :fields, :demerits
+
+    class <<self
+
+      WEIGHTS = {
+        same_color:  [ 3, 1],
+        full_blocks: 3,
+        dangerous:   40,
+        dark_ratio:  2,
+      }
+
+      def create_best data, version, error_correct_level
+        demerits, pattern = nil, 0
+        MASK_PATTERNS.length.times { |i|
+          test = new data, version, error_correct_level, true, i
+          d = test.demerits.total **WEIGHTS
+          demerits, pattern = d, i if not demerits or demerits > d
+        }
+        new data, version, error_correct_level, false, pattern
+      end
+
+    end
+
+    def initialize data, version, ecl, test, mask_pattern
+      count = version * 4 + POSITIONPATTERNLENGTH
+      @fields = Array.new count do Array.new count end
+      place_position_probe_pattern 0, 0
+      place_position_probe_pattern @fields.size - 7, 0
+      place_position_probe_pattern 0, @fields.size - 7
+      place_position_adjust_pattern version
+      place_timing_pattern
+      place_format_info test, (ERRORCORRECTLEVEL[ecl]<<3) | mask_pattern
+      place_version_info version, test if version >= 7
+      bs = BitStream.new data
+      walk_fields mask_pattern do bs.get end
+      @demerits = Demerits.new @fields if test
+    end
+
+    def inspect
+      d = [
+        "#{self.class}:",
+        (@fields.map { |row| row.map { |x| x.nil? ? "?" : x ? "X" : "." }.join }.join " "),
+      ].join " "
+      "#<#{d}>"
+    end
+
+    def size  ; @fields.size        ; end
+    def range ; @range ||= 0...size ; end
+
+    def check? row, col
+      range === row or raise Error, "Invalid row: #{row}/#{col}"
+      range === col or raise Error, "Invalid column: #{row}/#{col}"
+    end
+
+    def []  row, col      ; check? roq, col ; @fields[ row][col]       ; end
+    def []= row, col, val ; check? row, col ; @fields[ row][col] = val ; end
+
+    def each_row &block
+      @fields.each &block
+    end
+
+    def each_field quiet, start = 0
+      ri = start + quiet
+      each_row { |row|
+        ci = quiet
+        row.each { |field|
+          yield ri, ci if field
+          ci += 1
+        }
+        ri += 1
+      }
+    end
+
+    def each_field_neg quiet, start = 0
+      ri = start - quiet
+      each_row { |row|
+        ci = quiet
+        row.each { |field|
+          yield ri, ci if field
+          ci += 1
+        }
+        ri -= 1
+      }
+    end
+
+    def to_s dark: nil, light: nil, quiet_size: nil
+      r = []
+      lines dark: dark, light: light, quiet_size: quiet_size do |l| r.push l end
+      r.join "\n"
+    end
+
+    def lines dark: nil, light: nil, quiet_size: nil
+      dark  ||= "X"
+      light ||= " "
+      quiet_size ||= 0
+      qr = light * (@fields.size + 2*quiet_size)
+      quiet_size.times do yield qr end
+      qc = light * quiet_size
+      dl = { true => dark, false =>light, nil => "?"}
+      @fields.each do |row|
+        yield "" << qc << (row.map do |col| dl[ col] end.join) << qc
+      end
+      quiet_size.times do yield qr end
+    end
+
+    private
+
+    R08 = 0..8
+    R17 = 1..7
+    R35 = 3..5
+
+    def place_position_probe_pattern row, col
+      R08.each do |i|
+        r = row + i - 1
+        next unless range === r
+        iv = R17 ===             i
+        ih = R17.minmax.include? i
+        R08.each do |j|
+          c = col + j - 1
+          next unless range === c
+          @fields[ r][ c] = (iv && (R17.minmax.include? j)) ||
+                            (ih &&  R17 ===             j ) ||
+                            (R35 === i && R35 === j)
+        end
+      end
+    end
+
+    PATTERN_POSITION_TABLE = [
+      [],
+      [6, 18],
+      [6, 22],
+      [6, 26],
+      [6, 30],
+      [6, 34],
+      [6, 22, 38],
+      [6, 24, 42],
+      [6, 26, 46],
+      [6, 28, 50],
+      [6, 30, 54],
+      [6, 32, 58],
+      [6, 34, 62],
+      [6, 26, 46, 66],
+      [6, 26, 48, 70],
+      [6, 26, 50, 74],
+      [6, 30, 54, 78],
+      [6, 30, 56, 82],
+      [6, 30, 58, 86],
+      [6, 34, 62, 90],
+      [6, 28, 50, 72, 94],
+      [6, 26, 50, 74, 98],
+      [6, 30, 54, 78, 102],
+      [6, 28, 54, 80, 106],
+      [6, 32, 58, 84, 110],
+      [6, 30, 58, 86, 114],
+      [6, 34, 62, 90, 118],
+      [6, 26, 50, 74, 98, 122],
+      [6, 30, 54, 78, 102, 126],
+      [6, 26, 52, 78, 104, 130],
+      [6, 30, 56, 82, 108, 134],
+      [6, 34, 60, 86, 112, 138],
+      [6, 30, 58, 86, 114, 142],
+      [6, 34, 62, 90, 118, 146],
+      [6, 30, 54, 78, 102, 126, 150],
+      [6, 24, 50, 76, 102, 128, 154],
+      [6, 28, 54, 80, 106, 132, 158],
+      [6, 32, 58, 84, 110, 136, 162],
+      [6, 26, 54, 82, 110, 138, 166],
+      [6, 30, 58, 86, 114, 142, 170]
+    ]
+
+    MAX_VERSION = PATTERN_POSITION_TABLE.size
+
+    R_22 = -2..2
+
+    def place_position_adjust_pattern version
+      positions = PATTERN_POSITION_TABLE[ version - 1]
+      rd = R_22.minmax
+      positions.each do |row|
+        positions.each do |col|
+          next unless @fields[ row][ col].nil?
+          R_22.each do |r|
+            pr = row + r
+            R_22.each do |c|
+              pc = col + c
+              @fields[ pr][ pc] = (rd.include? r) || (rd.include? c) || (r == 0 && c == 0)
+            end
+          end
+        end
+      end
+    end
+
+    def place_timing_pattern
+      (8...@fields.size-8).each do |i|
+        @fields[ i][ 6] = @fields[ 6][ i] = i.even?
+      end
+    end
+
+    def place_format_info test, ecl
+      bits = Bch.format_info ecl
+      15.times do |i|
+        mod = !test && bits.odd?
+        r =
+          case i
+          when ...6 then 0
+          when ...8 then 1
+          else           @fields.size - 15
+          end
+        @fields[ r+i][ 8] = mod
+        c =
+          case i
+          when ...8 then @fields.size
+          when ...9 then 16
+          else           15
+          end
+        @fields[ 8][ c - i - 1] = mod
+        bits >>= 1
+      end
+      @fields[ @fields.size - 8][ 8] = !test
+    end
+
+    def place_version_info version, test
+      bits = Bch.version version
+      18.times do |i|
+        id, im = i.divmod 3
+        im += @fields.size - 8 - 3
+        @fields[ id][ im] = @fields[ im][ id] = !test && (bits & 1) == 1
+        bits >>= 1
+      end
+    end
+
+    def walk_fields mask_pattern
+      # An image says more than a thousand statements:
+      # <https://en.wikipedia.org/wiki/QR_code#Message_placement>
+      mp = MASK_PATTERNS[ mask_pattern] or raise ArgumentError, "Bad mask_pattern: #{mask_pattern}"
+      row = c2 = @fields.size - 1
+      inc = -1
+      loop do
+        loop do
+          2.times do |c|
+            col = c2 - c
+            next unless @fields[ row][ col].nil?
+            @fields[ row][ col] = (mp.call row, col).zero? ^ yield
+          end
+          ri = row + inc
+          unless range === ri then
+            inc = -inc
+            break
+          end
+          row = ri
+        end
+        break if c2 == 1
+        c2 -= 2
+        c2 -= 1 if c2 == 6
+      end
+    end
+
+  end
+
+end
+

data/lib/qrest/polynomial.rb

@@ -0,0 +1,136 @@
+#
+#  qrest/polynomial.rb  --  Polynomes
+#
+
+require "qrest/base"
+
+
+module QRest
+
+  class Polynomial
+
+    @ec = {}
+
+    class <<self
+
+      def error_correct error_correct_length
+        @ec[ error_correct_length] ||=
+          if error_correct_length > 0 then
+            e = error_correct_length - 1
+            ge = new [1, 0]
+            ge.gexp! 1, e
+            (error_correct e).multiply ge
+          else
+            new [1]
+          end
+      end
+
+      def zeroes len
+        new [ 0] * len
+      end
+
+    end
+
+    attr_reader :num
+
+    def initialize num
+      num.empty? and raise ArgumentError, "Empty polynomial."
+      @num = num
+    end
+
+    def dup ; Polynomial.new @num.dup ; end
+
+    def [] index ; @num[index] ; end
+    def size ; @num.size ; end
+    alias length size
+
+    def norm!
+      @num.shift while @num.first == 0
+      self
+    end
+
+    def extend! shift
+      shift.times { @num.push 0 }
+    end
+
+    def grow! n
+      @num.unshift 0 until @num.length >= n
+    end
+
+    def first_glog
+      Polynomial.glog @num.first
+    end
+
+    def each_glog
+      @num.each_with_index { |n,i|
+        yield (Polynomial.glog n), i
+      }
+    end
+
+    def gexp! i, n
+      @num[ i] ^= Polynomial.gexp n
+    end
+
+    def multiply e
+      r = Polynomial.zeroes length + e.length - 1
+      each_glog { |gi,i|
+        e.each_glog { |gj,j|
+          r.gexp! i + j, gi + gj
+        }
+      }
+      r
+    end
+
+    def error_mod error_count
+      e = Polynomial.error_correct error_count
+      ef = e.first_glog
+      p = dup
+      p.extend! error_count
+      loop do
+        p.norm!
+        break if p.length < e.length
+        ratio = p.first_glog - ef
+        e.each_glog { |gi,i|
+          p.gexp! i, ratio + gi
+        }
+      end
+      p.grow! error_count
+      p
+    end
+
+
+    EXP_TABLE = []
+    (0...8).each do |i|
+      EXP_TABLE.push 1 << i
+    end
+    (8...256).each do |i|
+      EXP_TABLE.push EXP_TABLE[i-4] ^ EXP_TABLE[i-5] ^ EXP_TABLE[i-6] ^ EXP_TABLE[i-8]
+    end
+
+    LOG_TABLE = [nil] * 256
+    255.times do |i|
+      LOG_TABLE[EXP_TABLE[i]] = i
+    end
+
+    EXP_TABLE.freeze
+    LOG_TABLE.freeze
+
+    class <<self
+
+      def glog n
+        n >= 1 or raise Error, "Internal error: glog(#{n})."
+        LOG_TABLE[n]
+      end
+
+      def gexp n
+        while n <  0   do n += 255 end
+        while n >= 256 do n -= 255 end
+        EXP_TABLE[n]
+      end
+
+    end
+
+  end
+
+end
+

data/lib/qrest/rsblocks.rb

@@ -0,0 +1,143 @@
+#
+#  qrest/rsblocks.rb  --  Reed-Solomon-Code blocks
+#
+
+require "qrest/base"
+require "qrest/bitbuffer"
+require "qrest/polynomial"
+
+
+module QRest
+
+  class RSBlocks
+
+    class Block
+
+      attr_reader :data_count, :total_count
+
+      def initialize total_count, data_count
+        @total_count, @data_count = total_count, data_count
+      end
+
+      def error_count ; total_count - data_count ; end
+
+    end
+
+    def initialize version, bs
+      @version = version
+      @list = bs.map { |num,total,data| [ num, (Block.new total, data)] }
+    end
+
+    def each    ; @list.each { |(n,b)| n.times { yield b } }     ; end
+    def sum sym ; @list.map  { |(n,b)| n * (b.send sym)    }.sum ; end
+    def max sym ; @list.map  { |(_,b)| (b.send sym)        }.max ; end
+
+    def create_data data
+      l = sum :data_count
+      b = BitBuffer.build l do |buf| data.write buf, @version end
+      create_bytes b
+    end
+
+    private
+
+    def create_bytes buffer
+      dcdata, ecdata = [], []
+      i = 0
+      each do |rs|
+        p = Polynomial.new buffer[ i, rs.data_count]
+        i += rs.data_count
+        dcdata.push p.num
+        ecdata.push (p.error_mod rs.error_count).num
+      end
+      data = []
+      (max :data_count).times do |j|
+        dcdata.each do |dc|
+          data.push dc[j] if j < dc.size
+        end
+      end
+      (max :error_count).times do |j|
+        ecdata.each do |ec|
+          data.push ec[j] if j < ec.size
+        end
+      end
+      data.length == (sum :total_count) or
+        raise Error, "Internal error. Please consider a report."
+      data
+    end
+
+    @blocks = Hash.new { |h,k|
+      v = nil
+      RS_BLOCK_TABLE.each_line { |l|
+        n, l = l.split nil, 2
+        if n.to_i == k then
+          v = {}
+          while l =~ /([a-z])\b([ 0-9,]+)/ do
+            n, b, l = $1, $2, $'
+            b.rstrip!
+            v[ n.to_sym] = (b.split /,/).map { |t| t.split.map { |i| i.to_i } }
+          end
+          break
+        end
+      }
+      h[k] = v
+    }
+
+    class <<self
+
+      private :new
+
+      def get version, error_correct_level
+        v = @blocks[version] or raise ArgumentError, "No RS block for version #{version}"
+        new version, v[error_correct_level]
+      end
+
+    end
+
+    # http://www.thonky.com/qr-code-tutorial/error-correction-table/
+    RS_BLOCK_TABLE = <<~EOT
+      1  l  1  26  19,             m  1 26 16,           q  1 26 13,           h  1 26  9,
+      2  l  1  44  34,             m  1 44 28,           q  1 44 22,           h  1 44 16,
+      3  l  1  70  55,             m  1 70 44,           q  2 35 17,           h  2 35 13,
+      4  l  1 100  80,             m  2 50 32,           q  2 50 24,           h  4 25  9,
+      5  l  1 134 108,             m  2 67 43,           q  2 33 15,  2 34 16, h  2 33 11,  2 34 12,
+      6  l  2  86  68,             m  4 43 27,           q  4 43 19,           h  4 43 15,
+      7  l  2  98  78,             m  4 49 31,           q  2 32 14,  4 33 15, h  4 39 13,  1 40 14,
+      8  l  2 121  97,             m  2 60 38,  2 61 39, q  4 40 18,  2 41 19, h  4 40 14,  2 41 15,
+      9  l  2 146 116,             m  3 58 36,  2 59 37, q  4 36 16,  4 37 17, h  4 36 12,  4 37 13,
+      10 l  2  86  68,  2  87  69, m  4 69 43,  1 70 44, q  6 43 19,  2 44 20, h  6 43 15,  2 44 16,
+      11 l  4 101  81,             m  1 80 50,  4 81 51, q  4 50 22,  4 51 23, h  3 36 12,  8 37 13,
+      12 l  2 116  92,  2 117  93, m  6 58 36,  2 59 37, q  4 46 20,  6 47 21, h  7 42 14,  4 43 15,
+      13 l  4 133 107,             m  8 59 37,  1 60 38, q  8 44 20,  4 45 21, h 12 33 11,  4 34 12,
+      14 l  3 145 115,  1 146 116, m  4 64 40,  5 65 41, q 11 36 16,  5 37 17, h 11 36 12,  5 37 13,
+      15 l  5 109  87,  1 110  88, m  5 65 41,  5 66 42, q  5 54 24,  7 55 25, h 11 36 12,  7 37 13,
+      16 l  5 122  98,  1 123  99, m  7 73 45,  3 74 46, q 15 43 19,  2 44 20, h  3 45 15, 13 46 16,
+      17 l  1 135 107,  5 136 108, m 10 74 46,  1 75 47, q  1 50 22, 15 51 23, h  2 42 14, 17 43 15,
+      18 l  5 150 120,  1 151 121, m  9 69 43,  4 70 44, q 17 50 22,  1 51 23, h  2 42 14, 19 43 15,
+      19 l  3 141 113,  4 142 114, m  3 70 44, 11 71 45, q 17 47 21,  4 48 22, h  9 39 13, 16 40 14,
+      20 l  3 135 107,  5 136 108, m  3 67 41, 13 68 42, q 15 54 24,  5 55 25, h 15 43 15, 10 44 16,
+      21 l  4 144 116,  4 145 117, m 17 68 42,           q 17 50 22,  6 51 23, h 19 46 16,  6 47 17,
+      22 l  2 139 111,  7 140 112, m 17 74 46,           q  7 54 24, 16 55 25, h 34 37 13,
+      23 l  4 151 121,  5 152 122, m  4 75 47, 14 76 48, q 11 54 24, 14 55 25, h 16 45 15, 14 46 16,
+      24 l  6 147 117,  4 148 118, m  6 73 45, 14 74 46, q 11 54 24, 16 55 25, h 30 46 16,  2 47 17,
+      25 l  8 132 106,  4 133 107, m  8 75 47, 13 76 48, q  7 54 24, 22 55 25, h 22 45 15, 13 46 16,
+      26 l 10 142 114,  2 143 115, m 19 74 46,  4 75 47, q 28 50 22,  6 51 23, h 33 46 16,  4 47 17,
+      27 l  8 152 122,  4 153 123, m 22 73 45,  3 74 46, q  8 53 23, 26 54 24, h 12 45 15, 28 46 16,
+      28 l  3 147 117, 10 148 118, m  3 73 45, 23 74 46, q  4 54 24, 31 55 25, h 11 45 15, 31 46 16,
+      29 l  7 146 116,  7 147 117, m 21 73 45,  7 74 46, q  1 53 23, 37 54 24, h 19 45 15, 26 46 16,
+      30 l  5 145 115, 10 146 116, m 19 75 47, 10 76 48, q 15 54 24, 25 55 25, h 23 45 15, 25 46 16,
+      31 l 13 145 115,  3 146 116, m  2 74 46, 29 75 47, q 42 54 24,  1 55 25, h 23 45 15, 28 46 16,
+      32 l 17 145 115,             m 10 74 46, 23 75 47, q 10 54 24, 35 55 25, h 19 45 15, 35 46 16,
+      33 l 17 145 115,  1 146 116, m 14 74 46, 21 75 47, q 29 54 24, 19 55 25, h 11 45 15, 46 46 16,
+      34 l 13 145 115,  6 146 116, m 14 74 46, 23 75 47, q 44 54 24,  7 55 25, h 59 46 16,  1 47 17,
+      35 l 12 151 121,  7 152 122, m 12 75 47, 26 76 48, q 39 54 24, 14 55 25, h 22 45 15, 41 46 16,
+      36 l  6 151 121, 14 152 122, m  6 75 47, 34 76 48, q 46 54 24, 10 55 25, h  2 45 15, 64 46 16,
+      37 l 17 152 122,  4 153 123, m 29 74 46, 14 75 47, q 49 54 24, 10 55 25, h 24 45 15, 46 46 16,
+      38 l  4 152 122, 18 153 123, m 13 74 46, 32 75 47, q 48 54 24, 14 55 25, h 42 45 15, 32 46 16,
+      39 l 20 147 117,  4 148 118, m 40 75 47,  7 76 48, q 43 54 24, 22 55 25, h 10 45 15, 67 46 16,
+      40 l 19 148 118,  6 149 119, m 18 75 47, 31 76 48, q 34 54 24, 34 55 25, h 20 45 15, 61 46 16,
+    EOT
+
+  end
+
+end
+