barcode1dtools 0.9.2

data/lib/barcode1dtools/upc_a.rb

@@ -0,0 +1,143 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'barcode1dtools/ean13'
+
+module Barcode1DTools
+
+  # Barcode1DTools::UPC_A - Create pattern for UPC-A barcodes
+  #
+  # The value encoded is an 11-digit integer, and a checksum digit
+  # will be added.  You can add the option :checksum_included => true
+  # when initializing to specify that you have already included a
+  # checksum.
+  #
+  # # Note that this number is a UPC-A, with the number system of 08,
+  # # manufacturer's code of "28999", product code of "00682", and a
+  # # checksum of "3" (not included)
+  # num = '82899900682'
+  # bc = Barcode1DTools::UPC_A.new(num)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  # check_digit = Barcode1DTools::UPC_A.generate_check_digit_for(num)
+  #
+  # A UPC-A barcode is an EAN-13 with an initial digit of "0" (that
+  # is the left digit of the number system designator).  Like the
+  # EAN-13, the code is broken into a single-digit number system,
+  # 5 digit manufacturer code, 5 digit product code, and single
+  # digit checksum.
+  #
+  # The number system is:
+  # 0, 1, 6, 7, 8 - standard UPC codes
+  # 2    - a product weight- generally calculated at the store.
+  # 3    - pharmaceuticals
+  # 4    - used for loyalty cards at stores
+  # 5    - coupons
+  # 9    - coupons
+  # 978  - for books, with a 10-digit ISBN coming after 978
+  #
+  # For code 2, the manufacturer code becomes an item number, and the
+  # product number is used for either the weight or the price, with
+  # the first digit determining which.
+  #
+  # For 5 and 9, the manufacturer code is the same as a standard
+  # UPC.  The first three digits of the product code are used as a
+  # "family code" set by the manufacturer, and the last two digits
+  # are a "coupon code" which determines the amount of the discount
+  # based on a table released by the GS1 US (formerly the UCC).
+  # Code 5 coupons may be doubled or tripled, but code 9 may not.
+  #
+  #== Rendering
+  #
+  # The UPC-A is typically rendered at 1-1.5 inch across, and half
+  # an inch high.  The number system digit and checksum digit are
+  # shown on the left and right sides of the code.  The other two
+  # sets of five digits are rendered at the bottom of the barcode.
+  # The alignment can be either bottom of the text flush with
+  # bottom of barcode, or middle of text aligned with bottom of
+  # barcode.  The two sets of five digits are separated by the two
+  # middle guard bars which always extend to the bottom.  There
+  # should be at least 9 spaces of quiet area on either side of
+  # the code.
+
+  class UPC_A < EAN13
+
+    class << self
+      # Returns true or false - must be 11-13 digits.  This
+      # also handles the case where the leading 0 is added.
+      def can_encode?(value, options = nil)
+        if !options
+          value.to_s =~ /^0?[0-9]{11,12}$/
+        elsif (options[:checksum_included])
+          value.to_s =~ /^0?[0-9]{12}$/
+        else
+          value.to_s =~ /^0?[0-9]{11}$/
+        end
+      end
+
+      # Generates check digit given a string to encode.  It assumes there
+      # is no check digit on the "value".
+      def generate_check_digit_for(value)
+        super('0' + value)
+      end
+
+      # validates the check digit given a string - assumes check digit
+      # is last digit of string.
+      def validate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value, :checksum_included => true)
+        md = value.match(/^(0?\d{11})(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      def decode(value)
+        ean = super(value)
+        if ean.value[0,1] == '0'
+          new(ean.value[1,11])
+        else
+          raise UnencodableCharactersError
+        end
+      end
+    end
+
+    # Options are :line_character, :space_character, and
+    # :checksum_included.
+    def initialize(value, options = {})
+
+      @options = DEFAULT_OPTIONS.merge(options)
+
+      # Can we encode this value?
+      raise UnencodableCharactersError unless self.class.can_encode?(value, @options)
+
+      if @options[:checksum_included]
+        @encoded_string = value.to_s
+        raise ChecksumError unless self.class.validate_check_digit_for(@encoded_string)
+        md = @encoded_string.match(/^(\d+?)(\d)$/)
+        @value, @check_digit = md[1], md[2].to_i
+      else
+        # need to add a checksum
+        @value = value.to_s
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = "#{@value}#{@check_digit}"
+      end
+
+      md = @value.match(/^(\d)(\d{5})(\d{5})/)
+      @number_system, @manufacturers_code, @product_code = md[1], md[2], md[3]
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      if @rle
+        @rle
+      else
+        md = @encoded_string.match(/^(\d{6})(\d{6})/)
+        @rle = gen_rle('0', md[1], md[2])
+      end
+    end
+
+  end
+end

data/lib/barcode1dtools/upc_e.rb

@@ -0,0 +1,274 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'barcode1dtools/upc_a'
+
+module Barcode1DTools
+
+  # Barcode1DTools::UPC_E - Create pattern for UPC-E barcodes
+  #
+  # The value encoded is an 6-digit integer, and a checksum digit
+  # will be added.  You can add the option :checksum_included => true
+  # when initializing to specify that you have already included a
+  # checksum.
+  #
+  # num = '394932'
+  # bc = Barcode1DTools::UPC_E.new(num)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  # check_digit = Barcode1DTools::UPC_E.generate_check_digit_for(num)
+  #
+  # A UPC-E barcode is an abbreviated form of UPC-A, but can encode
+  # only a few codes.  The checksum is derived from the full UPC-A
+  # digit sequence rather than the 6 digits of the UPC-E.  The checksum
+  # is encoded as the parity, with the bar patterns the same as the left
+  # side of a standard UPC-A.
+  #
+  # The last digit of the UPC-E determines the pattern used to convert
+  # to a UPC-A.
+  #
+  # UPC-E      UPC-A equivalent
+  # 2 digits for manufacturer code (plus last digit), 3 digits for product
+  # XXNNN0     0XX000-00NNN
+  # XXNNN1     0XX100-00NNN
+  # XXNNN2     0XX200-00NNN
+  # 3 digits for manufacturer code, 2 digits for product
+  # XXXNN3     0XXX00-000NN
+  # 4 digits for manufacturer code, 1 digit for product
+  # XXXXN4     0XXXX0-0000N
+  # 5 digits for manufacturer code, 1 digit for product (5-9)
+  # XXXXX5     0XXXXX-00005
+  # XXXXX6     0XXXXX-00006
+  # XXXXX7     0XXXXX-00007
+  # XXXXX8     0XXXXX-00008
+  # XXXXX9     0XXXXX-00009
+  #
+  #== Rendering
+  #
+  # The UPC-E is made for smaller items.  Generally, they are rendered
+  # with the number system digit (0) on the left of the bars and the
+  # checksum on the right.  The 6-digit payload is shown below the bars
+  # with the end guard bars extending half-way down the digits.  The
+  # number system and check digit might be rendered in a slightly smaller
+  # font size.  The UPC-E uses the same bar patterns as the left half of
+  # a regular UPC-A, but there is no middle pattern and the right guard
+  # pattern has an extra line/space pair.
+
+  class UPC_E < Barcode1D
+
+    LEFT_PATTERNS = UPC_A::LEFT_PATTERNS
+    LEFT_PATTERNS_RLE = UPC_A::LEFT_PATTERNS_RLE
+
+    PARITY_PATTERNS = {
+      '0' => 'eeeooo',
+      '1' => 'eeoeoo',
+      '2' => 'eeooeo',
+      '3' => 'eeoooe',
+      '4' => 'eoeeoo',
+      '5' => 'eooeeo',
+      '6' => 'eoooee',
+      '7' => 'eoeoeo',
+      '8' => 'eoeooe',
+      '9' => 'eooeoe',
+    };
+
+    LEFT_GUARD_PATTERN = '101'
+    RIGHT_GUARD_PATTERN = '010101'
+    LEFT_GUARD_PATTERN_RLE = '111'
+    RIGHT_GUARD_PATTERN_RLE = '111111'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0'
+    }
+
+    # For UPC-E
+    attr_reader :number_system
+    attr_reader :manufacturers_code
+    attr_reader :product_code
+    attr_reader :upca_value
+
+    class << self
+      # Returns true or false - must be 6-8 digits.  This
+      # also handles the case where the leading 0 is added.
+      def can_encode?(value, options = nil)
+        if !options
+          value.to_s =~ /^0?[0-9]{6,7}$/
+        elsif (options[:checksum_included])
+          value.to_s =~ /^0?[0-9]{7}$/
+        else
+          value.to_s =~ /^0?[0-9]{6}$/
+        end
+      end
+
+      # Generates check digit given a string to encode.  It assumes there
+      # is no check digit on the "value".
+      def generate_check_digit_for(value)
+        UPC_A.generate_check_digit_for(self.upce_value_to_upca_value(value))
+      end
+
+      # validates the check digit given a string - assumes check digit
+      # is last digit of string.
+      def validate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value, :checksum_included => true)
+        md = value.match(/^(0?\d{6})(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      def decode(str)
+        if str.length == 51
+          # bar pattern
+          str = bars_to_rle(str)
+        elsif str.length == 33 && str =~ /^[1-9]+$/
+          # rle
+        else
+          raise UnencodableCharactersError, "Pattern must be 51 unit bar pattern or 33 character rle."
+        end
+
+        # See if the string is reversed
+        if str[0..5] == RIGHT_GUARD_PATTERN_RLE && str[30..32] == LEFT_GUARD_PATTERN_RLE
+          str.reverse!
+        end
+
+        # Check the guard patterns
+        unless (str[0..2] == LEFT_GUARD_PATTERN_RLE && str[27..32] == RIGHT_GUARD_PATTERN_RLE)
+          raise UnencodableCharactersError, "Missing or incorrect guard patterns"
+        end
+
+        parity_sequence = ''
+        digits = ''
+        initial_offset = LEFT_GUARD_PATTERN_RLE.length
+
+        # Decode
+        (0..5).each do |offset|
+          found = false
+          digit_rle = str[(initial_offset + offset*4),4]
+          ['o','e'].each do |parity|
+            ('0'..'9').each do |digit|
+              if LEFT_PATTERNS_RLE[digit][parity] == digit_rle
+                parity_sequence += parity
+                digits += digit
+                found = true
+                break
+              end
+            end
+          end
+          raise UndecodableCharactersError, "Invalid sequence: #{digit_rle}" unless found
+        end
+
+        # Now, find the parity digit
+        parity_digit = nil
+        ('0'..'9').each do |x|
+          if PARITY_PATTERNS[x] == parity_sequence
+            parity_digit = x
+            break
+          end
+        end
+
+        raise UndecodableCharactersError, "Weird parity: #{parity_sequence}" unless parity_digit
+
+        UPC_E.new('0' + digits + parity_digit, :checksum_included => true)
+      end
+
+      def upce_value_to_upca_value(value, options = {})
+        raise UnencodableCharactersError unless self.can_encode?(value, options)
+        # remove the check digit if it was included
+        value = value.to_i % 10 if options[:checksum_included]
+        value = sprintf('%06d', value.to_i)
+        if value =~ /(\d\d)(\d\d\d)([012])/
+          upca_value = "0#{$1}#{$3}0000#{$2}"
+        elsif value =~ /(\d\d\d)(\d\d)(3)/
+          upca_value = "0#{$1}00000#{$2}"
+        elsif value =~ /(\d\d\d\d)(\d)(4)/
+          upca_value = "0#{$1}00000#{$2}"
+        elsif value =~ /(\d\d\d\d\d)([5-9])/
+          upca_value = "0#{$1}0000#{$2}"
+        else
+          raise UnencodableCharactersError, "Cannot change UPC-E #{value} to UPC-A"
+        end
+        upca_value
+      end
+
+      def upca_value_to_upce_value(value, options = {})
+        raise UnencodableCharactersError unless UPC_A.can_encode?(value, options)
+        value = value % 10 if options[:checksum_included]
+        value = sprintf('%011d', value.to_i)
+        if value =~ /^0(\d\d\d\d[1-9])0000([5-9])/
+          upce_value = "0#{$1}#{$2}"
+        elsif value =~ /^0(\d\d\d[1-9])00000(\d)/
+          upce_value = "0#{$1}#{$2}4"
+        elsif value =~ /^0(\d\d)([012])0000(\d\d\d)/
+          upce_value = "0#{$1}#{$3}#{$2}"
+        elsif value =~ /^0(\d\d[3-9])00000(\d\d)/
+          upce_value = "0#{$1}#{$2}3"
+        else
+          raise UnencodableCharactersError, "Cannot change UPC-A #{value} to UPC-E"
+        end
+        upce_value
+      end
+    end
+
+    # Options are :line_character, :space_character, and
+    # :checksum_included.
+    def initialize(value, options = {})
+
+      @options = DEFAULT_OPTIONS.merge(options)
+
+      # Can we encode this value?
+      raise UnencodableCharactersError unless self.class.can_encode?(value, @options)
+
+      if @options[:checksum_included]
+        @encoded_string = value.to_s
+        raise ChecksumError unless self.class.validate_check_digit_for(@encoded_string)
+        md = @encoded_string.match(/^(\d+?)(\d)$/)
+        @value, @check_digit = md[1], md[2].to_i
+      else
+        # need to add a checksum
+        @value = value.to_s
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = "#{@value}#{@check_digit}"
+      end
+
+      @upca_value = self.class.upce_value_to_upca_value(@value)
+      md = @upca_value.match(/^(\d)(\d{5})(\d{5})/)
+      @number_system, @manufacturers_code, @product_code = md[1], md[2], md[3]
+    end
+
+    # not usable with EAN-style codes
+    def wn
+      raise NotImplementedError
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      if @rle
+        @rle
+      else
+        md = @encoded_string.match(/(\d{6})(\d)$/)
+        @rle = gen_rle(md[1], md[2])
+      end
+    end
+
+    # returns 1s and 0s (for "black" and "white")
+    def bars
+      @bars ||= self.class.rle_to_bars(self.rle, @options)
+    end
+
+    # returns the total unit width of the bar code
+    def width
+      @width ||= rle.split('').inject(0) { |a,c| a + c.to_i }
+    end
+
+    private
+
+    def gen_rle(payload, parity_digit)
+      (LEFT_GUARD_PATTERN_RLE + (0..5).collect { |n| LEFT_PATTERNS_RLE[payload[n,1]][PARITY_PATTERNS[parity_digit][n,1]] }.join('') + RIGHT_GUARD_PATTERN_RLE)
+    end
+
+  end
+end

data/lib/barcode1dtools/upc_supplemental_2.rb

@@ -0,0 +1,221 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+require 'barcode1dtools/upc_a'
+
+module Barcode1DTools
+
+  # Barcode1DTools::UPC_Supplemental_2 - Create pattern for UPC
+  # Supplemental 2 barcodes
+  #
+  # The value encoded is an 2-digit integer, and a checksum digit
+  # will be added.  You can add the option :checksum_included => true
+  # when initializing to specify that you have already included a
+  # checksum.
+  #
+  # num = '24'
+  # bc = Barcode1DTools::UPC_Supplemental_2.new(num)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  # check_digit = Barcode1DTools::UPC_E.generate_check_digit_for(num)
+  #
+  # This type of barcode consists of 2 digits, and a check digit
+  # (simply a modulus 4 of the number encoded) that is encoded in
+  # the "parity" of the two barcode digits.  The bar patterns are the
+  # same as the left half of a standard UPC-A.
+  #
+  # The 2-digit supplement is generally used on periodicals as an
+  # "issue number", so that the UPC-A code may remain the same
+  # across issues.  The two are scanned together, and typically the
+  # scanner will return the two digits of the supplemental barcode
+  # immediately following the check digit from the main UPC-A.  You
+  # will likely need to use the Barcode::UPC_A module in addition
+  # to this one to create the full code.
+  #
+  #== Rendering
+  #
+  # The 2-digit supplement is positioned to the right of the main UPC
+  # code, and the human-readable digits are usually printed above the
+  # supplemental barcode.  UPC-A is generally rendered at one inch
+  # across, then there's a 1/8th inch gap, then the supplemental.  A
+  # UPC-A is 95 units wide, so the gap is 24 units wide.  The
+  # supplemental barcode is 20 units wide.  The author hasn't viewed
+  # the specification, but note that the UPC (and more generally EAN)
+  # barcode system never a bar or space of more than four units
+  # width.  Given that, the gap should likely be at last 10 units
+  # wide.
+
+  class UPC_Supplemental_2 < Barcode1D
+
+    LEFT_PATTERNS = UPC_A::LEFT_PATTERNS
+    LEFT_PATTERNS_RLE = UPC_A::LEFT_PATTERNS_RLE
+
+    # parity patterns, essentially binary counting where "e" is "1"
+    # and "o" is "0"
+    PARITY_PATTERNS = {
+      '0' => 'oo',
+      '1' => 'oe',
+      '2' => 'eo',
+      '3' => 'ee',
+    };
+
+    LEFT_GUARD_PATTERN = '1011'
+    MIDDLE_GUARD_PATTERN = '01'
+    LEFT_GUARD_PATTERN_RLE = '112'
+    MIDDLE_GUARD_PATTERN_RLE = '11'
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0'
+    }
+
+    class << self
+      # Returns true or false - must be 1-3 digits.  This
+      # also handles the case where the leading 0 is added.
+      def can_encode?(value, options = nil)
+        if !options
+          value.to_s =~ /^\d{1,3}$/
+        elsif (options[:checksum_included])
+          value.to_s =~ /^\d\d\d?$/
+        else
+          value.to_s =~ /^\d\d?$/ && (0..99).include?(value.to_i)
+        end
+      end
+
+      # Generates check digit given a string to encode.  It assumes there
+      # is no check digit on the "value".
+      def generate_check_digit_for(value)
+        value.to_i % 4
+      end
+
+      # validates the check digit given a string - assumes check digit
+      # is last digit of string.
+      def validate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value, :checksum_included => true)
+        md = value.match(/^(\d\d)(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      def decode(str)
+        if str.length == 20
+          # bar pattern
+          str = bars_to_rle(str)
+        elsif str.length == 13 && str =~ /^[1-9]+$/
+          # rle
+        else
+          raise UnencodableCharactersError, "Pattern must be 20 unit bar pattern or 13 character rle."
+        end
+
+        # This string is "aaabbbbccdddd" where "aaa" is the left
+        # guard pattern, "bbbb" is the first digit, "cc" is the
+        # intra-digit guard pattern, and "dddd" is the second
+        # digit.
+
+        # See if the string is reversed
+        if str[10..12] == LEFT_GUARD_PATTERN_RLE.reverse && str[4..5] == MIDDLE_GUARD_PATTERN_RLE.reverse
+          str.reverse!
+        end
+
+        # Check the guard patterns
+        unless (str[0..2] == LEFT_GUARD_PATTERN_RLE && str[7..8] == MIDDLE_GUARD_PATTERN_RLE)
+          raise UnencodableCharactersError, "Missing or incorrect guard patterns"
+        end
+
+        parity_sequence = ''
+        digits = ''
+
+        # Decode
+        [str[3..6], str[9..12]].each do |digit_rle|
+          found = false
+          ['o','e'].each do |parity|
+            ('0'..'9').each do |digit|
+              if LEFT_PATTERNS_RLE[digit][parity] == digit_rle
+                parity_sequence += parity
+                digits += digit
+                found = true
+                break
+              end
+            end
+          end
+          raise UndecodableCharactersError, "Invalid sequence: #{digit_rle}" unless found
+        end
+
+        # Now, find the parity digit
+        parity_digit = nil
+        ('0'..'3').each do |x|
+          if PARITY_PATTERNS[x] == parity_sequence
+            parity_digit = x
+            break
+          end
+        end
+
+        raise UndecodableCharactersError, "Weird parity: #{parity_sequence}" unless parity_digit
+
+        UPC_Supplemental_2.new(digits + parity_digit, :checksum_included => true)
+      end
+
+    end
+
+    # Options are :line_character, :space_character, and
+    # :checksum_included.
+    def initialize(value, options = {})
+
+      @options = DEFAULT_OPTIONS.merge(options)
+
+      # Can we encode this value?
+      raise UnencodableCharactersError unless self.class.can_encode?(value, @options)
+
+      if @options[:checksum_included]
+        @encoded_string = value.to_s
+        raise ChecksumError unless self.class.validate_check_digit_for(@encoded_string)
+        md = @encoded_string.match(/^(\d+?)(\d)$/)
+        @value, @check_digit = md[1].to_i, md[2].to_i
+      else
+        # need to add a checksum
+        @value = value.to_i
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = sprintf('%02d%1d',@value,@check_digit)
+      end
+    end
+
+    # not usable with EAN-style codes
+    def wn
+      raise NotImplementedError
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      if @rle
+        @rle
+      else
+        md = @encoded_string.match(/(\d\d)(\d)$/)
+        @rle = gen_rle(md[1], md[2])
+      end
+    end
+
+    # returns 1s and 0s (for "black" and "white")
+    def bars
+      @bars ||= self.class.rle_to_bars(self.rle, @options)
+    end
+
+    # returns the total unit width of the bar code
+    def width
+      @width ||= rle.split('').inject(0) { |a,c| a + c.to_i }
+    end
+
+    private
+
+    def gen_rle(payload, parity_digit)
+      LEFT_GUARD_PATTERN_RLE +
+      LEFT_PATTERNS_RLE[payload[0,1]][PARITY_PATTERNS[parity_digit][0,1]] +
+      MIDDLE_GUARD_PATTERN_RLE +
+      LEFT_PATTERNS_RLE[payload[1,1]][PARITY_PATTERNS[parity_digit][1,1]]
+    end
+
+  end
+end