rhodes 2.4.1 → 3.0.0.beta.1

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

@@ -0,0 +1,316 @@
+/*
+ * 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.common.detector;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region. By keeping track of the
+ * last black points it encountered, it determines the corners of the barcode.
+ * </p>
+ *
+ * @author David Olivier
+ */
+public final class WhiteRectangleDetector {
+
+  private static final int INIT_SIZE = 40;
+  private static final int CORR = 1;
+
+  private final BitMatrix image;
+  private final int height;
+  private final int width;
+
+  public WhiteRectangleDetector(BitMatrix image) {
+    this.image = image;
+    height = image.getHeight();
+    width = image.getWidth();
+  }
+
+  /**
+   * <p>
+   * Detects a candidate barcode-like rectangular region within an image. It
+   * starts around the center of the image, increases the size of the candidate
+   * region until it finds a white rectangular region.
+   * </p>
+   *
+   * @return {@link ResultPoint}[] describing the corners of the rectangular
+   *         region. The first and last points are opposed on the diagonal, as
+   *         are the second and third. The first point will be the topmost
+   *         point and the last, the bottommost. The second point will be
+   *         leftmost and the third, the rightmost
+   * @throws NotFoundException if no Data Matrix Code can be found
+   */
+  public ResultPoint[] detect() throws NotFoundException {
+
+    int left = (width - INIT_SIZE) >> 1;
+    int right = (width + INIT_SIZE) >> 1;
+    int up = (height - INIT_SIZE) >> 1;
+    int down = (height + INIT_SIZE) >> 1;
+    boolean sizeExceeded = false;
+    boolean aBlackPointFoundOnBorder = true;
+    boolean atLeastOneBlackPointFoundOnBorder = false;
+
+    while (aBlackPointFoundOnBorder) {
+
+      aBlackPointFoundOnBorder = false;
+
+      // .....
+      // .   |
+      // .....
+      boolean rightBorderNotWhite = true;
+      while (rightBorderNotWhite && right < width) {
+        rightBorderNotWhite = containsBlackPoint(up, down, right, false);
+        if (rightBorderNotWhite) {
+          right++;
+          aBlackPointFoundOnBorder = true;
+        }
+      }
+
+      if (right >= width) {
+        sizeExceeded = true;
+        break;
+      }
+
+      // .....
+      // .   .
+      // .___.
+      boolean bottomBorderNotWhite = true;
+      while (bottomBorderNotWhite && down < height) {
+        bottomBorderNotWhite = containsBlackPoint(left, right, down, true);
+        if (bottomBorderNotWhite) {
+          down++;
+          aBlackPointFoundOnBorder = true;
+        }
+      }
+
+      if (down >= height) {
+        sizeExceeded = true;
+        break;
+      }
+
+      // .....
+      // |   .
+      // .....
+      boolean leftBorderNotWhite = true;
+      while (leftBorderNotWhite && left >= 0) {
+        leftBorderNotWhite = containsBlackPoint(up, down, left, false);
+        if (leftBorderNotWhite) {
+          left--;
+          aBlackPointFoundOnBorder = true;
+        }
+      }
+
+      if (left < 0) {
+        sizeExceeded = true;
+        break;
+      }
+
+      // .___.
+      // .   .
+      // .....
+      boolean topBorderNotWhite = true;
+      while (topBorderNotWhite && up >= 0) {
+        topBorderNotWhite = containsBlackPoint(left, right, up, true);
+        if (topBorderNotWhite) {
+          up--;
+          aBlackPointFoundOnBorder = true;
+        }
+      }
+
+      if (up < 0) {
+        sizeExceeded = true;
+        break;
+      }
+
+      if (aBlackPointFoundOnBorder) {
+        atLeastOneBlackPointFoundOnBorder = true;
+      }
+
+    }
+
+    if (!sizeExceeded && atLeastOneBlackPointFoundOnBorder) {
+
+      int maxSize = right - left;
+
+      ResultPoint z = null;
+      for (int i = 1; i < maxSize; i++) {
+        z = getBlackPointOnSegment(left, down - i, left + i, down);
+        if (z != null) {
+          break;
+        }
+      }
+
+      if (z == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      ResultPoint t = null;
+      //go down right
+      for (int i = 1; i < maxSize; i++) {
+        t = getBlackPointOnSegment(left, up + i, left + i, up);
+        if (t != null) {
+          break;
+        }
+      }
+
+      if (t == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      ResultPoint x = null;
+      //go down left
+      for (int i = 1; i < maxSize; i++) {
+        x = getBlackPointOnSegment(right, up + i, right - i, up);
+        if (x != null) {
+          break;
+        }
+      }
+
+      if (x == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      ResultPoint y = null;
+      //go up left
+      for (int i = 1; i < maxSize; i++) {
+        y = getBlackPointOnSegment(right, down - i, right - i, down);
+        if (y != null) {
+          break;
+        }
+      }
+
+      if (y == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      return centerEdges(y, z, x, t);
+
+    } else {
+      throw NotFoundException.getNotFoundInstance();
+    }
+  }
+
+  /**
+   * Ends up being a bit faster than Math.round(). This merely rounds its
+   * argument to the nearest int, where x.5 rounds up.
+   */
+  private static int round(float d) {
+    return (int) (d + 0.5f);
+  }
+
+  private ResultPoint getBlackPointOnSegment(float aX, float aY, float bX, float bY) {
+    int dist = distanceL2(aX, aY, bX, bY);
+    float xStep = (bX - aX) / dist;
+    float yStep = (bY - aY) / dist;
+
+    for (int i = 0; i < dist; i++) {
+      int x = round(aX + i * xStep);
+      int y = round(aY + i * yStep);
+      if (image.get(x, y)) {
+        return new ResultPoint(x, y);
+      }
+    }
+    return null;
+  }
+
+  private static int distanceL2(float aX, float aY, float bX, float bY) {
+    float xDiff = aX - bX;
+    float yDiff = aY - bY;
+    return round((float) Math.sqrt(xDiff * xDiff + yDiff * yDiff));
+  }
+
+  /**
+   * recenters the points of a constant distance towards the center
+   *
+   * @param y bottom most point
+   * @param z left most point
+   * @param x right most point
+   * @param t top most point
+   * @return {@link ResultPoint}[] describing the corners of the rectangular
+   *         region. The first and last points are opposed on the diagonal, as
+   *         are the second and third. The first point will be the topmost
+   *         point and the last, the bottommost. The second point will be
+   *         leftmost and the third, the rightmost
+   */
+  private ResultPoint[] centerEdges(ResultPoint y, ResultPoint z,
+                                    ResultPoint x, ResultPoint t) {
+
+    //
+    //       t            t
+    //  z                      x
+    //        x    OR    z
+    //   y                    y
+    //
+
+    float yi = y.getX();
+    float yj = y.getY();
+    float zi = z.getX();
+    float zj = z.getY();
+    float xi = x.getX();
+    float xj = x.getY();
+    float ti = t.getX();
+    float tj = t.getY();
+
+    if (yi < width / 2) {
+      return new ResultPoint[]{
+          new ResultPoint(ti - CORR, tj + CORR),
+          new ResultPoint(zi + CORR, zj + CORR),
+          new ResultPoint(xi - CORR, xj - CORR),
+          new ResultPoint(yi + CORR, yj - CORR)};
+    } else {
+      return new ResultPoint[]{
+          new ResultPoint(ti + CORR, tj + CORR),
+          new ResultPoint(zi + CORR, zj - CORR),
+          new ResultPoint(xi - CORR, xj + CORR),
+          new ResultPoint(yi - CORR, yj - CORR)};
+    }
+  }
+
+  /**
+   * Determines whether a segment contains a black point
+   *
+   * @param a          min value of the scanned coordinate
+   * @param b          max value of the scanned coordinate
+   * @param fixed      value of fixed coordinate
+   * @param horizontal set to true if scan must be horizontal, false if vertical
+   * @return true if a black point has been found, else false.
+   */
+  private boolean containsBlackPoint(int a, int b, int fixed, boolean horizontal) {
+
+    if (horizontal) {
+      for (int x = a; x <= b; x++) {
+        if (image.get(x, fixed)) {
+          return true;
+        }
+      }
+    } else {
+      for (int y = a; y <= b; y++) {
+        if (image.get(fixed, y)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+}

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

@@ -0,0 +1,139 @@
+/*
+ * 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.reedsolomon;
+
+/**
+ * <p>This class contains utility methods for performing mathematical operations over
+ * the Galois Field GF(256). Operations use a given primitive polynomial in calculations.</p>
+ *
+ * <p>Throughout this package, elements of GF(256) are represented as an <code>int</code>
+ * for convenience and speed (but at the cost of memory).
+ * Only the bottom 8 bits are really used.</p>
+ *
+ * @author Sean Owen
+ */
+public final class GF256 {
+
+  public static final GF256 QR_CODE_FIELD = new GF256(0x011D); // x^8 + x^4 + x^3 + x^2 + 1
+  public static final GF256 DATA_MATRIX_FIELD = new GF256(0x012D); // x^8 + x^5 + x^3 + x^2 + 1
+
+  private final int[] expTable;
+  private final int[] logTable;
+  private final GF256Poly zero;
+  private final GF256Poly one;
+
+  /**
+   * Create a representation of GF(256) using the given primitive polynomial.
+   *
+   * @param primitive irreducible polynomial whose coefficients are represented by
+   *  the bits of an int, where the least-significant bit represents the constant
+   *  coefficient
+   */
+  private GF256(int primitive) {
+    expTable = new int[256];
+    logTable = new int[256];
+    int x = 1;
+    for (int i = 0; i < 256; i++) {
+      expTable[i] = x;
+      x <<= 1; // x = x * 2; we're assuming the generator alpha is 2
+      if (x >= 0x100) {
+        x ^= primitive;
+      }
+    }
+    for (int i = 0; i < 255; i++) {
+      logTable[expTable[i]] = i;
+    }
+    // logTable[0] == 0 but this should never be used
+    zero = new GF256Poly(this, new int[]{0});
+    one = new GF256Poly(this, new int[]{1});
+  }
+
+  GF256Poly getZero() {
+    return zero;
+  }
+
+  GF256Poly getOne() {
+    return one;
+  }
+
+  /**
+   * @return the monomial representing coefficient * x^degree
+   */
+  GF256Poly buildMonomial(int degree, int coefficient) {
+    if (degree < 0) {
+      throw new IllegalArgumentException();
+    }
+    if (coefficient == 0) {
+      return zero;
+    }
+    int[] coefficients = new int[degree + 1];
+    coefficients[0] = coefficient;
+    return new GF256Poly(this, coefficients);
+  }
+
+  /**
+   * Implements both addition and subtraction -- they are the same in GF(256).
+   *
+   * @return sum/difference of a and b
+   */
+  static int addOrSubtract(int a, int b) {
+    return a ^ b;
+  }
+
+  /**
+   * @return 2 to the power of a in GF(256)
+   */
+  int exp(int a) {
+    return expTable[a];
+  }
+
+  /**
+   * @return base 2 log of a in GF(256)
+   */
+  int log(int a) {
+    if (a == 0) {
+      throw new IllegalArgumentException();
+    }
+    return logTable[a];
+  }
+
+  /**
+   * @return multiplicative inverse of a
+   */
+  int inverse(int a) {
+    if (a == 0) {
+      throw new ArithmeticException();
+    }
+    return expTable[255 - logTable[a]];
+  }
+
+  /**
+   * @param a
+   * @param b
+   * @return product of a and b in GF(256)
+   */
+  int multiply(int a, int b) {
+    if (a == 0 || b == 0) {
+      return 0;
+    }
+    int logSum = logTable[a] + logTable[b];
+    // index is a sped-up alternative to logSum % 255 since sum
+    // is in [0,510]. Thanks to jmsachs for the idea
+    return expTable[(logSum & 0xFF) + (logSum >>> 8)];
+  }
+
+}