rhodes 2.4.1 → 3.0.0.beta.1

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright 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;
+
+import java.util.Hashtable;
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * This object renders a ITF code as a {@link BitMatrix}.
+ * 
+ * @author erik.barbara@gmail.com (Erik Barbara)
+ */
+public final class ITFWriter extends UPCEANWriter {
+
+  public BitMatrix encode(String contents,
+                          BarcodeFormat format,
+                          int width,
+                          int height,
+                          Hashtable hints) throws WriterException {
+    if (format != BarcodeFormat.ITF) {
+      throw new IllegalArgumentException("Can only encode ITF, but got " + format);
+    }
+
+    return super.encode(contents, format, width, height, hints);
+  }
+
+  public byte[] encode(String contents) {
+    int length = contents.length();
+    if (length > 80) {
+      throw new IllegalArgumentException(
+          "Requested contents should be less than 80 digits long, but got " + length);
+    }
+    byte[] result = new byte[9 + 9 * length];
+    int[] start = {1, 1, 1, 1};
+    int pos = appendPattern(result, 0, start, 1);
+    for (int i = 0; i < length; i += 2) {
+      int one = Character.digit(contents.charAt(i), 10);
+      int two = Character.digit(contents.charAt(i+1), 10);
+      int[] encoding = new int[18];
+      for (int j = 0; j < 5; j++) {
+        encoding[(j << 1)] = ITFReader.PATTERNS[one][j];
+        encoding[(j << 1) + 1] = ITFReader.PATTERNS[two][j];
+      }
+      pos += appendPattern(result, pos, encoding, 1);
+    }
+    int[] end = {3, 1, 1};
+    pos += appendPattern(result, pos, end, 1);
+
+    return result;
+  }
+
+}

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

@@ -0,0 +1,109 @@
+/*
+ * 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.DecodeHintType;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Reader;
+import com.google.zxing.ReaderException;
+import com.google.zxing.Result;
+import com.google.zxing.common.BitArray;
+import com.google.zxing.oned.rss.RSS14Reader;
+import com.google.zxing.oned.rss.expanded.RSSExpandedReader;
+
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Sean Owen
+ */
+public final class MultiFormatOneDReader extends OneDReader {
+
+  private final Vector readers;
+
+  public MultiFormatOneDReader(Hashtable hints) {
+    Vector possibleFormats = hints == null ? null :
+        (Vector) hints.get(DecodeHintType.POSSIBLE_FORMATS);
+    boolean useCode39CheckDigit = hints != null &&
+        hints.get(DecodeHintType.ASSUME_CODE_39_CHECK_DIGIT) != null;
+    readers = new Vector();
+    if (possibleFormats != null) {
+      if (possibleFormats.contains(BarcodeFormat.EAN_13) ||
+          possibleFormats.contains(BarcodeFormat.UPC_A) ||
+          possibleFormats.contains(BarcodeFormat.EAN_8) ||
+          possibleFormats.contains(BarcodeFormat.UPC_E)) {
+        readers.addElement(new MultiFormatUPCEANReader(hints));
+      }
+      if (possibleFormats.contains(BarcodeFormat.CODE_39)) {
+        readers.addElement(new Code39Reader(useCode39CheckDigit));
+      }
+      if (possibleFormats.contains(BarcodeFormat.CODE_93)) {
+        readers.addElement(new Code93Reader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.CODE_128)) {
+        readers.addElement(new Code128Reader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.ITF)) {
+         readers.addElement(new ITFReader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.CODABAR)) {
+         readers.addElement(new CodaBarReader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.RSS14)) {
+         readers.addElement(new RSS14Reader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.RSS_EXPANDED)){
+        readers.addElement(new RSSExpandedReader());
+      }
+    }
+    if (readers.isEmpty()) {
+      readers.addElement(new MultiFormatUPCEANReader(hints));
+      readers.addElement(new Code39Reader());
+      //readers.addElement(new CodaBarReader());
+      readers.addElement(new Code93Reader());      
+      readers.addElement(new Code128Reader());
+      readers.addElement(new ITFReader());
+      readers.addElement(new RSS14Reader());      
+      readers.addElement(new RSSExpandedReader());      
+    }
+  }
+
+  public Result decodeRow(int rowNumber, BitArray row, Hashtable hints) throws NotFoundException {
+    int size = readers.size();
+    for (int i = 0; i < size; i++) {
+      OneDReader reader = (OneDReader) readers.elementAt(i);
+      try {
+        return reader.decodeRow(rowNumber, row, hints);
+      } catch (ReaderException re) {
+        // continue
+      }
+    }
+
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  public void reset() {
+    int size = readers.size();
+    for (int i = 0; i < size; i++) {
+      Reader reader = (Reader) readers.elementAt(i);
+      reader.reset();
+    }
+  }
+
+}

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

@@ -0,0 +1,113 @@
+/*
+ * 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.DecodeHintType;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Reader;
+import com.google.zxing.ReaderException;
+import com.google.zxing.Result;
+import com.google.zxing.common.BitArray;
+
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+ * <p>A reader that can read all available UPC/EAN formats. If a caller wants to try to
+ * read all such formats, it is most efficient to use this implementation rather than invoke
+ * individual readers.</p>
+ *
+ * @author Sean Owen
+ */
+public final class MultiFormatUPCEANReader extends OneDReader {
+
+  private final Vector readers;
+
+  public MultiFormatUPCEANReader(Hashtable hints) {
+    Vector possibleFormats = hints == null ? null :
+        (Vector) hints.get(DecodeHintType.POSSIBLE_FORMATS);
+    readers = new Vector();
+    if (possibleFormats != null) {
+      if (possibleFormats.contains(BarcodeFormat.EAN_13)) {
+        readers.addElement(new EAN13Reader());
+      } else if (possibleFormats.contains(BarcodeFormat.UPC_A)) {
+        readers.addElement(new UPCAReader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.EAN_8)) {
+        readers.addElement(new EAN8Reader());
+      }
+      if (possibleFormats.contains(BarcodeFormat.UPC_E)) {
+        readers.addElement(new UPCEReader());
+      }
+    }
+    if (readers.isEmpty()) {
+      readers.addElement(new EAN13Reader());
+      // UPC-A is covered by EAN-13
+      readers.addElement(new EAN8Reader());
+      readers.addElement(new UPCEReader());
+    }
+  }
+
+  public Result decodeRow(int rowNumber, BitArray row, Hashtable hints) throws NotFoundException {
+    // Compute this location once and reuse it on multiple implementations
+    int[] startGuardPattern = UPCEANReader.findStartGuardPattern(row);
+    int size = readers.size();
+    for (int i = 0; i < size; i++) {
+      UPCEANReader reader = (UPCEANReader) readers.elementAt(i);
+      Result result;
+      try {
+        result = reader.decodeRow(rowNumber, row, startGuardPattern, hints);
+      } catch (ReaderException re) {
+        continue;
+      }
+      // Special case: a 12-digit code encoded in UPC-A is identical to a "0"
+      // followed by those 12 digits encoded as EAN-13. Each will recognize such a code,
+      // UPC-A as a 12-digit string and EAN-13 as a 13-digit string starting with "0".
+      // Individually these are correct and their readers will both read such a code
+      // and correctly call it EAN-13, or UPC-A, respectively.
+      //
+      // In this case, if we've been looking for both types, we'd like to call it
+      // a UPC-A code. But for efficiency we only run the EAN-13 decoder to also read
+      // UPC-A. So we special case it here, and convert an EAN-13 result to a UPC-A
+      // result if appropriate.
+      //
+      // But, don't return UPC-A if UPC-A was not a requested format!
+      boolean ean13MayBeUPCA =
+          BarcodeFormat.EAN_13.equals(result.getBarcodeFormat()) &&
+          result.getText().charAt(0) == '0';
+      Vector possibleFormats = hints == null ? null : (Vector) hints.get(DecodeHintType.POSSIBLE_FORMATS);
+      boolean canReturnUPCA = possibleFormats == null || possibleFormats.contains(BarcodeFormat.UPC_A);
+
+      if (ean13MayBeUPCA && canReturnUPCA) {
+        return new Result(result.getText().substring(1), null, result.getResultPoints(), BarcodeFormat.UPC_A);
+      }
+      return result;
+    }
+
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  public void reset() {
+    int size = readers.size();
+    for (int i = 0; i < size; i++) {
+      Reader reader = (Reader) readers.elementAt(i);
+      reader.reset();
+    }
+  }
+
+}

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

@@ -0,0 +1,297 @@
+/*
+ * 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.BinaryBitmap;
+import com.google.zxing.ChecksumException;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.FormatException;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Reader;
+import com.google.zxing.ReaderException;
+import com.google.zxing.Result;
+import com.google.zxing.ResultMetadataType;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitArray;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+/**
+ * Encapsulates functionality and implementation that is common to all families
+ * of one-dimensional barcodes.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Sean Owen
+ */
+public abstract class OneDReader implements Reader {
+
+  protected static final int INTEGER_MATH_SHIFT = 8;
+  protected static final int PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
+
+  public Result decode(BinaryBitmap image) throws NotFoundException, FormatException {
+    return decode(image, null);
+  }
+
+  // Note that we don't try rotation without the try harder flag, even if rotation was supported.
+  public Result decode(BinaryBitmap image, Hashtable hints) throws NotFoundException, FormatException {
+    try {
+      return doDecode(image, hints);
+    } catch (NotFoundException nfe) {
+      boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
+      if (tryHarder && image.isRotateSupported()) {
+        BinaryBitmap rotatedImage = image.rotateCounterClockwise();
+        Result result = doDecode(rotatedImage, hints);
+        // Record that we found it rotated 90 degrees CCW / 270 degrees CW
+        Hashtable metadata = result.getResultMetadata();
+        int orientation = 270;
+        if (metadata != null && metadata.containsKey(ResultMetadataType.ORIENTATION)) {
+          // But if we found it reversed in doDecode(), add in that result here:
+          orientation = (orientation +
+              ((Integer) metadata.get(ResultMetadataType.ORIENTATION)).intValue()) % 360;
+        }
+        result.putMetadata(ResultMetadataType.ORIENTATION, new Integer(orientation));
+        // Update result points
+        ResultPoint[] points = result.getResultPoints();
+        int height = rotatedImage.getHeight();
+        for (int i = 0; i < points.length; i++) {
+          points[i] = new ResultPoint(height - points[i].getY() - 1, points[i].getX());
+        }
+        return result;
+      } else {
+        throw nfe;
+      }
+    }
+  }
+
+  public void reset() {
+    // do nothing
+  }
+
+  /**
+   * We're going to examine rows from the middle outward, searching alternately above and below the
+   * middle, and farther out each time. rowStep is the number of rows between each successive
+   * attempt above and below the middle. So we'd scan row middle, then middle - rowStep, then
+   * middle + rowStep, then middle - (2 * rowStep), etc.
+   * rowStep is bigger as the image is taller, but is always at least 1. We've somewhat arbitrarily
+   * decided that moving up and down by about 1/16 of the image is pretty good; we try more of the
+   * image if "trying harder".
+   *
+   * @param image The image to decode
+   * @param hints Any hints that were requested
+   * @return The contents of the decoded barcode
+   * @throws NotFoundException Any spontaneous errors which occur
+   */
+  private Result doDecode(BinaryBitmap image, Hashtable hints) throws NotFoundException {
+    int width = image.getWidth();
+    int height = image.getHeight();
+    BitArray row = new BitArray(width);
+
+    int middle = height >> 1;
+    boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
+    int rowStep = Math.max(1, height >> (tryHarder ? 8 : 5));
+    int maxLines;
+    if (tryHarder) {
+      maxLines = height; // Look at the whole image, not just the center
+    } else {
+      maxLines = 15; // 15 rows spaced 1/32 apart is roughly the middle half of the image
+    }
+
+    for (int x = 0; x < maxLines; x++) {
+
+      // Scanning from the middle out. Determine which row we're looking at next:
+      int rowStepsAboveOrBelow = (x + 1) >> 1;
+      boolean isAbove = (x & 0x01) == 0; // i.e. is x even?
+      int rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);
+      if (rowNumber < 0 || rowNumber >= height) {
+        // Oops, if we run off the top or bottom, stop
+        break;
+      }
+
+      // Estimate black point for this row and load it:
+      try {
+        row = image.getBlackRow(rowNumber, row);
+      } catch (NotFoundException nfe) {
+        continue;
+      }
+
+      // While we have the image data in a BitArray, it's fairly cheap to reverse it in place to
+      // handle decoding upside down barcodes.
+      for (int attempt = 0; attempt < 2; attempt++) {
+        if (attempt == 1) { // trying again?
+          row.reverse(); // reverse the row and continue
+          // This means we will only ever draw result points *once* in the life of this method
+          // since we want to avoid drawing the wrong points after flipping the row, and,
+          // don't want to clutter with noise from every single row scan -- just the scans
+          // that start on the center line.
+          if (hints != null && hints.containsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK)) {
+            Hashtable newHints = new Hashtable(); // Can't use clone() in J2ME
+            Enumeration hintEnum = hints.keys();
+            while (hintEnum.hasMoreElements()) {
+              Object key = hintEnum.nextElement();
+              if (!key.equals(DecodeHintType.NEED_RESULT_POINT_CALLBACK)) {
+                newHints.put(key, hints.get(key));
+              }
+            }
+            hints = newHints;
+          }
+        }
+        try {
+          // Look for a barcode
+          Result result = decodeRow(rowNumber, row, hints);
+          // We found our barcode
+          if (attempt == 1) {
+            // But it was upside down, so note that
+            result.putMetadata(ResultMetadataType.ORIENTATION, new Integer(180));
+            // And remember to flip the result points horizontally.
+            ResultPoint[] points = result.getResultPoints();
+            points[0] = new ResultPoint(width - points[0].getX() - 1, points[0].getY());
+            points[1] = new ResultPoint(width - points[1].getX() - 1, points[1].getY());
+          }
+          return result;
+        } catch (ReaderException re) {
+          // continue -- just couldn't decode this row
+        }
+      }
+    }
+
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  /**
+   * 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.
+   *
+   * @param row row to count from
+   * @param start offset into row to start at
+   * @param counters array into which to record counts
+   * @throws NotFoundException if counters cannot be filled entirely from row before running out
+   *  of pixels
+   */
+  protected static void recordPattern(BitArray row, int start, int[] counters) throws NotFoundException {
+    int numCounters = counters.length;
+    for (int i = 0; i < numCounters; i++) {
+      counters[i] = 0;
+    }
+    int end = row.getSize();
+    if (start >= end) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+    boolean isWhite = !row.get(start);
+    int counterPosition = 0;
+    int i = start;
+    while (i < end) {
+      boolean pixel = row.get(i);
+      if (pixel ^ isWhite) { // that is, exactly one is true
+        counters[counterPosition]++;
+      } else {
+        counterPosition++;
+        if (counterPosition == numCounters) {
+          break;
+        } else {
+          counters[counterPosition] = 1;
+          isWhite = !isWhite;
+        }
+      }
+      i++;
+    }
+    // If we read fully the last section of pixels and filled up our counters -- or filled
+    // the last counter but ran off the side of the image, OK. Otherwise, a problem.
+    if (!(counterPosition == numCounters || (counterPosition == numCounters - 1 && i == end))) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+  }
+
+  protected static void recordPatternInReverse(BitArray row, int start, int[] counters)
+      throws NotFoundException {
+    // This could be more efficient I guess
+    int numTransitionsLeft = counters.length;
+    boolean last = row.get(start);
+    while (start > 0 && numTransitionsLeft >= 0) {
+      if (row.get(--start) != last) {
+        numTransitionsLeft--;
+        last = !last;
+      }
+    }
+    if (numTransitionsLeft >= 0) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+    recordPattern(row, start + 1, counters);
+  }
+
+  /**
+   * 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.
+   *
+   * @param counters observed counters
+   * @param pattern expected pattern
+   * @param maxIndividualVariance The most any counter can differ before we give up
+   * @return ratio of total variance between counters and pattern compared to total pattern size,
+   *  where the ratio has been multiplied by 256. So, 0 means no variance (perfect match); 256 means
+   *  the total variance between counters and patterns equals the pattern length, higher values mean
+   *  even more variance
+   */
+  protected static int patternMatchVariance(int[] counters, int[] pattern, int maxIndividualVariance) {
+    int numCounters = counters.length;
+    int total = 0;
+    int patternLength = 0;
+    for (int i = 0; i < numCounters; i++) {
+      total += counters[i];
+      patternLength += pattern[i];
+    }
+    if (total < patternLength) {
+      // If we don't even have one pixel per unit of bar width, assume this is too small
+      // to reliably match, so fail:
+      return Integer.MAX_VALUE;
+    }
+    // We're going to fake floating-point math in integers. We just need to use more bits.
+    // Scale up patternLength so that intermediate values below like scaledCounter will have
+    // more "significant digits"
+    int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+    maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+
+    int totalVariance = 0;
+    for (int x = 0; x < numCounters; x++) {
+      int counter = counters[x] << INTEGER_MATH_SHIFT;
+      int scaledPattern = pattern[x] * unitBarWidth;
+      int variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
+      if (variance > maxIndividualVariance) {
+        return Integer.MAX_VALUE;
+      }
+      totalVariance += variance;
+    }
+    return totalVariance / total;
+  }
+
+  /**
+   * <p>Attempts to decode a one-dimensional barcode format given a single row of
+   * an image.</p>
+   *
+   * @param rowNumber row number from top of the row
+   * @param row the black/white pixel data of the row
+   * @param hints decode hints
+   * @return {@link Result} containing encoded string and start/end of barcode
+   * @throws NotFoundException if an error occurs or barcode cannot be found
+   */
+  public abstract Result decodeRow(int rowNumber, BitArray row, Hashtable hints)
+      throws NotFoundException, ChecksumException, FormatException;
+
+}