rhodes 2.4.1 → 3.0.0.beta.1

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/UPCEANWriter.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.Writer;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+
+import java.util.Hashtable;
+
+/**
+ * <p>Encapsulates functionality and implementation that is common to UPC and EAN families
+ * of one-dimensional barcodes.</p>
+ *
+ * @author aripollak@gmail.com (Ari Pollak)
+ */
+public abstract class UPCEANWriter implements Writer {
+
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height)
+  throws WriterException {
+    return encode(contents, format, width, height, null);
+  }
+
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height,
+      Hashtable hints) throws WriterException {
+    if (contents == null || contents.length() == 0) {
+      throw new IllegalArgumentException("Found empty contents");
+    }
+
+    if (width < 0 || height < 0) {
+      throw new IllegalArgumentException("Requested dimensions are too small: "
+          + width + 'x' + height);
+    }
+
+    byte[] code = encode(contents);
+    return renderResult(code, width, height);
+  }
+
+  /** @return a byte array of horizontal pixels (0 = white, 1 = black) */
+  private static BitMatrix renderResult(byte[] code, int width, int height) {
+    int inputWidth = code.length;
+    // Add quiet zone on both sides
+    int fullWidth = inputWidth + (UPCEANReader.START_END_PATTERN.length << 1);
+    int outputWidth = Math.max(width, fullWidth);
+    int outputHeight = Math.max(1, height);
+
+    int multiple = outputWidth / fullWidth;
+    int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
+
+    BitMatrix output = new BitMatrix(outputWidth, outputHeight);
+    for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
+      if (code[inputX] == 1) {
+        output.setRegion(outputX, 0, multiple, outputHeight);
+      }
+    }
+    return output;
+  }
+
+
+  /**
+   * Appends the given pattern to the target array starting at pos.
+   *
+   * @param startColor
+   *          starting color - 0 for white, 1 for black
+   * @return the number of elements added to target.
+   */
+   protected static int appendPattern(byte[] target, int pos, int[] pattern, int startColor) {
+    if (startColor != 0 && startColor != 1) {
+      throw new IllegalArgumentException(
+          "startColor must be either 0 or 1, but got: " + startColor);
+    }
+
+    byte color = (byte) startColor;
+    int numAdded = 0;
+    for (int i = 0; i < pattern.length; i++) {
+      for (int j = 0; j < pattern[i]; j++) {
+        target[pos] = color;
+        pos += 1;
+        numAdded += 1;
+      }
+      color ^= 1; // flip color after each segment
+    }
+    return numAdded;
+  }
+
+  /** @return a byte array of horizontal pixels (0 = white, 1 = black) */
+  public abstract byte[] encode(String contents);
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/UPCEReader.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.ChecksumException;
+import com.google.zxing.FormatException;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.common.BitArray;
+
+/**
+ * <p>Implements decoding of the UPC-E format.</p>
+ * <p/>
+ * <p><a href="http://www.barcodeisland.com/upce.phtml">This</a> is a great reference for
+ * UPC-E information.</p>
+ *
+ * @author Sean Owen
+ */
+public final class UPCEReader extends UPCEANReader {
+
+  /**
+   * The pattern that marks the middle, and end, of a UPC-E pattern.
+   * There is no "second half" to a UPC-E barcode.
+   */
+  private static final int[] MIDDLE_END_PATTERN = {1, 1, 1, 1, 1, 1};
+
+  /**
+   * 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.
+   */
+  private static final int[][] NUMSYS_AND_CHECK_DIGIT_PATTERNS = {
+      {0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25},
+      {0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A}
+  };
+
+  private final int[] decodeMiddleCounters;
+
+  public UPCEReader() {
+    decodeMiddleCounters = new int[4];
+  }
+
+  protected int decodeMiddle(BitArray row, int[] startRange, StringBuffer result)
+      throws NotFoundException {
+    int[] counters = decodeMiddleCounters;
+    counters[0] = 0;
+    counters[1] = 0;
+    counters[2] = 0;
+    counters[3] = 0;
+    int end = row.getSize();
+    int rowOffset = startRange[1];
+
+    int lgPatternFound = 0;
+
+    for (int x = 0; x < 6 && rowOffset < end; x++) {
+      int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);
+      result.append((char) ('0' + bestMatch % 10));
+      for (int i = 0; i < counters.length; i++) {
+        rowOffset += counters[i];
+      }
+      if (bestMatch >= 10) {
+        lgPatternFound |= 1 << (5 - x);
+      }
+    }
+
+    determineNumSysAndCheckDigit(result, lgPatternFound);
+
+    return rowOffset;
+  }
+
+  protected int[] decodeEnd(BitArray row, int endStart) throws NotFoundException {
+    return findGuardPattern(row, endStart, true, MIDDLE_END_PATTERN);
+  }
+
+  protected boolean checkChecksum(String s) throws FormatException, ChecksumException {
+    return super.checkChecksum(convertUPCEtoUPCA(s));
+  }
+
+  private static void determineNumSysAndCheckDigit(StringBuffer resultString, int lgPatternFound)
+      throws NotFoundException {
+
+    for (int numSys = 0; numSys <= 1; numSys++) {
+      for (int d = 0; d < 10; d++) {
+        if (lgPatternFound == NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d]) {
+          resultString.insert(0, (char) ('0' + numSys));
+          resultString.append((char) ('0' + d));
+          return;
+        }
+      }
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  BarcodeFormat getBarcodeFormat() {
+    return BarcodeFormat.UPC_E;
+  }
+
+  /**
+   * Expands a UPC-E value back into its full, equivalent UPC-A code value.
+   *
+   * @param upce UPC-E code as string of digits
+   * @return equivalent UPC-A code as string of digits
+   */
+  public static String convertUPCEtoUPCA(String upce) {
+    char[] upceChars = new char[6];
+    upce.getChars(1, 7, upceChars, 0);
+    StringBuffer result = new StringBuffer(12);
+    result.append(upce.charAt(0));
+    char lastChar = upceChars[5];
+    switch (lastChar) {
+      case '0':
+      case '1':
+      case '2':
+        result.append(upceChars, 0, 2);
+        result.append(lastChar);
+        result.append("0000");
+        result.append(upceChars, 2, 3);
+        break;
+      case '3':
+        result.append(upceChars, 0, 3);
+        result.append("00000");
+        result.append(upceChars, 3, 2);
+        break;
+      case '4':
+        result.append(upceChars, 0, 4);
+        result.append("00000");
+        result.append(upceChars[4]);
+        break;
+      default:
+        result.append(upceChars, 0, 5);
+        result.append("0000");
+        result.append(lastChar);
+        break;
+    }
+    result.append(upce.charAt(7));
+    return result.toString();
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/rss/AbstractRSSReader.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned.rss;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.oned.OneDReader;
+
+public abstract class AbstractRSSReader extends OneDReader {
+
+  private static final int MAX_AVG_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.2f);
+  private static final int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.4f);
+
+  private static final float MIN_FINDER_PATTERN_RATIO = 9.5f / 12.0f;
+  private static final float MAX_FINDER_PATTERN_RATIO = 12.5f / 14.0f;
+
+  protected final int[] decodeFinderCounters;
+  protected final int[] dataCharacterCounters;
+  protected final float[] oddRoundingErrors;
+  protected final float[] evenRoundingErrors;
+  protected final int[] oddCounts;
+  protected final int[] evenCounts;
+
+  protected AbstractRSSReader(){
+      decodeFinderCounters = new int[4];
+      dataCharacterCounters = new int[8];
+      oddRoundingErrors = new float[4];
+      evenRoundingErrors = new float[4];
+      oddCounts = new int[dataCharacterCounters.length / 2];
+      evenCounts = new int[dataCharacterCounters.length / 2];
+  }
+
+
+  protected static int parseFinderValue(int[] counters, int [][] finderPatterns) throws NotFoundException {
+    for (int value = 0; value < finderPatterns.length; value++) {
+      if (patternMatchVariance(counters, finderPatterns[value], MAX_INDIVIDUAL_VARIANCE) <
+          MAX_AVG_VARIANCE) {
+        return value;
+      }
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  protected static int count(int[] array) {
+    int count = 0;
+    for (int i = 0; i < array.length; i++) {
+      count += array[i];
+    }
+    return count;
+  }
+
+  protected static void increment(int[] array, float[] errors) {
+    int index = 0;
+    float biggestError = errors[0];
+    for (int i = 1; i < array.length; i++) {
+      if (errors[i] > biggestError) {
+        biggestError = errors[i];
+        index = i;
+      }
+    }
+    array[index]++;
+  }
+
+  protected static void decrement(int[] array, float[] errors) {
+    int index = 0;
+    float biggestError = errors[0];
+    for (int i = 1; i < array.length; i++) {
+      if (errors[i] < biggestError) {
+        biggestError = errors[i];
+        index = i;
+      }
+    }
+    array[index]--;
+  }
+
+  protected static boolean isFinderPattern(int[] counters) {
+    int firstTwoSum = counters[0] + counters[1];
+    int sum = firstTwoSum + counters[2] + counters[3];
+    float ratio = (float) firstTwoSum / (float) sum;
+    if (ratio >= MIN_FINDER_PATTERN_RATIO && ratio <= MAX_FINDER_PATTERN_RATIO) {
+      // passes ratio test in spec, but see if the counts are unreasonable
+      int minCounter = Integer.MAX_VALUE;
+      int maxCounter = Integer.MIN_VALUE;
+      for (int i = 0; i < counters.length; i++) {
+        int counter = counters[i];
+        if (counter > maxCounter) {
+          maxCounter = counter;
+        }
+        if (counter < minCounter) {
+          minCounter = counter;
+        }
+      }
+      return maxCounter < 10 * minCounter;
+    }
+    return false;
+  }
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/rss/DataCharacter.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned.rss;
+
+public class DataCharacter {
+
+  private final int value;
+  private final int checksumPortion;
+
+  public DataCharacter(int value, int checksumPortion) {
+    this.value = value;
+    this.checksumPortion = checksumPortion;
+  }
+
+  public int getValue() {
+    return value;
+  }
+
+  public int getChecksumPortion() {
+    return checksumPortion;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/oned/rss/FinderPattern.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.oned.rss;
+
+import com.google.zxing.ResultPoint;
+
+public final class FinderPattern {
+
+  private final int value;
+  private final int[] startEnd;
+  private final ResultPoint[] resultPoints;
+
+  public FinderPattern(int value, int[] startEnd, int start, int end, int rowNumber) {
+    this.value = value;
+    this.startEnd = startEnd;
+    this.resultPoints = new ResultPoint[] {
+        new ResultPoint((float) start, (float) rowNumber),
+        new ResultPoint((float) end, (float) rowNumber),
+    };
+  }
+
+  public int getValue() {
+    return value;
+  }
+
+  public int[] getStartEnd() {
+    return startEnd;
+  }
+
+  public ResultPoint[] getResultPoints() {
+    return resultPoints;
+  }
+
+}