Options
All
  • Public
  • Public/Protected
  • All
Menu

Class UPCEReader

Implements decoding of the UPC-E format.

This is a great reference for UPC-E information.

author

Sean Owen

source

https://github.com/zxing/zxing/blob/3c96923276dd5785d58eb970b6ba3f80d36a9505/core/src/main/java/com/google/zxing/oned/UPCEReader.java

experimental

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Properties

Private decodeMiddleCounters

decodeMiddleCounters: Int32Array

Protected decodeRowStringBuffer

decodeRowStringBuffer: string = ""

Static END_PATTERN

END_PATTERN: Int32Array = Int32Array.from([1, 1, 1, 1, 1, 1])

end guard pattern.

Static L_AND_G_PATTERNS

L_AND_G_PATTERNS: Int32Array[]

As above but also including the "even", or "G" patterns used to encode UPC/EAN digits.

Static L_PATTERNS

L_PATTERNS: Int32Array[] = [Int32Array.from([3, 2, 1, 1]), // 0Int32Array.from([2, 2, 2, 1]), // 1Int32Array.from([2, 1, 2, 2]), // 2Int32Array.from([1, 4, 1, 1]), // 3Int32Array.from([1, 1, 3, 2]), // 4Int32Array.from([1, 2, 3, 1]), // 5Int32Array.from([1, 1, 1, 4]), // 6Int32Array.from([1, 3, 1, 2]), // 7Int32Array.from([1, 2, 1, 3]), // 8Int32Array.from([3, 1, 1, 2]), // 9]

"Odd", or "L" patterns used to encode UPC/EAN digits.

Static Private MIDDLE_END_PATTERN

MIDDLE_END_PATTERN: Int32Array = Int32Array.from([1, 1, 1, 1, 1, 1])

The pattern that marks the middle, and end, of a UPC-E pattern. There is no "second half" to a UPC-E barcode.

Static MIDDLE_PATTERN

MIDDLE_PATTERN: Int32Array = Int32Array.from([1, 1, 1, 1, 1])

Pattern marking the middle of a UPC/EAN pattern, separating the two halves.

Static NUMSYS_AND_CHECK_DIGIT_PATTERNS

NUMSYS_AND_CHECK_DIGIT_PATTERNS: Int32Array[] = [Int32Array.from([0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25]),Int32Array.from([0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1]),]

See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of even-odd parity encodings of digits that imply both the number system (0 or 1) used, and the check digit.

Static START_END_PATTERN

START_END_PATTERN: Int32Array = Int32Array.from([1, 1, 1])

Start/end guard pattern.

Methods

Protected checkChecksum

  • checkChecksum(s: string): boolean

decode

Protected decodeEnd

  • decodeEnd(row: BitArray, endStart: int): Int32Array

decodeMiddle

  • decodeMiddle(row: BitArray, startRange: Int32Array, result: string): number

decodeRow

getBarcodeFormat

reset

  • reset(): void

Static checkChecksum

  • checkChecksum(s: string): boolean

Static checkStandardUPCEANChecksum

  • checkStandardUPCEANChecksum(s: string): boolean

Static convertUPCEtoUPCA

  • convertUPCEtoUPCA(upce: string): string

  • Expands a UPC-E value back into its full, equivalent UPC-A code value.

    Parameters

    • upce: string

      UPC-E code as string of digits

    Returns string

    equivalent UPC-A code as string of digits

Static decodeDigit

  • decodeDigit(row: BitArray, counters: Int32Array, rowOffset: int, patterns: Int32Array[]): number

Static decodeEnd

  • decodeEnd(row: BitArray, endStart: number): Int32Array

Static Private determineNumSysAndCheckDigit

  • determineNumSysAndCheckDigit(resultString: StringBuilder, lgPatternFound: int): void

Static findGuardPattern

  • findGuardPattern(row: BitArray, rowOffset: number, whiteFirst: boolean, pattern: Int32Array, counters: Int32Array): Int32Array
  • throws

    NotFoundException if pattern is not found

    Parameters

    • row: BitArray

      row of black/white values to search

    • rowOffset: number

      position to start search

    • whiteFirst: boolean

      if true, indicates that the pattern specifies white/black/white/... pixel counts, otherwise, it is interpreted as black/white/black/...

    • pattern: Int32Array

      pattern of counts of number of black and white pixels that are being searched for as a pattern

    • counters: Int32Array

      array of counters, as long as pattern, to re-use

    Returns Int32Array

    start/end horizontal offset of guard pattern, as an array of two ints

Static findGuardPatternWithoutCounters

  • findGuardPatternWithoutCounters(row: BitArray, rowOffset: int, whiteFirst: boolean, pattern: Int32Array): Int32Array

Static findStartGuardPattern

  • findStartGuardPattern(row: BitArray): Int32Array

Static getStandardUPCEANChecksum

  • getStandardUPCEANChecksum(s: string): number

Static Protected patternMatchVariance

  • patternMatchVariance(counters: Int32Array, pattern: Int32Array, maxIndividualVariance: number): number

  • Determines how closely a set of observed counts of runs of black/white values matches a given target pattern. This is reported as the ratio of the total variance from the expected pattern proportions across all pattern elements, to the length of the pattern.

    Parameters

    • counters: Int32Array

      observed counters

    • pattern: Int32Array

      expected pattern

    • maxIndividualVariance: number

      The most any counter can differ before we give up

    Returns number

    ratio of total variance between counters and pattern compared to total pattern size

Static Protected recordPattern

  • recordPattern(row: BitArray, start: number, counters: Int32Array): void

  • Records the size of successive runs of white and black pixels in a row, starting at a given point. The values are recorded in the given array, and the number of runs recorded is equal to the size of the array. If the row starts on a white pixel at the given start point, then the first count recorded is the run of white pixels starting from that point; likewise it is the count of a run of black pixels if the row begin on a black pixels at that point.

    throws

    NotFoundException if counters cannot be filled entirely from row before running out of pixels

    Parameters

    • row: BitArray

      row to count from

    • start: number

      offset into row to start at

    • counters: Int32Array

      array into which to record counts

    Returns void

Static Protected recordPatternInReverse

  • recordPatternInReverse(row: BitArray, start: number, counters: Int32Array): void

Generated using TypeDoc