rhodes 2.4.1 → 3.0.0.beta.1

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/BitSource.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2007 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.common;
+
+/**
+ * <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.</p>
+ *
+ * <p>This class is thread-safe but not reentrant. Unless the caller modifies the bytes array
+ * it passed in, in which case all bets are off.</p>
+ *
+ * @author Sean Owen
+ */
+public final class BitSource {
+
+  private final byte[] bytes;
+  private int byteOffset;
+  private int bitOffset;
+
+  /**
+   * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+   * Bits are read within a byte from most-significant to least-significant bit.
+   */
+  public BitSource(byte[] bytes) {
+    this.bytes = bytes;
+  }
+
+  /**
+   * @param numBits number of bits to read
+   * @return int representing the bits read. The bits will appear as the least-significant
+   *         bits of the int
+   * @throws IllegalArgumentException if numBits isn't in [1,32]
+   */
+  public int readBits(int numBits) {
+    if (numBits < 1 || numBits > 32) {
+      throw new IllegalArgumentException();
+    }
+
+    int result = 0;
+
+    // First, read remainder from current byte
+    if (bitOffset > 0) {
+      int bitsLeft = 8 - bitOffset;
+      int toRead = numBits < bitsLeft ? numBits : bitsLeft;
+      int bitsToNotRead = bitsLeft - toRead;
+      int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
+      result = (bytes[byteOffset] & mask) >> bitsToNotRead;
+      numBits -= toRead;
+      bitOffset += toRead;
+      if (bitOffset == 8) {
+        bitOffset = 0;
+        byteOffset++;
+      }
+    }
+
+    // Next read whole bytes
+    if (numBits > 0) {
+      while (numBits >= 8) {
+        result = (result << 8) | (bytes[byteOffset] & 0xFF);
+        byteOffset++;
+        numBits -= 8;
+      }
+
+      // Finally read a partial byte
+      if (numBits > 0) {
+        int bitsToNotRead = 8 - numBits;
+        int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
+        result = (result << numBits) | ((bytes[byteOffset] & mask) >> bitsToNotRead);
+        bitOffset += numBits;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * @return number of bits that can be read successfully
+   */
+  public int available() {
+    return 8 * (bytes.length - byteOffset) - bitOffset;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/CharacterSetECI.java

@@ -0,0 +1,110 @@
+/*
+ * 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.common;
+
+import java.util.Hashtable;
+
+/**
+ * Encapsulates a Character Set ECI, according to "Extended Channel Interpretations" 5.3.1.1
+ * of ISO 18004.
+ *
+ * @author Sean Owen
+ */
+public final class CharacterSetECI extends ECI {
+
+  private static Hashtable VALUE_TO_ECI;
+  private static Hashtable NAME_TO_ECI;
+
+  private static void initialize() {
+    VALUE_TO_ECI = new Hashtable(29);
+    NAME_TO_ECI = new Hashtable(29);
+    // TODO figure out if these values are even right!
+    addCharacterSet(0, "Cp437");
+    addCharacterSet(1, new String[] {"ISO8859_1", "ISO-8859-1"});
+    addCharacterSet(2, "Cp437");
+    addCharacterSet(3, new String[] {"ISO8859_1", "ISO-8859-1"});
+    addCharacterSet(4, "ISO8859_2");
+    addCharacterSet(5, "ISO8859_3");
+    addCharacterSet(6, "ISO8859_4");
+    addCharacterSet(7, "ISO8859_5");
+    addCharacterSet(8, "ISO8859_6");
+    addCharacterSet(9, "ISO8859_7");
+    addCharacterSet(10, "ISO8859_8");
+    addCharacterSet(11, "ISO8859_9");
+    addCharacterSet(12, "ISO8859_10");
+    addCharacterSet(13, "ISO8859_11");
+    addCharacterSet(15, "ISO8859_13");
+    addCharacterSet(16, "ISO8859_14");
+    addCharacterSet(17, "ISO8859_15");
+    addCharacterSet(18, "ISO8859_16");
+    addCharacterSet(20, new String[] {"SJIS", "Shift_JIS"});
+  }
+
+  private final String encodingName;
+
+  private CharacterSetECI(int value, String encodingName) {
+    super(value);
+    this.encodingName = encodingName;
+  }
+
+  public String getEncodingName() {
+    return encodingName;
+  }
+
+  private static void addCharacterSet(int value, String encodingName) {
+    CharacterSetECI eci = new CharacterSetECI(value, encodingName);
+    VALUE_TO_ECI.put(new Integer(value), eci); // can't use valueOf
+    NAME_TO_ECI.put(encodingName, eci);
+  }
+
+  private static void addCharacterSet(int value, String[] encodingNames) {
+    CharacterSetECI eci = new CharacterSetECI(value, encodingNames[0]);
+    VALUE_TO_ECI.put(new Integer(value), eci); // can't use valueOf
+    for (int i = 0; i < encodingNames.length; i++) {
+      NAME_TO_ECI.put(encodingNames[i], eci);
+    }
+  }
+
+  /**
+   * @param value character set ECI value
+   * @return {@link CharacterSetECI} representing ECI of given value, or null if it is legal but
+   *   unsupported
+   * @throws IllegalArgumentException if ECI value is invalid
+   */
+  public static CharacterSetECI getCharacterSetECIByValue(int value) {
+    if (VALUE_TO_ECI == null) {
+      initialize();
+    }
+    if (value < 0 || value >= 900) {
+      throw new IllegalArgumentException("Bad ECI value: " + value);
+    }
+    return (CharacterSetECI) VALUE_TO_ECI.get(new Integer(value));
+  }
+
+  /**
+   * @param name character set ECI encoding name
+   * @return {@link CharacterSetECI} representing ECI for character encoding, or null if it is legal
+   *   but unsupported
+   */
+  public static CharacterSetECI getCharacterSetECIByName(String name) {
+    if (NAME_TO_ECI == null) {
+      initialize();
+    }
+    return (CharacterSetECI) NAME_TO_ECI.get(name);
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/Collections.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2007 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.common;
+
+import java.util.Vector;
+
+/**
+ * <p>This is basically a substitute for <code>java.util.Collections</code>, which is not
+ * present in MIDP 2.0 / CLDC 1.1.</p>
+ *
+ * @author Sean Owen
+ */
+public final class Collections {
+
+  private Collections() {
+  }
+
+  /**
+   * Sorts its argument (destructively) using insert sort; in the context of this package
+   * insertion sort is simple and efficient given its relatively small inputs.
+   *
+   * @param vector vector to sort
+   * @param comparator comparator to define sort ordering
+   */
+  public static void insertionSort(Vector vector, Comparator comparator) {
+    int max = vector.size();
+    for (int i = 1; i < max; i++) {
+      Object value = vector.elementAt(i);
+      int j = i - 1;
+      Object valueB;
+      while (j >= 0 && comparator.compare((valueB = vector.elementAt(j)), value) > 0) {
+        vector.setElementAt(valueB, j + 1);
+        j--;
+      }
+      vector.setElementAt(value, j + 1);
+    }
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/Comparator.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2007 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.common;
+
+/**
+ * This is merely a clone of <code>Comparator</code> since it is not available in
+ * CLDC 1.1 / MIDP 2.0.
+ */
+public interface Comparator {
+
+  int compare(Object o1, Object o2);
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/DecoderResult.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2007 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.common;
+
+import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
+
+import java.util.Vector;
+
+/**
+ * <p>Encapsulates the result of decoding a matrix of bits. This typically
+ * applies to 2D barcode formats. For now it contains the raw bytes obtained,
+ * as well as a String interpretation of those bytes, if applicable.</p>
+ *
+ * @author Sean Owen
+ */
+public final class DecoderResult {
+
+  private final byte[] rawBytes;
+  private final String text;
+  private final Vector byteSegments;
+  private final ErrorCorrectionLevel ecLevel;
+
+  public DecoderResult(byte[] rawBytes, String text, Vector byteSegments, ErrorCorrectionLevel ecLevel) {
+    if (rawBytes == null && text == null) {
+      throw new IllegalArgumentException();
+    }
+    this.rawBytes = rawBytes;
+    this.text = text;
+    this.byteSegments = byteSegments;
+    this.ecLevel = ecLevel;
+  }
+
+  public byte[] getRawBytes() {
+    return rawBytes;
+  }
+
+  public String getText() {
+    return text;
+  }
+
+  public Vector getByteSegments() {
+    return byteSegments;
+  }
+
+  public ErrorCorrectionLevel getECLevel() {
+    return ecLevel;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/DefaultGridSampler.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2007 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.common;
+
+import com.google.zxing.NotFoundException;
+
+/**
+ * @author Sean Owen
+ */
+public final class DefaultGridSampler extends GridSampler {
+
+  public BitMatrix sampleGrid(BitMatrix image,
+                              int dimension,
+                              float p1ToX, float p1ToY,
+                              float p2ToX, float p2ToY,
+                              float p3ToX, float p3ToY,
+                              float p4ToX, float p4ToY,
+                              float p1FromX, float p1FromY,
+                              float p2FromX, float p2FromY,
+                              float p3FromX, float p3FromY,
+                              float p4FromX, float p4FromY) throws NotFoundException {
+
+    PerspectiveTransform transform = PerspectiveTransform.quadrilateralToQuadrilateral(
+        p1ToX, p1ToY, p2ToX, p2ToY, p3ToX, p3ToY, p4ToX, p4ToY,
+        p1FromX, p1FromY, p2FromX, p2FromY, p3FromX, p3FromY, p4FromX, p4FromY);
+
+    return sampleGrid(image, dimension, transform);
+  }
+
+  public BitMatrix sampleGrid(BitMatrix image,
+                              int dimension,
+                              PerspectiveTransform transform) throws NotFoundException {
+    BitMatrix bits = new BitMatrix(dimension);
+    float[] points = new float[dimension << 1];
+    for (int y = 0; y < dimension; y++) {
+      int max = points.length;
+      float iValue = (float) y + 0.5f;
+      for (int x = 0; x < max; x += 2) {
+        points[x] = (float) (x >> 1) + 0.5f;
+        points[x + 1] = iValue;
+      }
+      transform.transformPoints(points);
+      // Quick check to see if points transformed to something inside the image;
+      // sufficient to check the endpoints
+      checkAndNudgePoints(image, points);
+      try {
+        for (int x = 0; x < max; x += 2) {
+          if (image.get((int) points[x], (int) points[x + 1])) {
+            // Black(-ish) pixel
+            bits.set(x >> 1, y);
+          }
+        }
+      } catch (ArrayIndexOutOfBoundsException aioobe) {
+        // This feels wrong, but, sometimes if the finder patterns are misidentified, the resulting
+        // transform gets "twisted" such that it maps a straight line of points to a set of points
+        // whose endpoints are in bounds, but others are not. There is probably some mathematical
+        // way to detect this about the transformation that I don't know yet.
+        // This results in an ugly runtime exception despite our clever checks above -- can't have
+        // that. We could check each point's coordinates but that feels duplicative. We settle for
+        // catching and wrapping ArrayIndexOutOfBoundsException.
+        throw NotFoundException.getNotFoundInstance();
+      }
+    }
+    return bits;
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/common/DetectorResult.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2007 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.common;
+
+import com.google.zxing.ResultPoint;
+
+/**
+ * <p>Encapsulates the result of detecting a barcode in an image. This includes the raw
+ * matrix of black/white pixels corresponding to the barcode, and possibly points of interest
+ * in the image, like the location of finder patterns or corners of the barcode in the image.</p>
+ *
+ * @author Sean Owen
+ */
+public final class DetectorResult {
+
+  private final BitMatrix bits;
+  private final ResultPoint[] points;
+
+  public DetectorResult(BitMatrix bits, ResultPoint[] points) {
+    this.bits = bits;
+    this.points = points;
+  }
+
+  public BitMatrix getBits() {
+    return bits;
+  }
+
+  public ResultPoint[] getPoints() {
+    return points;
+  }
+
+}