barcode1dtools 0.9.2

data/lib/barcode1dtools/ean8.rb

@@ -0,0 +1,252 @@
+#--
+# 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::EAN_8 - Create pattern for EAN-8 barcodes
+  
+  # The value encoded is a 7-digit number, 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 = '96385074'
+  # bc = Barcode1DTools::EAN8.new(num)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # width = bc.width
+  # check_digit = Barcode1DTools::EAN83.generate_check_digit_for(num)
+  #
+  # The object created is immutable.
+  #
+  # There are two formats for the returned pattern (wn format is
+  # not available):
+  #
+  #   bars - 1s and 0s specifying black lines and white spaces.  Actual
+  #          characters can be changed from "1" and 0" with options
+  #          :line_character and :space_character.  Each character
+  #          in the string renders to a single unit width.
+  #
+  #   rle -  Run-length-encoded version of the pattern.  The first
+  #          number is always a black line, with subsequent digits
+  #          alternating between spaces and lines.  The digits specify
+  #          the width of each line or space.
+  #
+  # The "width" method will tell you the total end-to-end width, in
+  # units, of the entire barcode.
+  #
+  # Unlike some of the other barcodes, e.g. Code 3 of 9, there is no "wnstr" for
+  # EAN & UPC style barcodes because the bars and spaces are variable width from
+  # 1 to 4 units.
+  # 
+  # A EAN-8 barcode has 3 elements:
+  # 1. A 2 or 3 digit "number system" designation
+  # 2. A 4 or 5 digit manufacturer's code
+  # 3. A single digit checksum
+  # 
+  # Note than an EAN-8 is not analogous to a UPC-E.  In particular, there
+  # is no way to create an EAN-13 from and EAN-8 and vice versa.  The
+  # numbers are assigned within each system by a central authority.
+  #
+  # The bar patterns are the same as EAN-13, with nothing encoded in the
+  # parity.  All bars on the left use the "odd" parity set.
+  # 
+  # RENDERING
+  # 
+  # When rendered, two sets of four digits are shown at the bottom of the
+  # code, aligned with the bottom of the code, and with the middle guard
+  # pattern bars extending down between them.  A supplemental 2 or 5 may
+  # be used.
+
+  class EAN8 < Barcode1D
+
+    # patterns to create the bar codes:
+    LEFT_PATTERNS = EAN13::LEFT_PATTERNS
+    LEFT_PATTERNS_RLE = EAN13::LEFT_PATTERNS_RLE
+    RIGHT_PATTERNS = EAN13::RIGHT_PATTERNS
+    RIGHT_PATTERNS_RLE = EAN13::RIGHT_PATTERNS_RLE
+
+    SIDE_GUARD_PATTERN=EAN13::SIDE_GUARD_PATTERN
+    MIDDLE_GUARD_PATTERN=EAN13::MIDDLE_GUARD_PATTERN
+    SIDE_GUARD_PATTERN_RLE=EAN13::SIDE_GUARD_PATTERN_RLE
+    MIDDLE_GUARD_PATTERN_RLE=EAN13::MIDDLE_GUARD_PATTERN_RLE
+
+    DEFAULT_OPTIONS = {
+      :line_character => '1',
+      :space_character => '0'
+    }
+
+    # Specific for EAN
+    attr_reader :number_system
+    attr_reader :product_code
+
+    class << self
+      # returns true or false - must be 7-8 digits
+      def can_encode?(value, options = nil)
+        if !options
+          value.to_s =~ /^\d{7,8}$/
+        elsif (options[:checksum_included])
+          value.to_s =~ /^\d{8}$/
+        else
+          value.to_s =~ /^\d{7}$/
+        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)
+        raise UnencodableCharactersError unless self.can_encode?(value, :checksum_included => false)
+        mult = 1
+        value = value.split('').inject(0) { |a,c| mult = 4 - mult ; a + c.to_i * mult }
+        (10 - (value % 10)) % 10
+      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{7})(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      # Decode a string representing an rle or bar pattern EAN-13.
+      # Note that the string might be backward or forward.  This
+      # will return an EAN8 object.
+      def decode(str)
+        if str.length == 67
+          # bar pattern
+          str = bars_to_rle(str)
+        elsif str.length == 43
+          # rle
+        else
+          raise UnencodableCharactersError, "Pattern must be 67 unit bar pattern or 43 character rle."
+        end
+
+        # Check the guard patterns
+        unless str[0..2] == SIDE_GUARD_PATTERN_RLE && str[40..42] == SIDE_GUARD_PATTERN_RLE && str[19..23] == MIDDLE_GUARD_PATTERN_RLE
+          raise UnencodableCharactersError, "Missing or incorrect guard patterns"
+        end
+
+        # Now I have an rle pattern, simply need to decode
+        # according to the LEFT_PATTERNS_RLE, keeping track
+        # of the parity for each position.
+
+        # Set up the decoder
+        left_parity_sequence = ''
+        left_digits = ''
+        right_parity_sequence = ''
+        right_digits = ''
+        left_initial_offset = SIDE_GUARD_PATTERN_RLE.length
+        right_initial_offset = SIDE_GUARD_PATTERN_RLE.length + (4*4) + MIDDLE_GUARD_PATTERN_RLE.length
+
+        # Decode the left side
+        (0..3).each do |left_offset|
+          found = false
+          digit_rle = str[(left_initial_offset + left_offset*4),4]
+          ['o','e'].each do |parity|
+            ('0'..'9').each do |digit|
+              if LEFT_PATTERNS_RLE[digit][parity] == digit_rle
+                left_parity_sequence += parity
+                left_digits += digit
+                found = true
+                break
+              end
+            end
+          end
+          raise UndecodableCharactersError, "Invalid sequence: #{digit_rle}" unless found
+        end
+
+        # Decode the right side
+        (0..3).each do |right_offset|
+          found = false
+          digit_rle = str[(right_initial_offset + right_offset*4),4]
+          ['o','e'].each do |parity|
+            ('0'..'9').each do |digit|
+              if LEFT_PATTERNS_RLE[digit][parity] == digit_rle
+                right_parity_sequence += parity
+                right_digits += digit
+                found = true
+                break
+              end
+            end
+          end
+          raise UndecodableCharactersError, "Invalid sequence: #{digit_rle}" unless found
+        end
+
+        # If left parity sequence is 'eeee', the string is reversed
+        if left_parity_sequence == 'eeee'
+          left_digits, right_digits, left_parity_sequence = right_digits.reverse, left_digits.reverse, right_parity_sequence.reverse.tr('eo','oe')
+        end
+
+        # Debugging
+        #puts "Left digits: #{left_digits} Left parity: #{left_parity_sequence}"
+        #puts "Right digits: #{right_digits} Right parity: #{right_parity_sequence}"
+
+        EAN8.new(left_digits + right_digits, :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 = sprintf('%08d', value.to_i)
+        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 = sprintf('%07d', value.to_i)
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = "#{@value}#{@check_digit}"
+      end
+
+      md = @value.match(/^(\d{3})(\d{4})/)
+      @number_system, @product_code = md[1], md[2]
+    end
+
+    # not usable with EAN codes
+    def wn
+      raise NotImplementedError
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      if @rle
+        @rle
+      else
+        md = @encoded_string.match(/^(\d{4})(\d{4})/)
+        @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(left_half, right_half)
+      (SIDE_GUARD_PATTERN_RLE + (0..3).collect { |n| LEFT_PATTERNS_RLE[left_half[n,1]]['o'] }.join + MIDDLE_GUARD_PATTERN_RLE + right_half.split('').collect { |c| RIGHT_PATTERNS_RLE[c] }.join + SIDE_GUARD_PATTERN_RLE)
+    end
+
+  end
+end

data/lib/barcode1dtools/interleaved2of5.rb

@@ -0,0 +1,248 @@
+#--
+# Copyright 2012 Michael Chaney Consulting Corporation
+#
+# Released under the terms of the MIT License or the GNU
+# General Public License, v. 2
+#++
+
+module Barcode1DTools
+
+  # Barcode1DTools::Interleaved2of5 - Create pattern for Interleaved 2 of 5
+  # (also known as I 2/5 or ITF) barcodes.  The value encoded is an
+  # 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, or :skip_checksum => true to
+  # specify that no checksum should be added or checked.  A ChecksumError
+  # will be raised if :checksum_included => true, :skip_checksum is
+  # missing or false, and the last digit is invalid as a checksum.
+  #
+  # I 2/5 can only encode an even number of digits (including the
+  # checksum), so a "0" will be prepended if there is an odd number of
+  # digits.  The 0 has no effect on the checksum.  Note that sometimes
+  # an odd number of digits is encoded with 5 narrow spaces for the last
+  # digit.  We do not encode this way but can handle decoding.
+  #
+  # num = 238982
+  # bc = Barcode1DTools::Interleaved2of5.new(num)
+  # pattern = bc.bars
+  # rle_pattern = bc.rle
+  # wn_pattern = bc.wn
+  # width = bc.width
+  # check_digit = Barcode1DTools::Interleaved2of5.generate_check_digit_for(num)
+  #
+  # The object created is immutable.
+  #
+  # Barcode1DTools::Interleaved2of5 creates the patterns that you need to
+  # display Interleaved 2 of 5 (also known as I 2/5) barcodes.  It can also
+  # decode a simple w/n string.
+  #
+  # I 2/5 barcodes consist of lines and spaces that are either "wide" or
+  # "narrow", with "wide" lines or spaces being twice the width of
+  # narrow lines or spaces.
+  #
+  # There are three formats for the returned pattern:
+  #
+  #   bars - 1s and 0s specifying black lines and white spaces.  Actual
+  #          characters can be changed from "1" and 0" with options
+  #          :line_character and :space_character.
+  #
+  #   rle -  Run-length-encoded version of the pattern.  The first
+  #          number is always a black line, with subsequent digits
+  #          alternating between spaces and lines.  The digits specify
+  #          the width of each line or space.
+  #
+  #   wn -   The native format for this barcode type.  The string
+  #          consists of a series of "w" and "n" characters.  The first
+  #          item is always a black line, with subsequent characters
+  #          alternating between spaces and lines.  A "wide" item
+  #          is twice the width of a "narrow" item.
+  #
+  # The "width" method will tell you the total end-to-end width, in
+  # units, of the entire barcode.
+  #
+  # In this encoding, pairs of digits are interleaved with each other,
+  # so the first digit is the "bars" and the second digit is the
+  # "spaces".  Each digit consists of 5 sets of wide or narrow bars or
+  # spaces, with 2 of the 5 being wide.  The pattern can be calculated
+  # by considering a "weight" for each position: 1, 2, 4, 7, and 0, with
+  # "0" itself being represented by 4 + 7.  So, 3 is 1 + 2, or "wwnnn",
+  # while 7 is "nnnww" (7 + 0).  More information is available on
+  # Wikipedia.
+
+  class Interleaved2of5 < Barcode1D
+
+    # patterns and such go here
+    PATTERNS = {
+      'start' => 'nnnn',
+      '0' => 'nnwwn',
+      '1' => 'wnnnw',
+      '2' => 'nwnnw',
+      '3' => 'wwnnn',
+      '4' => 'nnwnw',
+      '5' => 'wnwnn',
+      '6' => 'nwwnn',
+      '7' => 'nnnww',
+      '8' => 'wnnwn',
+      '9' => 'nwnwn',
+      'stop' => 'wnn'
+    }
+
+    WN_RATIO = 2
+
+    DEFAULT_OPTIONS = {
+      :w_character => 'w',
+      :n_character => 'n',
+      :line_character => '1',
+      :space_character => '0',
+      :wn_ratio => WN_RATIO
+    }
+
+    class << self
+      # returns true or false
+      def can_encode?(value)
+        value.is_a?(Integer) || value.to_s =~ /^[0-9]+$/
+      end
+
+      # Generates check digit given a string to encode.  It assumes there
+      # is no check digit on the "value".  Note that if value has an even
+      # number of digits, a "0" will be prepended for this operation.
+      def generate_check_digit_for(value)
+        raise UnencodableCharactersError unless self.can_encode?(value)
+        mult = 1
+        value = value.to_s
+        value = "0#{value}" if value.size.even?
+        value = value.split('').inject(0) { |a,c| mult = 4 - mult ; a + c.to_i * mult }
+        (10 - (value % 10)) % 10
+      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)
+        md = value.to_s.match(/^(\d+)(\d)$/)
+        self.generate_check_digit_for(md[1]) == md[2].to_i
+      end
+
+      # Decode a string in wn format.  This will return an Interleaved2of5
+      # object.
+      def decode(str, options = {})
+        if str =~ /[^wn]/
+          raise UnencodableCharactersError, "Pattern must contain only \"w\" and \"n\"."
+        end
+
+        if str.reverse =~ /^#{PATTERNS['start']}.*?#{PATTERNS['stop']}$/
+          str.reverse!
+        end
+
+        unless str =~ /^#{PATTERNS['start']}(.*?)#{PATTERNS['stop']}$/
+          raise UnencodableCharactersError, "Start/stop pattern is not detected."
+        end
+
+        numeric_pattern = $1
+
+        unless numeric_pattern.size % 10 == 0
+          raise UnencodableCharactersError, "Wrong number of bars."
+        end
+
+        decoded_string = ''
+
+        numeric_pattern.scan(/(.{10})/).each do |chunk|
+          chunk = chunk[0]
+
+          num1 = chunk[0,1] + chunk[2,1] + chunk[4,1] + chunk[6,1] + chunk[8,1]
+          num2 = chunk[1,1] + chunk[3,1] + chunk[5,1] + chunk[7,1] + chunk[9,1]
+
+          found = false
+          ('0'..'9').each do |digit|
+            if PATTERNS[digit] == num1
+              decoded_string += digit
+              found = true
+            end
+          end
+
+          raise UndecodableCharactersError, "Invalid sequence: #{num1}" unless found
+
+          # nnnnn is a sequence sometimes used in the spaces of the last
+          # digit to indicate there is no last digit.
+          if num2 != 'nnnnn'
+            found = false
+            ('0'..'9').each do |digit|
+              if PATTERNS[digit] == num2
+                decoded_string += digit
+                found = true
+              end
+            end
+
+            raise UndecodableCharactersError, "Invalid sequence: #{num2}" unless found
+          end
+        end
+
+        Interleaved2of5.new(decoded_string.to_i, options)
+      end
+    end
+
+    # Options are :line_character, :space_character, :w_character,
+    # :n_character, :skip_checksum, 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)
+
+      if @options[:skip_checksum]
+        @encoded_string = value.to_s
+        @value = value.to_i
+        @check_digit = nil
+      elsif @options[:checksum_included]
+        raise ChecksumError unless self.class.validate_check_digit_for(value)
+        @encoded_string = value.to_s
+        @value = value.to_i / 10
+        @check_digit = value % 10
+      else
+        # need to add a checksum
+        @value = value.to_i
+        @check_digit = self.class.generate_check_digit_for(@value)
+        @encoded_string = "#{@value.to_s}#{@check_digit}"
+      end
+
+      @encoded_string = '0' + @encoded_string if @encoded_string.size.odd?
+    end
+
+    # Returns a string of "w" or "n" ("wide" and "narrow")
+    def wn
+      @wn ||= wn_str.tr('wn', @options[:w_character].to_s + @options[:n_character].to_s)
+    end
+
+    # returns a run-length-encoded string representation
+    def rle
+      @rle ||= self.class.wn_to_rle(self.wn, @options)
+    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 wn_str
+      @wn_str ||=
+        PATTERNS['start'] +
+        @encoded_string.unpack('A2'*(@encoded_string.size/2)).inject('') { |a,str| a + interleave(str) } +
+        PATTERNS['stop']
+    end
+
+    # Requires a two-digit string
+    def interleave(two_digits)
+      bars_pattern = PATTERNS[two_digits[0,1]]
+      spaces_pattern = PATTERNS[two_digits[1,1]]
+      (0..4).inject('') { |ret,x| ret + bars_pattern[x,1] + spaces_pattern[x,1] }
+    end
+  end
+end