zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/src/zxing/qrcode/detector/FinderPatternFinder.h

@@ -0,0 +1,76 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#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;
+
+protected:
+  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);
+
+  Ref<BitMatrix> getImage();
+  std::vector<Ref<FinderPattern> >& getPossibleCenters();
+
+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/zxing/zxing-cpp/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/zxing/zxing-cpp/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/zxing/zxing-cpp/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, char**) {
+  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/zxing/zxing-cpp/core/tests/src/common/BitArrayTest.cpp

@@ -0,0 +1,216 @@
+/*
+ *  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>
+#include <cstdlib>
+
+using namespace std;
+
+namespace zxing {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BitArrayTest);
+
+void BitArrayTest::testGetSet() {
+  const int bits = BitArray::bitsPerWord + 1;
+  BitArray array(bits);
+  for(int 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() {
+  const int bits = BitArray::bitsPerWord;
+  BitArray array(bits);
+  for(int i = 0; i < bits; i++) {
+    array.set(i);
+  }
+  array.clear();
+  for(int i = 0; i < bits; i++) {
+    CPPUNIT_ASSERT_EQUAL(false, array.get(i));
+  }
+}
+
+void BitArrayTest::testGetArray() {
+  const int bits = BitArray::bitsPerWord;
+  BitArray array(2 * bits);
+  array.set(0);
+  array.set(2 * bits - 1);
+  vector<int> words(array.getBitArray());
+  CPPUNIT_ASSERT_EQUAL(1, words[0]);
+  CPPUNIT_ASSERT_EQUAL((1 << (bits - 1)), words[1]);
+}
+
+void BitArrayTest::testIsRange() {
+  const int bits = BitArray::bitsPerWord;
+  int 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(int 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));
+}
+
+// fills the two arrays with identical random bits
+void BitArrayTest::fillRandom(BitArray& test, BitArray& reference) {
+  srandom(0xDEADBEEFL + test.getSize());
+  for(int i = 0; i < test.getSize(); ++i) {
+    if(random() & 0x1) {
+      test.set(i);
+      reference.set(i);
+    }
+  }
+}
+
+void BitArrayTest::testReverseHalves() {
+  // one word test, split in half
+  {
+    const int bits = BitArray::bitsPerWord;
+    BitArray test(bits);
+
+    test.clear();
+    for(int i = 0; i < bits / 2; ++i) {
+      test.set(i);
+    }
+
+    test.reverse();
+    for(int i = 0; i < bits / 2; ++i) {
+      CPPUNIT_ASSERT_EQUAL(test.get(i), !test.get(bits - 1 - i));
+    }
+  }
+
+  // two word test
+  {
+    const int bits2 = BitArray::bitsPerWord * 2;
+    BitArray test2(bits2);
+
+    test2.clear();
+    for(int i = 0; i < bits2 / 2; ++i) {
+      test2.set(i);
+    }
+
+    test2.reverse();
+    for(int i = 0; i < bits2 / 2; ++i) {
+      CPPUNIT_ASSERT_EQUAL(test2.get(i), !test2.get(bits2 - 1 - i));
+    }
+  }
+}
+
+void BitArrayTest::testReverseEven() {
+  const int bits = BitArray::bitsPerWord * 8;
+  BitArray test(bits);
+  BitArray reference(bits);
+
+  test.clear();
+  reference.clear();
+
+  fillRandom(test, reference);
+
+  test.reverse();
+  for(int i = 0; i < bits; ++i) {
+    CPPUNIT_ASSERT_EQUAL(test.get(i), reference.get(bits - 1 - i));
+  }
+}
+
+void BitArrayTest::testReverseOdd() {
+  const int bits = BitArray::bitsPerWord * 6 + 11;
+  BitArray test(bits);
+  BitArray reference(bits);
+
+  test.clear();
+  reference.clear();
+
+  fillRandom(test, reference);
+
+  test.reverse();
+  for(int i = 0; i < bits; ++i) {
+    CPPUNIT_ASSERT_EQUAL(test.get(i), reference.get(bits - 1 - i));
+  }
+}
+
+void BitArrayTest::testReverseSweep() {
+  int bits;
+  const int bitsHigh = BitArray::bitsPerWord * 10;
+
+  for(bits = 1; bits < bitsHigh; ++bits) {
+    BitArray test(bits);
+    BitArray reference(bits);
+
+    test.clear();
+    reference.clear();
+
+    fillRandom(test, reference);
+
+    test.reverse();
+    for(int i = 0; i < bits; ++i) {
+      CPPUNIT_ASSERT_EQUAL(test.get(i), reference.get(bits - 1 - i));
+    }
+  }
+}
+
+void BitArrayTest::testReverseReverse() {
+  const int bits = BitArray::bitsPerWord * 4 + 17;
+  BitArray test(bits);
+  BitArray reference(bits);
+
+  test.clear();
+  reference.clear();
+
+  fillRandom(test, reference);
+
+  // flip it once and test
+  test.reverse();
+  for(int i = 0; i < bits; ++i) {
+    CPPUNIT_ASSERT_EQUAL(test.get(i), reference.get(bits - 1 - i));
+  }
+  // flip it back and test
+  test.reverse();
+  for(int i = 0; i < bits; ++i) {
+    CPPUNIT_ASSERT_EQUAL(test.get(i), reference.get(i));
+  }
+}
+}
+

data/ext/zxing/zxing-cpp/core/tests/src/common/BitArrayTest.h

@@ -0,0 +1,61 @@
+#ifndef __BIT_ARRAY_TEST_H__
+#define __BIT_ARRAY_TEST_H__
+
+/*
+ *  BitArrayTest.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 <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <zxing/common/BitArray.h>
+
+namespace zxing {
+class BitArrayTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(BitArrayTest);
+  CPPUNIT_TEST(testGetSet);
+  CPPUNIT_TEST(testSetBulk);
+  CPPUNIT_TEST(testClear);
+  CPPUNIT_TEST(testGetArray);
+  CPPUNIT_TEST(testIsRange);
+  CPPUNIT_TEST(testReverseHalves);
+  CPPUNIT_TEST(testReverseEven);
+  CPPUNIT_TEST(testReverseOdd);
+  CPPUNIT_TEST(testReverseSweep);
+  CPPUNIT_TEST(testReverseReverse);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testGetSet();
+  void testSetBulk();
+  void testClear();
+  void testGetArray();
+  void testIsRange();
+  void testReverseHalves();
+  void testReverseEven();
+  void testReverseOdd();
+  void testReverseSweep();
+  void testReverseReverse();
+
+private:
+  static void fillRandom(BitArray& test, BitArray& reference);
+};
+}
+
+#endif // __BIT_ARRAY_TEST_H__