barby-chunky_png 0.3.3

data/lib/barby/barcode/code_93.rb

@@ -0,0 +1,230 @@
+require 'barby/barcode'
+
+module Barby
+
+  class Code93 < Barcode1D
+
+    SHIFT_DOLLAR  = "\301" # ($)
+    SHIFT_PERCENT = "\302" # (%)
+    SHIFT_SLASH   = "\303" # (/)
+    SHIFT_PLUS    = "\304" # (+)
+
+    SHIFT_CHARACTERS = [SHIFT_DOLLAR, SHIFT_PERCENT, SHIFT_SLASH, SHIFT_PLUS]
+
+    ENCODINGS = {
+      "0" => "100010100", "1" => "101001000",
+      "2" => "101000100", "3" => "101000010",
+      "4" => "100101000", "5" => "100100100",
+      "6" => "100100010", "7" => "101010000",
+      "8" => "100010010", "9" => "100001010",
+      "A" => "110101000", "B" => "110100100",
+      "C" => "110100010", "D" => "110010100",
+      "E" => "110010010", "F" => "110001010",
+      "G" => "101101000", "H" => "101100100",
+      "I" => "101100010", "J" => "100110100",
+      "K" => "100011010", "L" => "101011000",
+      "M" => "101001100", "N" => "101000110",
+      "O" => "100101100", "P" => "100010110",
+      "Q" => "110110100", "R" => "110110010",
+      "S" => "110101100", "T" => "110100110",
+      "U" => "110010110", "V" => "110011010",
+      "W" => "101101100", "X" => "101100110",
+      "Y" => "100110110", "Z" => "100111010",
+      "-" => "100101110", "." => "111010100",
+      " " => "111010010", "$" => "111001010",
+      "/" => "101101110", "+" => "101110110",
+      "%" => "110101110",
+      SHIFT_DOLLAR  => "100100110",
+      SHIFT_PERCENT => "111011010",
+      SHIFT_SLASH   => "111010110",
+      SHIFT_PLUS    => "100110010"
+    }
+
+    EXTENDED_MAPPING = {
+      "\000" => "\302U",    " "    => " ",        "@"  => "\302V", "`"    =>    "\302W",
+      "\001" => "\301A",    "!"    => "\303A",    "A"  => "A",     "a"    =>    "\304A",
+      "\002" => "\301B",    '"'    => "\303B",    "B"  => "B",     "b"    =>    "\304B",
+      "\003" => "\301C",    "#"    => "\303C",    "C"  => "C",     "c"    =>    "\304C",
+      "\004" => "\301D",    "$"    => "\303D",    "D"  => "D",     "d"    =>    "\304D",
+      "\005" => "\301E",    "%"    => "\303E",    "E"  => "E",     "e"    =>    "\304E",
+      "\006" => "\301F",    "&"    => "\303F",    "F"  => "F",     "f"    =>    "\304F",
+      "\007" => "\301G",    "'"    => "\303G",    "G"  => "G",     "g"    =>    "\304G",
+      "\010" => "\301H",    "("    => "\303H",    "H"  => "H",     "h"    =>    "\304H",
+      "\011" => "\301I",    ")"    => "\303I",    "I"  => "I",     "i"    =>    "\304I",
+      "\012" => "\301J",    "*"    => "\303J",    "J"  => "J",     "j"    =>    "\304J",
+      "\013" => "\301K",    "/"    => "\303K",    "K"  => "K",     "k"    =>    "\304K",
+      "\014" => "\301L",    ","    => "\303L",    "L"  => "L",     "l"    =>    "\304L",
+      "\015" => "\301M",    "-"    => "-",        "M"  => "M",     "m"    =>    "\304M",
+      "\016" => "\301N",    "."    => ".",        "N"  => "N",     "n"    =>    "\304N",
+      "\017" => "\301O",    "+"    => "\303O",    "O"  => "O",     "o"    =>    "\304O",
+      "\020" => "\301P",    "0"    => "0",        "P"  => "P",     "p"    =>    "\304P",
+      "\021" => "\301Q",    "1"    => "1",        "Q"  => "Q",     "q"    =>    "\304Q",
+      "\022" => "\301R",    "2"    => "2",        "R"  => "R",     "r"    =>    "\304R",
+      "\023" => "\301S",    "3"    => "3",        "S"  => "S",     "s"    =>    "\304S",
+      "\024" => "\301T",    "4"    => "4",        "T"  => "T",     "t"    =>    "\304T",
+      "\025" => "\301U",    "5"    => "5",        "U"  => "U",     "u"    =>    "\304U",
+      "\026" => "\301V",    "6"    => "6",        "V"  => "V",     "v"    =>    "\304V",
+      "\027" => "\301W",    "7"    => "7",        "W"  => "W",     "w"    =>    "\304W",
+      "\030" => "\301X",    "8"    => "8",        "X"  => "X",     "x"    =>    "\304X",
+      "\031" => "\301Y",    "9"    => "9",        "Y"  => "Y",     "y"    =>    "\304Y",
+      "\032" => "\301Z",    ":"    => "\303Z",    "Z"  => "Z",     "z"    =>    "\304Z",
+      "\033" => "\302A",    ";"    => "\302F",    "["  => "\302K", "{"    =>    "\302P",
+      "\034" => "\302B",    "<"    => "\302G",    "\\" => "\302L", "|"    =>    "\302Q",
+      "\035" => "\302C",    "="    => "\302H",    "]"  => "\302M", "}"    =>    "\302R",
+      "\036" => "\302D",    ">"    => "\302I",    "^"  => "\302N", "~"    =>    "\302S",
+      "\037" => "\302E",    "?"    => "\302J",    "_"  => "\302O", "\177" =>    "\302T"
+    }
+
+    EXTENDED_CHARACTERS = EXTENDED_MAPPING.keys - ENCODINGS.keys
+
+    CHARACTERS = {
+      0  => "0",  1 => "1", 2  => "2", 3  => "3",
+      4  => "4",  5 => "5", 6  => "6", 7  => "7",
+      8  => "8",  9 => "9", 10 => "A", 11 => "B",
+      12 => "C", 13 => "D", 14 => "E", 15 => "F",
+      16 => "G", 17 => "H", 18 => "I", 19 => "J",
+      20 => "K", 21 => "L", 22 => "M", 23 => "N",
+      24 => "O", 25 => "P", 26 => "Q", 27 => "R",
+      28 => "S", 29 => "T", 30 => "U", 31 => "V",
+      32 => "W", 33 => "X", 34 => "Y", 35 => "Z",
+      36 => "-", 37 => ".", 38 => " ", 39 => "$",
+      40 => "/", 41 => "+", 42 => "%",
+      43 => SHIFT_DOLLAR, 44 => SHIFT_PERCENT,
+      45 => SHIFT_SLASH,  46 => SHIFT_PLUS
+    }
+    
+    VALUES = CHARACTERS.invert
+
+    START_ENCODING     = '101011110' # *
+    STOP_ENCODING      = '101011110'
+    TERMINATE_ENCODING = '1'
+
+    attr_accessor :data
+
+
+    def initialize(data)
+      self.data = data
+    end
+
+
+    def extended?
+      raw_characters.any?{|c| EXTENDED_CHARACTERS.include?(c) }
+    end
+
+
+    def raw_characters
+      data.split(//)
+    end
+
+    def characters
+      raw_characters.map{|c| EXTENDED_MAPPING[c].split(//) }.flatten
+    end
+
+    def encoded_characters
+      characters.map{|c| ENCODINGS[c] }
+    end
+    alias character_encodings encoded_characters
+
+
+    def start_encoding
+      START_ENCODING
+    end
+
+    #The stop encoding includes the termination bar
+    def stop_encoding
+      STOP_ENCODING+TERMINATE_ENCODING
+    end
+
+
+    def encoding
+      start_encoding+data_encoding_with_checksums+stop_encoding
+    end
+
+    def data_encoding
+      character_encodings.join
+    end
+
+    def data_encoding_with_checksums
+      (character_encodings + checksum_encodings).join
+    end
+
+    def checksum_encodings
+      checksum_characters.map{|c| ENCODINGS[c] }
+    end
+
+    def checksum_encoding
+      checksum_encodings.join
+    end
+
+
+    def checksums
+      [c_checksum, k_checksum]
+    end
+
+    def checksum_characters
+      checksums.map{|s| CHARACTERS[s] }
+    end
+
+
+    #Returns the values used for computing the C checksum
+    #in the "right" order (i.e. reversed)
+    def checksum_values
+      characters.map{|c| VALUES[c] }.reverse
+    end
+
+    #Returns the normal checksum plus the c_checksum
+    #This is used for calculating the k_checksum
+    def checksum_values_with_c_checksum
+      [c_checksum] + checksum_values
+    end
+
+
+    #Calculates the C checksum based on checksum_values
+    def c_checksum
+      sum = 0
+      checksum_values.each_with_index do |value, index|
+        sum += ((index % 20) + 1) * value
+      end
+      sum % 47
+    end
+
+    def c_checksum_character
+      CHARACTERS[c_checksum]
+    end
+
+    def c_checksum_encoding
+      ENCODINGS[c_checksum_character]
+    end
+
+
+    #Calculates the K checksum based on checksum_values_with_c_checksum
+    def k_checksum
+      sum = 0
+      checksum_values_with_c_checksum.each_with_index do |value, index|
+        sum += ((index % 15) + 1) * value
+      end
+      sum % 47
+    end
+
+    def k_checksum_character
+      CHARACTERS[k_checksum]
+    end
+
+    def k_checksum_encoding
+      ENCODINGS[k_checksum_character]
+    end
+
+
+    def valid?
+      characters.all?{|c| ENCODINGS.include?(c) }
+    end
+
+
+    def to_s
+      data
+    end
+
+
+  end
+
+end

data/lib/barby/barcode/data_matrix.rb

@@ -0,0 +1,46 @@
+require 'semacode'
+require 'barby/barcode'
+
+module Barby
+
+
+  #Uses the semacode library (gem install semacode) to encode DataMatrix barcodes
+  class DataMatrix < Barcode2D
+
+    attr_accessor :data
+
+
+    def initialize(data)
+      self.data = data
+    end
+
+
+    def data=(data)
+      @data = data
+      @encoder = nil
+    end
+
+    def encoder
+      @encoder ||= ::DataMatrix::Encoder.new(data)
+    end
+
+
+    def encoding
+      encoder.data.map{|a| a.map{|b| b ? '1' : '0' }.join }
+    end
+
+
+    def semacode?
+      #TODO: Not sure if this is right
+      data =~ /^http:\/\//
+    end
+
+
+    def to_s
+      data
+    end
+
+
+  end
+
+end

data/lib/barby/barcode/ean_13.rb

@@ -0,0 +1,178 @@
+require 'barby/barcode'
+
+module Barby
+
+  #EAN-13, aka UPC-A, barcodes are the ones you can see at your local
+  #supermarket, in your house and, well, everywhere..
+  #
+  #To use this for a UPC barcode, just add a 0 to the front
+  class EAN13 < Barcode1D
+
+    LEFT_ENCODINGS_ODD = {
+      0 => '0001101', 1 => '0011001', 2 => '0010011',
+      3 => '0111101', 4 => '0100011', 5 => '0110001',
+      6 => '0101111', 7 => '0111011', 8 => '0110111',
+      9 => '0001011'
+    }
+
+    LEFT_ENCODINGS_EVEN = {
+      0 => '0100111', 1 => '0110011', 2 => '0011011',
+      3 => '0100001', 4 => '0011101', 5 => '0111001',
+      6 => '0000101', 7 => '0010001', 8 => '0001001',
+      9 => '0010111'
+    }
+
+    RIGHT_ENCODINGS = {
+      0 => '1110010', 1 => '1100110', 2 => '1101100',
+      3 => '1000010', 4 => '1011100', 5 => '1001110',
+      6 => '1010000', 7 => '1000100', 8 => '1001000',
+      9 => '1110100'
+    }
+
+    #Describes whether the left-hand encoding should use
+    #LEFT_ENCODINGS_ODD or LEFT_ENCODINGS_EVEN, based on the
+    #first digit in the number system  (and the barcode as a whole)
+    LEFT_PARITY_MAPS = {
+      0 => [:odd, :odd, :odd, :odd, :odd, :odd],   #UPC-A
+      1 => [:odd, :odd, :even, :odd, :even, :even],
+      2 => [:odd, :odd, :even, :even, :odd, :even],
+      3 => [:odd, :odd, :even, :even, :even, :odd],
+      4 => [:odd, :even, :odd, :odd, :even, :even],
+      5 => [:odd, :even, :even, :odd, :odd, :even],
+      6 => [:odd, :even, :even, :even, :odd, :odd],
+      7 => [:odd, :even, :odd, :even, :odd, :even],
+      8 => [:odd, :even, :odd, :even, :even, :odd],
+      9 => [:odd, :even, :even, :odd, :even, :odd]
+    }
+
+    #These are the lines that "stick down" in the graphical representation
+    START = '101'
+    CENTER = '01010'
+    STOP = '101'
+
+    #EAN-13 barcodes have 12 digits + check digit
+    FORMAT = /^\d{12}$/
+
+    attr_accessor :data
+
+
+    def initialize(data)
+      self.data = data
+      raise ArgumentError, 'data not valid' unless valid?
+    end
+
+
+    def characters
+      data.split(//)
+    end
+    
+    def numbers
+      characters.map{|s| s.to_i }
+    end
+
+    def odd_and_even_numbers
+      alternater = false
+      numbers.reverse.partition{ alternater = !alternater }
+    end
+
+    #Numbers that are encoded to the left of the center
+    #The first digit is not included
+    def left_numbers
+      numbers[1,6]
+    end
+
+    #Numbers that are encoded to the right of the center
+    #The checksum is included here
+    def right_numbers
+      numbers_with_checksum[7,6]
+    end
+
+    def numbers_with_checksum
+      numbers + [checksum]
+    end
+
+
+    def data_with_checksum
+      data + checksum.to_s
+    end
+
+
+    def left_encodings
+      left_parity_map.zip(left_numbers).map do |parity,number|
+        parity == :odd ? LEFT_ENCODINGS_ODD[number] : LEFT_ENCODINGS_EVEN[number]
+      end
+    end
+
+    def right_encodings
+      right_numbers.map{|n| RIGHT_ENCODINGS[n] }
+    end
+
+    def left_encoding
+      left_encodings.join
+    end
+
+    def right_encoding
+      right_encodings.join
+    end
+
+    def encoding
+      start_encoding+left_encoding+center_encoding+right_encoding+stop_encoding
+    end
+
+
+    #The parities to use for encoding left-hand numbers
+    def left_parity_map
+      LEFT_PARITY_MAPS[numbers.first]
+    end
+
+
+    def weighted_sum
+      odds, evens = odd_and_even_numbers
+      odds.map!{|n| n * 3 }
+      sum = (odds+evens).inject(0){|s,n| s+n }
+    end
+
+    #Mod10
+    def checksum
+      mod = weighted_sum % 10
+      mod.zero? ? 0 : 10-mod
+    end
+
+    def checksum_encoding
+      RIGHT_ENCODINGS[checksum]
+    end
+
+
+    def valid?
+      data =~ FORMAT
+    end
+
+
+    def to_s
+      data_with_checksum
+    end
+
+
+    #Is this a UPC-A barcode?
+    #UPC barcodes are EAN codes that start with 0
+    def upc?
+      numbers.first.zero?
+    end
+
+
+    def start_encoding
+      START
+    end
+
+    def center_encoding
+      CENTER
+    end
+
+    def stop_encoding
+      STOP
+    end
+
+
+  end
+
+end

data/lib/barby/barcode/ean_8.rb

@@ -0,0 +1,32 @@
+require 'barby/barcode/ean_13'
+
+module Barby
+
+  #EAN-8 is a sub-set of EAN-13, with only 7 (8) digits
+  class EAN8 < EAN13
+
+    FORMAT = /^\d{7}$/
+
+
+    def left_numbers
+      numbers[0,4]
+    end
+
+    def right_numbers
+      numbers_with_checksum[4,4]
+    end
+
+
+    #Left-hand digits are all encoded using odd parity
+    def left_parity_map
+      [:odd, :odd, :odd, :odd]
+    end
+
+
+    def valid?
+      data =~ FORMAT
+    end
+
+  end
+
+end

data/lib/barby/barcode/gs1_128.rb

@@ -0,0 +1,42 @@
+require 'barby/barcode/code_128'
+
+module Barby
+
+
+  #AKA EAN-128, UCC-128
+  class GS1128 < Code128
+
+    attr_accessor :application_identifier
+
+    def initialize(data, type, ai)
+      self.application_identifier = ai
+      super(data, type)
+    end
+
+
+    #TODO: Not sure this is entirely right
+    def data
+      FNC1+application_identifier+super
+    end
+
+    def partial_data
+      @data
+    end
+
+    def application_identifier_number
+      values[application_identifier]
+    end
+
+    def application_identifier_encoding
+      encodings[application_identifier_number]
+    end
+
+    def to_s
+      "(#{application_identifier}) #{partial_data}"
+    end
+
+
+  end
+
+
+end

data/lib/barby/barcode/pdf_417.rb

@@ -0,0 +1,76 @@
+require 'barby/barcode'
+require 'java'
+require 'Pdf417lib'
+import 'Pdf417lib'
+
+module Barby
+  class Pdf417 < Barcode2D
+    DEFAULT_OPTIONS = {
+      :options       => 0,
+      :y_height      => 3,
+      :aspect_ratio  => 0.5, 
+      :error_level   => 0,
+      :len_codewords => 0,
+      :code_rows     => 0,
+      :code_columns  => 0
+    }
+
+    # Creates a new Pdf417 barcode. The +options+ argument
+    # can use the same keys as DEFAULT_OPTIONS. Please consult
+    # the source code of Pdf417lib.java for details about values
+    # that can be used.
+    def initialize(data, options={})
+      @pdf417 = Java::Pdf417lib.new
+      self.data = data
+      DEFAULT_OPTIONS.merge(options).each{|k,v| send("#{k}=", v) }
+    end
+
+    def options=(options)
+      @options = options
+    end
+
+    def y_height=(y_height)
+      @pdf417.setYHeight(y_height)
+    end
+
+    def aspect_ratio=(aspect_ratio)
+      @pdf417.setAspectRatio(aspect_ratio)
+    end
+
+    def error_level=(error_level)
+      @pdf417.setErrorLevel(error_level)
+    end
+
+    def len_codewords=(len_codewords)
+      @pdf417.setLenCodewords(len_codewords)
+    end
+
+    def code_rows=(code_rows)
+      @pdf417.setCodeRows(code_rows)
+    end
+
+    def code_columns=(code_columns)
+      @pdf417.setCodeColumns(code_columns)
+    end
+
+    def data=(data)
+      @pdf417.setText(data)
+    end
+
+    def encoding
+      @pdf417.paintCode()
+
+      cols = (@pdf417.getBitColumns() - 1) / 8 + 1
+      enc = []
+      row = nil
+      @pdf417.getOutBits.each_with_index do |byte, n|
+        if n%cols == 0
+          row = ""
+          enc << row
+        end
+        row << sprintf("%08b", (byte & 0xff) | 0x100)
+      end
+      enc
+    end
+  end
+end