rhodes 2.4.1 → 3.0.0.beta.1

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/datamatrix/decoder/Decoder.java

@@ -0,0 +1,134 @@
+/*
+ * 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.datamatrix.decoder;
+
+import com.google.zxing.ChecksumException;
+import com.google.zxing.FormatException;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.DecoderResult;
+import com.google.zxing.common.reedsolomon.GF256;
+import com.google.zxing.common.reedsolomon.ReedSolomonDecoder;
+import com.google.zxing.common.reedsolomon.ReedSolomonException;
+
+/**
+ * <p>The main class which implements Data Matrix Code decoding -- as opposed to locating and extracting
+ * the Data Matrix Code from an image.</p>
+ *
+ * @author bbrown@google.com (Brian Brown)
+ */
+public final class Decoder {
+
+  private final ReedSolomonDecoder rsDecoder;
+
+  public Decoder() {
+    rsDecoder = new ReedSolomonDecoder(GF256.DATA_MATRIX_FIELD);
+  }
+
+  /**
+   * <p>Convenience method that can decode a Data Matrix Code represented as a 2D array of booleans.
+   * "true" is taken to mean a black module.</p>
+   *
+   * @param image booleans representing white/black Data Matrix Code modules
+   * @return text and bytes encoded within the Data Matrix Code
+   * @throws FormatException if the Data Matrix Code cannot be decoded
+   * @throws ChecksumException if error correction fails
+   */
+  public DecoderResult decode(boolean[][] image) throws FormatException, ChecksumException {
+    int dimension = image.length;
+    BitMatrix bits = new BitMatrix(dimension);
+    for (int i = 0; i < dimension; i++) {
+      for (int j = 0; j < dimension; j++) {
+        if (image[i][j]) {
+          bits.set(j, i);
+        }
+      }
+    }
+    return decode(bits);
+  }
+
+  /**
+   * <p>Decodes a Data Matrix Code represented as a {@link BitMatrix}. A 1 or "true" is taken
+   * to mean a black module.</p>
+   *
+   * @param bits booleans representing white/black Data Matrix Code modules
+   * @return text and bytes encoded within the Data Matrix Code
+   * @throws FormatException if the Data Matrix Code cannot be decoded
+   * @throws ChecksumException if error correction fails
+   */
+  public DecoderResult decode(BitMatrix bits) throws FormatException, ChecksumException {
+
+    // Construct a parser and read version, error-correction level
+    BitMatrixParser parser = new BitMatrixParser(bits);
+    Version version = parser.readVersion(bits);
+
+    // Read codewords
+    byte[] codewords = parser.readCodewords();
+    // Separate into data blocks
+    DataBlock[] dataBlocks = DataBlock.getDataBlocks(codewords, version);
+
+    // Count total number of data bytes
+    int totalBytes = 0;
+    for (int i = 0; i < dataBlocks.length; i++) {
+      totalBytes += dataBlocks[i].getNumDataCodewords();
+    }
+    byte[] resultBytes = new byte[totalBytes];
+    int resultOffset = 0;
+
+    // Error-correct and copy data blocks together into a stream of bytes
+    for (int j = 0; j < dataBlocks.length; j++) {
+      DataBlock dataBlock = dataBlocks[j];
+      byte[] codewordBytes = dataBlock.getCodewords();
+      int numDataCodewords = dataBlock.getNumDataCodewords();
+      correctErrors(codewordBytes, numDataCodewords);
+      for (int i = 0; i < numDataCodewords; i++) {
+        resultBytes[resultOffset++] = codewordBytes[i];
+      }
+    }
+
+    // Decode the contents of that stream of bytes
+    return DecodedBitStreamParser.decode(resultBytes);
+  }
+
+  /**
+   * <p>Given data and error-correction codewords received, possibly corrupted by errors, attempts to
+   * correct the errors in-place using Reed-Solomon error correction.</p>
+   *
+   * @param codewordBytes data and error correction codewords
+   * @param numDataCodewords number of codewords that are data bytes
+   * @throws ChecksumException if error correction fails
+   */
+  private void correctErrors(byte[] codewordBytes, int numDataCodewords) throws ChecksumException {
+    int numCodewords = codewordBytes.length;
+    // First read into an array of ints
+    int[] codewordsInts = new int[numCodewords];
+    for (int i = 0; i < numCodewords; i++) {
+      codewordsInts[i] = codewordBytes[i] & 0xFF;
+    }
+    int numECCodewords = codewordBytes.length - numDataCodewords;
+    try {
+      rsDecoder.decode(codewordsInts, numECCodewords);
+    } catch (ReedSolomonException rse) {
+      throw ChecksumException.getChecksumInstance();
+    }
+    // Copy back into array of bytes -- only need to worry about the bytes that were data
+    // We don't care about errors in the error-correction codewords
+    for (int i = 0; i < numDataCodewords; i++) {
+      codewordBytes[i] = (byte) codewordsInts[i];
+    }
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/datamatrix/decoder/Version.java

@@ -0,0 +1,242 @@
+/*
+ * 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.datamatrix.decoder;
+
+import com.google.zxing.FormatException;
+
+/**
+ * The Version object encapsulates attributes about a particular
+ * size Data Matrix Code.
+ *
+ * @author bbrown@google.com (Brian Brown)
+ */
+public final class Version {
+
+  private static final Version[] VERSIONS = buildVersions();
+
+  private final int versionNumber;
+  private final int symbolSizeRows;
+  private final int symbolSizeColumns;
+  private final int dataRegionSizeRows;
+  private final int dataRegionSizeColumns;
+  private final ECBlocks ecBlocks;
+  private final int totalCodewords;
+
+  private Version(int versionNumber,
+                  int symbolSizeRows,
+                  int symbolSizeColumns,
+                  int dataRegionSizeRows,
+                  int dataRegionSizeColumns,
+                  ECBlocks ecBlocks) {
+    this.versionNumber = versionNumber;
+    this.symbolSizeRows = symbolSizeRows;
+    this.symbolSizeColumns = symbolSizeColumns;
+    this.dataRegionSizeRows = dataRegionSizeRows;
+    this.dataRegionSizeColumns = dataRegionSizeColumns;
+    this.ecBlocks = ecBlocks;
+    
+    // Calculate the total number of codewords
+    int total = 0;
+    int ecCodewords = ecBlocks.getECCodewords();
+    ECB[] ecbArray = ecBlocks.getECBlocks();
+    for (int i = 0; i < ecbArray.length; i++) {
+      ECB ecBlock = ecbArray[i];
+      total += ecBlock.getCount() * (ecBlock.getDataCodewords() + ecCodewords);
+    }
+    this.totalCodewords = total;
+  }
+
+  public int getVersionNumber() {
+    return versionNumber;
+  }
+
+  public int getSymbolSizeRows() {
+    return symbolSizeRows;
+  }
+  
+  public int getSymbolSizeColumns() {
+    return symbolSizeColumns;
+  }
+  
+  public int getDataRegionSizeRows() {
+    return dataRegionSizeRows;
+  }
+  
+  public int getDataRegionSizeColumns() {
+    return dataRegionSizeColumns;
+  }
+  
+  public int getTotalCodewords() {
+    return totalCodewords;
+  }
+  
+  ECBlocks getECBlocks() {
+    return ecBlocks;
+  }
+
+  /**
+   * <p>Deduces version information from Data Matrix dimensions.</p>
+   *
+   * @param numRows Number of rows in modules
+   * @param numColumns Number of columns in modules
+   * @return {@link Version} for a Data Matrix Code of those dimensions
+   * @throws FormatException if dimensions do correspond to a valid Data Matrix size
+   */
+  public static Version getVersionForDimensions(int numRows, int numColumns) throws FormatException {
+    if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {
+      throw FormatException.getFormatInstance();
+    }
+    
+    // TODO(bbrown): This is doing a linear search through the array of versions.
+    // If we interleave the rectangular versions with the square versions we could
+    // do a binary search.
+    int numVersions = VERSIONS.length;
+    for (int i = 0; i < numVersions; ++i){
+      Version version = VERSIONS[i];
+      if (version.symbolSizeRows == numRows && version.symbolSizeColumns == numColumns) {
+        return version;
+      }
+    }
+    
+    throw FormatException.getFormatInstance();
+  }
+
+  /**
+   * <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+   * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+   * each set of blocks. It also holds the number of error-correction codewords per block since it
+   * will be the same across all blocks within one version.</p>
+   */
+  static final class ECBlocks {
+    private final int ecCodewords;
+    private final ECB[] ecBlocks;
+
+    private ECBlocks(int ecCodewords, ECB ecBlocks) {
+      this.ecCodewords = ecCodewords;
+      this.ecBlocks = new ECB[] { ecBlocks };
+    }
+
+    private ECBlocks(int ecCodewords, ECB ecBlocks1, ECB ecBlocks2) {
+      this.ecCodewords = ecCodewords;
+      this.ecBlocks = new ECB[] { ecBlocks1, ecBlocks2 };
+    }
+
+    int getECCodewords() {
+      return ecCodewords;
+    }
+
+    ECB[] getECBlocks() {
+      return ecBlocks;
+    }
+  }
+
+  /**
+   * <p>Encapsualtes the parameters for one error-correction block in one symbol version.
+   * This includes the number of data codewords, and the number of times a block with these
+   * parameters is used consecutively in the Data Matrix code version's format.</p>
+   */
+  static final class ECB {
+    private final int count;
+    private final int dataCodewords;
+
+    private ECB(int count, int dataCodewords) {
+      this.count = count;
+      this.dataCodewords = dataCodewords;
+    }
+
+    int getCount() {
+      return count;
+    }
+
+    int getDataCodewords() {
+      return dataCodewords;
+    }
+  }
+
+  public String toString() {
+    return String.valueOf(versionNumber);
+  }
+
+  /**
+   * See ISO 16022:2006 5.5.1 Table 7
+   */
+  private static Version[] buildVersions() {
+    return new Version[]{
+        new Version(1, 10, 10, 8, 8,
+            new ECBlocks(5, new ECB(1, 3))),
+        new Version(2, 12, 12, 10, 10,
+            new ECBlocks(7, new ECB(1, 5))),
+        new Version(3, 14, 14, 12, 12,
+            new ECBlocks(10, new ECB(1, 8))),
+        new Version(4, 16, 16, 14, 14,
+            new ECBlocks(12, new ECB(1, 12))),
+        new Version(5, 18, 18, 16, 16,
+            new ECBlocks(14, new ECB(1, 18))),
+        new Version(6, 20, 20, 18, 18,
+            new ECBlocks(18, new ECB(1, 22))),
+        new Version(7, 22, 22, 20, 20,
+            new ECBlocks(20, new ECB(1, 30))),
+        new Version(8, 24, 24, 22, 22,
+            new ECBlocks(24, new ECB(1, 36))),
+        new Version(9, 26, 26, 24, 24,
+            new ECBlocks(28, new ECB(1, 44))),
+        new Version(10, 32, 32, 14, 14,
+            new ECBlocks(36, new ECB(1, 62))),
+        new Version(11, 36, 36, 16, 16,
+            new ECBlocks(42, new ECB(1, 86))),
+        new Version(12, 40, 40, 18, 18,
+            new ECBlocks(48, new ECB(1, 114))),
+        new Version(13, 44, 44, 20, 20,
+            new ECBlocks(56, new ECB(1, 144))),
+        new Version(14, 48, 48, 22, 22,
+            new ECBlocks(68, new ECB(1, 174))),
+        new Version(15, 52, 52, 24, 24,
+            new ECBlocks(42, new ECB(2, 102))),
+        new Version(16, 64, 64, 14, 14,
+            new ECBlocks(56, new ECB(2, 140))),
+        new Version(17, 72, 72, 16, 16,
+            new ECBlocks(36, new ECB(4, 92))),
+        new Version(18, 80, 80, 18, 18,
+            new ECBlocks(48, new ECB(4, 114))),
+        new Version(19, 88, 88, 20, 20,
+            new ECBlocks(56, new ECB(4, 144))),
+        new Version(20, 96, 96, 22, 22,
+            new ECBlocks(68, new ECB(4, 174))),
+        new Version(21, 104, 104, 24, 24,
+            new ECBlocks(56, new ECB(6, 136))),
+        new Version(22, 120, 120, 18, 18,
+            new ECBlocks(68, new ECB(6, 175))),
+        new Version(23, 132, 132, 20, 20,
+            new ECBlocks(62, new ECB(8, 163))),
+        new Version(24, 144, 144, 22, 22,
+            new ECBlocks(62, new ECB(8, 156), new ECB(2, 155))),
+        new Version(25, 8, 18, 6, 16,
+            new ECBlocks(7, new ECB(1, 5))),
+        new Version(26, 8, 32, 6, 14,
+            new ECBlocks(11, new ECB(1, 10))),
+        new Version(27, 12, 26, 10, 24,
+            new ECBlocks(14, new ECB(1, 16))),
+        new Version(28, 12, 36, 10, 16,
+            new ECBlocks(18, new ECB(1, 22))),
+        new Version(29, 16, 36, 10, 16,
+            new ECBlocks(24, new ECB(1, 32))),
+        new Version(30, 16, 48, 14, 22,
+            new ECBlocks(28, new ECB(1, 49)))
+    };
+  }
+
+}

data/lib/extensions/barcode/ext/barcode/platform/android/src/com/google/zxing/datamatrix/detector/Detector.java

@@ -0,0 +1,348 @@
+/*
+ * 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.datamatrix.detector;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.Collections;
+import com.google.zxing.common.Comparator;
+import com.google.zxing.common.DetectorResult;
+import com.google.zxing.common.GridSampler;
+import com.google.zxing.common.detector.WhiteRectangleDetector;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+ * <p>Encapsulates logic that can detect a Data Matrix Code in an image, even if the Data Matrix Code
+ * is rotated or skewed, or partially obscured.</p>
+ *
+ * @author Sean Owen
+ */
+public final class Detector {
+
+  // Trick to avoid creating new Integer objects below -- a sort of crude copy of
+  // the Integer.valueOf(int) optimization added in Java 5, not in J2ME
+  private static final Integer[] INTEGERS =
+      { new Integer(0), new Integer(1), new Integer(2), new Integer(3), new Integer(4) };
+  // No, can't use valueOf()
+
+  private final BitMatrix image;
+  private final WhiteRectangleDetector rectangleDetector;
+
+  public Detector(BitMatrix image) {
+    this.image = image;
+    rectangleDetector = new WhiteRectangleDetector(image);
+  }
+
+  /**
+   * <p>Detects a Data Matrix Code in an image.</p>
+   *
+   * @return {@link DetectorResult} encapsulating results of detecting a Data Matrix Code
+   * @throws NotFoundException if no Data Matrix Code can be found
+   */
+  public DetectorResult detect() throws NotFoundException {
+
+    ResultPoint[] cornerPoints = rectangleDetector.detect();
+    ResultPoint pointA = cornerPoints[0];
+    ResultPoint pointB = cornerPoints[1];
+    ResultPoint pointC = cornerPoints[2];
+    ResultPoint pointD = cornerPoints[3];
+
+    // Point A and D are across the diagonal from one another,
+    // as are B and C. Figure out which are the solid black lines
+    // by counting transitions
+    Vector transitions = new Vector(4);
+    transitions.addElement(transitionsBetween(pointA, pointB));
+    transitions.addElement(transitionsBetween(pointA, pointC));
+    transitions.addElement(transitionsBetween(pointB, pointD));
+    transitions.addElement(transitionsBetween(pointC, pointD));
+    Collections.insertionSort(transitions, new ResultPointsAndTransitionsComparator());
+
+    // Sort by number of transitions. First two will be the two solid sides; last two
+    // will be the two alternating black/white sides
+    ResultPointsAndTransitions lSideOne = (ResultPointsAndTransitions) transitions.elementAt(0);
+    ResultPointsAndTransitions lSideTwo = (ResultPointsAndTransitions) transitions.elementAt(1);
+
+    // Figure out which point is their intersection by tallying up the number of times we see the
+    // endpoints in the four endpoints. One will show up twice.
+    Hashtable pointCount = new Hashtable();
+    increment(pointCount, lSideOne.getFrom());
+    increment(pointCount, lSideOne.getTo());
+    increment(pointCount, lSideTwo.getFrom());
+    increment(pointCount, lSideTwo.getTo());
+
+    ResultPoint maybeTopLeft = null;
+    ResultPoint bottomLeft = null;
+    ResultPoint maybeBottomRight = null;
+    Enumeration points = pointCount.keys();
+    while (points.hasMoreElements()) {
+      ResultPoint point = (ResultPoint) points.nextElement();
+      Integer value = (Integer) pointCount.get(point);
+      if (value.intValue() == 2) {
+        bottomLeft = point; // this is definitely the bottom left, then -- end of two L sides
+      } else {
+        // Otherwise it's either top left or bottom right -- just assign the two arbitrarily now
+        if (maybeTopLeft == null) {
+          maybeTopLeft = point;
+        } else {
+          maybeBottomRight = point;
+        }
+      }
+    }
+
+    if (maybeTopLeft == null || bottomLeft == null || maybeBottomRight == null) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    // Bottom left is correct but top left and bottom right might be switched
+    ResultPoint[] corners = { maybeTopLeft, bottomLeft, maybeBottomRight };
+    // Use the dot product trick to sort them out
+    ResultPoint.orderBestPatterns(corners);
+
+    // Now we know which is which:
+    ResultPoint bottomRight = corners[0];
+    bottomLeft = corners[1];
+    ResultPoint topLeft = corners[2];
+
+    // Which point didn't we find in relation to the "L" sides? that's the top right corner
+    ResultPoint topRight;
+    if (!pointCount.containsKey(pointA)) {
+      topRight = pointA;
+    } else if (!pointCount.containsKey(pointB)) {
+      topRight = pointB;
+    } else if (!pointCount.containsKey(pointC)) {
+      topRight = pointC;
+    } else {
+      topRight = pointD;
+    }
+
+    // Next determine the dimension by tracing along the top or right side and counting black/white
+    // transitions. Since we start inside a black module, we should see a number of transitions
+    // equal to 1 less than the code dimension. Well, actually 2 less, because we are going to
+    // end on a black module:
+
+    // The top right point is actually the corner of a module, which is one of the two black modules
+    // adjacent to the white module at the top right. Tracing to that corner from either the top left
+    // or bottom right should work here.
+    int dimension = Math.min(transitionsBetween(topLeft, topRight).getTransitions(),
+                             transitionsBetween(bottomRight, topRight).getTransitions());
+    if ((dimension & 0x01) == 1) {
+      // it can't be odd, so, round... up?
+      dimension++;
+    }
+    dimension += 2;
+
+    //correct top right point to match the white module
+    ResultPoint correctedTopRight = correctTopRight(bottomLeft, bottomRight, topLeft, topRight, dimension);
+    if (correctedTopRight == null){
+    	correctedTopRight = topRight;
+    }
+
+    //We redetermine the dimension using the corrected top right point
+    int dimension2 = Math.max(transitionsBetween(topLeft, correctedTopRight).getTransitions(),
+                              transitionsBetween(bottomRight, correctedTopRight).getTransitions());
+    dimension2++;
+    if ((dimension2 & 0x01) == 1) {
+      dimension2++;
+    }
+
+    BitMatrix bits = sampleGrid(image, topLeft, bottomLeft, bottomRight, correctedTopRight, dimension2);
+
+    return new DetectorResult(bits, new ResultPoint[]{topLeft, bottomLeft, bottomRight, correctedTopRight});
+  }
+
+  /**
+   * Calculates the position of the white top right module using the output of the rectangle detector
+   */
+  private ResultPoint correctTopRight(ResultPoint bottomLeft,
+                                      ResultPoint bottomRight,
+                                      ResultPoint topLeft,
+                                      ResultPoint topRight,
+                                      int dimension) {
+		
+		float corr = distance(bottomLeft, bottomRight) / (float)dimension;
+		int norm = distance(topLeft, topRight);
+		float cos = (topRight.getX() - topLeft.getX()) / norm;
+		float sin = (topRight.getY() - topLeft.getY()) / norm;
+		
+		ResultPoint c1 = new ResultPoint(topRight.getX()+corr*cos, topRight.getY()+corr*sin);
+	
+		corr = distance(bottomLeft, bottomRight) / (float)dimension;
+		norm = distance(bottomRight, topRight);
+		cos = (topRight.getX() - bottomRight.getX()) / norm;
+		sin = (topRight.getY() - bottomRight.getY()) / norm;
+		
+		ResultPoint c2 = new ResultPoint(topRight.getX()+corr*cos, topRight.getY()+corr*sin);
+
+		if (!isValid(c1)){
+			if (isValid(c2)){
+				return c2;
+			}
+			return null;
+		} else if (!isValid(c2)){
+			return c1;
+		}
+		
+		int l1 = Math.abs(transitionsBetween(topLeft, c1).getTransitions() - transitionsBetween(bottomRight, c1).getTransitions());
+		int l2 = Math.abs(transitionsBetween(topLeft, c2).getTransitions() - transitionsBetween(bottomRight, c2).getTransitions());
+		
+		if (l1 <= l2){
+			return c1;
+		}
+		
+		return c2;
+  }
+
+  private boolean isValid(ResultPoint p) {
+	  return (p.getX() >= 0 && p.getX() < image.width && p.getY() > 0 && p.getY() < image.height);
+  }
+
+  /**
+   * 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);
+  }
+
+// L2 distance
+  private static int distance(ResultPoint a, ResultPoint b) {
+    return round((float) Math.sqrt((a.getX() - b.getX())
+        * (a.getX() - b.getX()) + (a.getY() - b.getY())
+        * (a.getY() - b.getY())));
+  }
+
+  /**
+   * Increments the Integer associated with a key by one.
+   */
+  private static void increment(Hashtable table, ResultPoint key) {
+    Integer value = (Integer) table.get(key);
+    table.put(key, value == null ? INTEGERS[1] : INTEGERS[value.intValue() + 1]);
+  }
+
+  private static BitMatrix sampleGrid(BitMatrix image,
+                                      ResultPoint topLeft,
+                                      ResultPoint bottomLeft,
+                                      ResultPoint bottomRight,
+                                      ResultPoint topRight,
+                                      int dimension) throws NotFoundException {
+
+    GridSampler sampler = GridSampler.getInstance();
+
+    return sampler.sampleGrid(image,
+                              dimension,
+                              0.5f,
+                              0.5f,
+                              dimension - 0.5f,
+                              0.5f,
+                              dimension - 0.5f,
+                              dimension - 0.5f,
+                              0.5f,
+                              dimension - 0.5f,
+                              topLeft.getX(),
+                              topLeft.getY(),
+                              topRight.getX(),
+                              topRight.getY(),
+                              bottomRight.getX(),
+                              bottomRight.getY(),
+                              bottomLeft.getX(),
+                              bottomLeft.getY());
+  }
+
+  /**
+   * Counts the number of black/white transitions between two points, using something like Bresenham's algorithm.
+   */
+  private ResultPointsAndTransitions transitionsBetween(ResultPoint from, ResultPoint to) {
+    // See QR Code Detector, sizeOfBlackWhiteBlackRun()
+    int fromX = (int) from.getX();
+    int fromY = (int) from.getY();
+    int toX = (int) to.getX();
+    int toY = (int) to.getY();
+    boolean steep = Math.abs(toY - fromY) > Math.abs(toX - fromX);
+    if (steep) {
+      int temp = fromX;
+      fromX = fromY;
+      fromY = temp;
+      temp = toX;
+      toX = toY;
+      toY = temp;
+    }
+
+    int dx = Math.abs(toX - fromX);
+    int dy = Math.abs(toY - fromY);
+    int error = -dx >> 1;
+    int ystep = fromY < toY ? 1 : -1;
+    int xstep = fromX < toX ? 1 : -1;
+    int transitions = 0;
+    boolean inBlack = image.get(steep ? fromY : fromX, steep ? fromX : fromY);
+    for (int x = fromX, y = fromY; x != toX; x += xstep) {
+      boolean isBlack = image.get(steep ? y : x, steep ? x : y);
+      if (isBlack != inBlack) {
+        transitions++;
+        inBlack = isBlack;
+      }
+      error += dy;
+      if (error > 0) {
+        if (y == toY) {
+          break;
+        }
+        y += ystep;
+        error -= dx;
+      }
+    }
+    return new ResultPointsAndTransitions(from, to, transitions);
+  }
+
+  /**
+   * Simply encapsulates two points and a number of transitions between them.
+   */
+  private static class ResultPointsAndTransitions {
+    private final ResultPoint from;
+    private final ResultPoint to;
+    private final int transitions;
+    private ResultPointsAndTransitions(ResultPoint from, ResultPoint to, int transitions) {
+      this.from = from;
+      this.to = to;
+      this.transitions = transitions;
+    }
+    public ResultPoint getFrom() {
+      return from;
+    }
+    public ResultPoint getTo() {
+      return to;
+    }
+    public int getTransitions() {
+      return transitions;
+    }
+    public String toString() {
+      return from + "/" + to + '/' + transitions;
+    }
+  }
+
+  /**
+   * Orders ResultPointsAndTransitions by number of transitions, ascending.
+   */
+  private static class ResultPointsAndTransitionsComparator implements Comparator {
+    public int compare(Object o1, Object o2) {
+      return ((ResultPointsAndTransitions) o1).getTransitions() - ((ResultPointsAndTransitions) o2).getTransitions();
+    }
+  }
+
+}