qrscanner 0.1

data/ext/qrscanner/zxing/core/src/zxing/qrcode/detector/FinderPatternFinder.h

@@ -0,0 +1,69 @@
+#ifndef __FINDER_PATTERN_FINDER_H__
+#define __FINDER_PATTERN_FINDER_H__
+
+/*
+ *  FinderPatternFinder.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/qrcode/detector/FinderPattern.h>
+#include <zxing/qrcode/detector/FinderPatternInfo.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/ResultPointCallback.h>
+#include <vector>
+
+namespace zxing {
+
+class DecodeHints;
+
+namespace qrcode {
+
+class FinderPatternFinder {
+private:
+  static int CENTER_QUORUM;
+  static int MIN_SKIP;
+  static int MAX_MODULES;
+
+  Ref<BitMatrix> image_;
+  std::vector<Ref<FinderPattern> > possibleCenters_;
+  bool hasSkipped_;
+
+  Ref<ResultPointCallback> callback_;
+
+  /** stateCount must be int[5] */
+  static float centerFromEnd(int* stateCount, int end);
+  static bool foundPatternCross(int* stateCount);
+
+  float crossCheckVertical(size_t startI, size_t centerJ, int maxCount, int originalStateCountTotal);
+  float crossCheckHorizontal(size_t startJ, size_t centerI, int maxCount, int originalStateCountTotal);
+
+  /** stateCount must be int[5] */
+  bool handlePossibleCenter(int* stateCount, size_t i, size_t j);
+  int findRowSkip();
+  bool haveMultiplyConfirmedCenters();
+  std::vector<Ref<FinderPattern> > selectBestPatterns();
+  static std::vector<Ref<FinderPattern> > orderBestPatterns(std::vector<Ref<FinderPattern> > patterns);
+public:
+  static float distance(Ref<ResultPoint> p1, Ref<ResultPoint> p2);
+  FinderPatternFinder(Ref<BitMatrix> image, Ref<ResultPointCallback>const&);
+  Ref<FinderPatternInfo> find(DecodeHints const& hints);
+};
+}
+}
+
+#endif // __FINDER_PATTERN_FINDER_H__

data/ext/qrscanner/zxing/core/src/zxing/qrcode/detector/FinderPatternInfo.cpp

@@ -0,0 +1,41 @@
+/*
+ *  FinderPatternInfo.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 13/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/qrcode/detector/FinderPatternInfo.h>
+
+namespace zxing {
+namespace qrcode {
+
+FinderPatternInfo::FinderPatternInfo(std::vector<Ref<FinderPattern> > patternCenters) :
+    bottomLeft_(patternCenters[0]), topLeft_(patternCenters[1]), topRight_(patternCenters[2]) {
+}
+
+Ref<FinderPattern> FinderPatternInfo::getBottomLeft() {
+  return bottomLeft_;
+}
+Ref<FinderPattern> FinderPatternInfo::getTopLeft() {
+  return topLeft_;
+}
+Ref<FinderPattern> FinderPatternInfo::getTopRight() {
+  return topRight_;
+}
+
+}
+}

data/ext/qrscanner/zxing/core/src/zxing/qrcode/detector/FinderPatternInfo.h

@@ -0,0 +1,47 @@
+#ifndef __FINDER_PATTERN_INFO_H__
+#define __FINDER_PATTERN_INFO_H__
+
+/*
+ *  FinderPatternInfo.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/qrcode/detector/FinderPattern.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <vector>
+
+namespace zxing {
+namespace qrcode {
+
+class FinderPatternInfo : public Counted {
+private:
+  Ref<FinderPattern> bottomLeft_;
+  Ref<FinderPattern> topLeft_;
+  Ref<FinderPattern> topRight_;
+
+public:
+  FinderPatternInfo(std::vector<Ref<FinderPattern> > patternCenters);
+
+  Ref<FinderPattern> getBottomLeft();
+  Ref<FinderPattern> getTopLeft();
+  Ref<FinderPattern> getTopRight();
+};
+}
+}
+
+#endif // __FINDER_PATTERN_INFO_H__

data/ext/qrscanner/zxing/core/src/zxing/qrcode/detector/QREdgeDetector.cpp

@@ -0,0 +1,169 @@
+/*
+ *  QREdgeDetector.cpp
+ *  zxing
+ *
+ *  Created by Ralf Kistner on 7/12/2009.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/qrcode/detector/QREdgeDetector.h>
+#include <zxing/common/EdgeDetector.h>
+#include <cstdlib>
+
+using namespace std;
+
+namespace zxing {
+namespace qrcode {
+
+static const float patternEdgeThreshold = 2;
+static const int patternEdgeWidth = 3;
+static const float patternEdgeSearchRatio = 1.1;
+static const int patternEdgeSkip = 2;
+
+static const float accurateEdgeThreshold = 3.3;
+static const int accurateEdgeWidth = 7;
+static const int accurateEdgeSkip = 2;
+
+static Point guessLastPattern(Point topLeft, Point topRight, Point bottomLeft) {
+  return Point(topRight.x - topLeft.x + bottomLeft.x, topRight.y - topLeft.y + bottomLeft.y);
+}
+
+static Point rp(Ref<ResultPoint> rp) {
+  return Point(rp->getX(), rp->getY());
+}
+
+QREdgeDetector::QREdgeDetector(Ref<BitMatrix> image) : Detector(image) { }
+
+Ref<PerspectiveTransform> QREdgeDetector::createTransform(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref <
+      ResultPoint > bottomLeft, Ref<ResultPoint> alignmentPattern, int dimension) {
+
+  if(alignmentPattern == NULL) {
+    Point corner = findCorner(*Detector::getImage(), rp(topLeft), rp(topRight), rp(bottomLeft), dimension);
+    return get1CornerTransform(rp(topLeft), rp(topRight), rp(bottomLeft), corner, dimension);
+  } else {
+    return Detector::createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension);
+  }
+}
+
+
+
+
+Point QREdgeDetector::findCorner(const BitMatrix& image, Point topLeft, Point topRight, Point bottomLeft, int dimension) {
+  Point bottomRight = guessLastPattern(topLeft, topRight, bottomLeft);
+
+  Line bottomEst = findPatternEdge(image, bottomLeft, topLeft, bottomRight, false);
+  Line rightEst = findPatternEdge(image, topRight, topLeft, bottomRight, true);
+
+  //return EdgeDetector::intersection(bottomEst, rightEst);
+
+  Line bottom = EdgeDetector::findLine(image, bottomEst, false, accurateEdgeWidth, accurateEdgeThreshold, accurateEdgeSkip);
+  Line right = EdgeDetector::findLine(image, rightEst, true, accurateEdgeWidth, accurateEdgeThreshold, accurateEdgeSkip);
+
+
+  return EdgeDetector::intersection(bottom, right);
+}
+
+Line QREdgeDetector::findPatternEdge(const BitMatrix& image, Point pattern, Point opposite, Point direction, bool invert) {
+  Point start = endOfReverseBlackWhiteBlackRun(image, pattern, opposite);
+
+  float dx = pattern.x - start.x;
+  float dy = pattern.y - start.y;
+  float dist = sqrt(dx*dx + dy*dy);
+
+  float dirX = direction.x - pattern.x;
+  float dirY = direction.y - pattern.y;
+  float dirSize = sqrt(dirX*dirX + dirY*dirY);
+
+  float nx = dirX/dirSize;
+  float ny = dirY/dirSize;
+
+  float search = dist * patternEdgeSearchRatio;
+  Point a(start.x + nx*search, start.y + ny*search);
+  Point b(start.x - nx*search, start.y - ny*search);
+
+  return EdgeDetector::findLine(image, Line(a, b), invert, patternEdgeWidth, patternEdgeThreshold, patternEdgeSkip);
+}
+
+
+Ref<PerspectiveTransform> QREdgeDetector::get1CornerTransform(Point topLeft, Point topRight, Point bottomLeft, Point corner, int dimension) {
+  float dimMinusThree = (float) dimension - 3.5f;
+
+  Ref<PerspectiveTransform> transform(PerspectiveTransform::quadrilateralToQuadrilateral(3.5f, 3.5f, dimMinusThree, 3.5f, dimension,
+                                      dimension, 3.5f, dimMinusThree, topLeft.x, topLeft.y, topRight.x,
+                                      topRight.y, corner.x, corner.y, bottomLeft.x, bottomLeft.y));
+
+  return transform;
+}
+
+// Adapted from "sizeOfBlackWhiteBlackRun" in zxing::qrcode::Detector
+Point QREdgeDetector::endOfReverseBlackWhiteBlackRun(const BitMatrix& image, Point from, Point to) {
+  int fromX = (int)from.x;
+  int fromY = (int)from.y;
+  int toX = (int)to.x;
+  int toY = (int)to.y;
+
+  bool steep = abs(toY - fromY) > abs(toX - fromX);
+  if (steep) {
+    int temp = fromX;
+    fromX = fromY;
+    fromY = temp;
+    temp = toX;
+    toX = toY;
+    toY = temp;
+  }
+
+  int dx = abs(toX - fromX);
+  int dy = abs(toY - fromY);
+  int error = -dx >> 1;
+  int ystep = fromY < toY ? -1 : 1;
+  int xstep = fromX < toX ? -1 : 1;
+  int state = 0; // In black pixels, looking for white, first or second time
+
+  // In case there are no points, prepopulate to from
+  int realX = fromX;
+  int realY = fromY;
+  for (int x = fromX, y = fromY; x != toX; x += xstep) {
+    realX = steep ? y : x;
+    realY = steep ? x : y;
+
+    if(realX < 0 || realY < 0 || realX >= (int)image.getWidth() || realY >= (int)image.getHeight())
+      break;
+
+    if (state == 1) { // In white pixels, looking for black
+      if (image.get(realX, realY)) {
+        state++;
+      }
+    } else {
+      if (!image.get(realX, realY)) {
+        state++;
+      }
+    }
+
+    if (state == 3) { // Found black, white, black, and stumbled back onto white; done
+      return Point(realX, realY);
+    }
+    error += dy;
+    if (error > 0) {
+      y += ystep;
+      error -= dx;
+    }
+  }
+
+  // B-W-B run not found, return the last point visited.
+  return Point(realX, realY);
+}
+
+} // namespace qrcode
+} // namespace zxing

data/ext/qrscanner/zxing/core/src/zxing/qrcode/detector/QREdgeDetector.h

@@ -0,0 +1,48 @@
+#ifndef __QREDGEDETECTOR_H__
+#define __QREDGEDETECTOR_H__
+/*
+ *  QREdgeDetector.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+
+
+#include <zxing/qrcode/detector/Detector.h>
+#include <zxing/common/Point.h>
+
+namespace zxing {
+namespace qrcode {
+
+class QREdgeDetector : public Detector {
+public:
+  QREdgeDetector(Ref<BitMatrix> image);
+
+  virtual Ref<PerspectiveTransform> createTransform(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref <
+      ResultPoint > bottomLeft, Ref<ResultPoint> alignmentPattern, int dimension);
+
+private:
+  Point findCorner(const BitMatrix& image, Point topLeft, Point topRight, Point bottomLeft, int dimension);
+  Line findPatternEdge(const BitMatrix& image, Point pattern, Point opposite, Point direction, bool invert);
+
+  Point endOfReverseBlackWhiteBlackRun(const BitMatrix& image, Point from, Point to);
+
+  Ref<PerspectiveTransform> get1CornerTransform(Point topLeft, Point topRight, Point bottomLeft, Point corner, int dimension);
+};
+
+}
+}
+#endif // QREDGEDETECTOR_H_

data/ext/qrscanner/zxing/core/tests/src/TestRunner.cpp

@@ -0,0 +1,30 @@
+/*
+ *  TestRunner.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 06/05/2008.
+ *  Copyright 2008 Google UK. All rights reserved.
+ *
+ * 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.
+ */
+
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
+
+int main(int argc, char **argv) {
+  CppUnit::TextUi::TestRunner runner;
+  CppUnit::TestFactoryRegistry &registry = CppUnit::TestFactoryRegistry::getRegistry();
+  runner.addTest(registry.makeTest());
+  bool wasSuccessful = runner.run("", false);
+  return wasSuccessful ? 0 : 1;
+}

data/ext/qrscanner/zxing/core/tests/src/common/BitArrayTest.cpp

@@ -0,0 +1,96 @@
+/*
+ *  BitArrayTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 12/05/2008.
+ *  Copyright 2008 Google UK. All rights reserved.
+ *
+ * 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.
+ */
+
+#include "BitArrayTest.h"
+#include <limits>
+
+using namespace std;
+
+namespace zxing {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BitArrayTest);
+
+void BitArrayTest::testGetSet() {
+  size_t bits = numeric_limits<unsigned int>::digits + 1;
+  BitArray array(bits);
+  for (size_t i = 0; i < bits; i++) {
+    CPPUNIT_ASSERT_EQUAL(false, array.get(i));
+    array.set(i);
+    CPPUNIT_ASSERT_EQUAL(true, array.get(i));
+  }
+}
+
+void BitArrayTest::testSetBulk() {
+  BitArray array(64);
+  array.setBulk(32, 0xFFFF0000);
+  for (int i = 0; i < 48; i++) {
+    CPPUNIT_ASSERT_EQUAL(false, array.get(i));
+  }
+  for (int i = 48; i < 64; i++) {
+    CPPUNIT_ASSERT_EQUAL(true, array.get(i));
+  }
+}
+
+void BitArrayTest::testClear() {
+  size_t bits = numeric_limits<unsigned int>::digits;
+  BitArray array(bits);
+  for (size_t i = 0; i < bits; i++) {
+    array.set(i);
+  }
+  array.clear();
+  for (size_t i = 0; i < bits; i++) {
+    CPPUNIT_ASSERT_EQUAL(false, array.get(i));
+  }
+}
+
+void BitArrayTest::testGetArray() {
+  size_t bits = numeric_limits<unsigned int>::digits;
+  BitArray array(2*bits);
+  array.set(0);
+  array.set(2*bits - 1);
+  vector<unsigned> words(array.getBitArray());
+  CPPUNIT_ASSERT_EQUAL(1u, words[0]);
+  CPPUNIT_ASSERT_EQUAL((1u << (bits - 1)), words[1]);
+}
+
+void BitArrayTest::testIsRange() {
+  size_t bits = numeric_limits<unsigned int>::digits;
+  size_t bits2 = 2 * bits;
+  BitArray array(bits2);
+  CPPUNIT_ASSERT_EQUAL(true, array.isRange(0, bits2, false));
+  CPPUNIT_ASSERT_EQUAL(false, array.isRange(0, bits2, true));
+  array.set(bits);
+  CPPUNIT_ASSERT_EQUAL(true, array.isRange(bits, bits + 1, true));
+  array.set(bits - 1);
+  CPPUNIT_ASSERT_EQUAL(true, array.isRange(bits - 1, bits + 1, true));
+  array.set(bits + 2);
+  CPPUNIT_ASSERT_EQUAL(false, array.isRange(bits - 1, bits + 3, true));
+  for (size_t i = 0; i < bits - 1; i++) {
+    array.set(i);
+  }
+  CPPUNIT_ASSERT_EQUAL(true, array.isRange(0, bits + 1, true));
+  for (int i = 33; i < 64; i++) {
+    array.set(i);
+  }
+  CPPUNIT_ASSERT_EQUAL(true, array.isRange(0, 64, true));
+  CPPUNIT_ASSERT_EQUAL(false, array.isRange(0, 64, false));
+}
+}
+