zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/VersionTest.h

@@ -0,0 +1,49 @@
+#ifndef __VERSION_TEST_H__
+#define __VERSION_TEST_H__
+
+/*
+ *  VersionTest.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/qrcode/ErrorCorrectionLevel.h>
+
+namespace zxing {
+namespace qrcode {
+
+class VersionTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(VersionTest);
+  CPPUNIT_TEST(testVersionForNumber);
+  CPPUNIT_TEST(testGetProvisionalVersionForDimension);
+  CPPUNIT_TEST(testDecodeVersionInformation);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testVersionForNumber();
+  void testGetProvisionalVersionForDimension();
+  void testDecodeVersionInformation();
+
+private:
+};
+}
+}
+
+#endif // __VERSION_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/decoder/DataMaskTest.cpp

@@ -0,0 +1,132 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Created by Christian Brunschen on 19/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 "DataMaskTest.h"
+
+namespace zxing {
+namespace qrcode {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(DataMaskTest);
+
+class Mask0Condition : public MaskCondition {
+public:
+  Mask0Condition() { }
+  bool isMasked(int i, int j) {
+    return (i + j) % 2 == 0;
+  }
+};
+
+class Mask1Condition : public MaskCondition {
+public:
+  Mask1Condition() { }
+  bool isMasked(int i, int) {
+    return i % 2 == 0;
+  }
+};
+
+class Mask2Condition : public MaskCondition {
+public:
+  Mask2Condition() { }
+  bool isMasked(int, int j) {
+    return j % 3 == 0;
+  }
+};
+
+class Mask3Condition : public MaskCondition {
+public:
+  Mask3Condition() { }
+  bool isMasked(int i, int j) {
+    return (i + j) % 3 == 0;
+  }
+};
+
+class Mask4Condition : public MaskCondition {
+public:
+  Mask4Condition() { }
+  bool isMasked(int i, int j) {
+    return (i / 2 + j / 3) % 2 == 0;
+  }
+};
+
+class Mask5Condition : public MaskCondition {
+public:
+  Mask5Condition() { }
+  bool isMasked(int i, int j) {
+    return (i * j) % 2 + (i * j) % 3 == 0;
+  }
+};
+
+class Mask6Condition : public MaskCondition {
+public:
+  Mask6Condition() { }
+  bool isMasked(int i, int j) {
+    return ((i * j) % 2 + (i * j) % 3) % 2 == 0;
+  }
+};
+
+class Mask7Condition : public MaskCondition {
+public:
+  Mask7Condition() { }
+  bool isMasked(int i, int j) {
+    return ((i + j) % 2 + (i * j) % 3) % 2 == 0;
+  }
+};
+
+
+void DataMaskTest::testMask0() {
+  Mask0Condition condition;
+  testMaskAcrossDimensions(0, condition);
+}
+
+void DataMaskTest::testMask1() {
+  Mask1Condition condition;
+  testMaskAcrossDimensions(1, condition);
+}
+
+void DataMaskTest::testMask2() {
+  Mask2Condition condition;
+  testMaskAcrossDimensions(2, condition);
+}
+
+void DataMaskTest::testMask3() {
+  Mask3Condition condition;
+  testMaskAcrossDimensions(3, condition);
+}
+
+void DataMaskTest::testMask4() {
+  Mask4Condition condition;
+  testMaskAcrossDimensions(4, condition);
+}
+
+void DataMaskTest::testMask5() {
+  Mask5Condition condition;
+  testMaskAcrossDimensions(5, condition);
+}
+
+void DataMaskTest::testMask6() {
+  Mask6Condition condition;
+  testMaskAcrossDimensions(6, condition);
+}
+
+void DataMaskTest::testMask7() {
+  Mask7Condition condition;
+  testMaskAcrossDimensions(7, condition);
+}
+
+}
+}

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/decoder/DataMaskTest.h

@@ -0,0 +1,91 @@
+#ifndef __DATA_MASK_TEST_H__
+#define __DATA_MASK_TEST_H__
+
+/*
+ *  DataMaskTest.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/qrcode/decoder/DataMask.h>
+#include <zxing/common/BitMatrix.h>
+
+namespace zxing {
+namespace qrcode {
+
+class MaskCondition {
+public:
+  MaskCondition() { }
+  virtual bool isMasked(int i, int j) = 0;
+  virtual ~MaskCondition() { }
+};
+
+
+class DataMaskTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(DataMaskTest);
+  CPPUNIT_TEST(testMask0);
+  CPPUNIT_TEST(testMask1);
+  CPPUNIT_TEST(testMask2);
+  CPPUNIT_TEST(testMask3);
+  CPPUNIT_TEST(testMask4);
+  CPPUNIT_TEST(testMask5);
+  CPPUNIT_TEST(testMask6);
+  CPPUNIT_TEST(testMask7);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testMask0();
+  void testMask1();
+  void testMask2();
+  void testMask3();
+  void testMask4();
+  void testMask5();
+  void testMask6();
+  void testMask7();
+
+private:
+  void testMaskAcrossDimensions(int reference,
+                                MaskCondition &condition) {
+    DataMask& mask = DataMask::forReference(reference);
+    for (int version = 1; version <= 40; version++) {
+      int dimension = 17 + 4 * version;
+      testMask(mask, dimension, condition);
+    }
+  }
+
+  void testMask(DataMask& mask, int dimension, MaskCondition &condition) {
+    BitMatrix bits(dimension);
+    mask.unmaskBitMatrix(bits, dimension);
+    for (int i = 0; i < dimension; i++) {
+      for (int j = 0; j < dimension; j++) {
+        //TODO: check why the coordinates are swapped
+        CPPUNIT_ASSERT_EQUAL(
+          //"(" + i + ',' + j + ')',
+          condition.isMasked(i, j),
+          bits.get(j, i));
+      }
+    }
+  }
+};
+
+}
+}
+
+#endif // __DATA_MASK_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/decoder/ModeTest.cpp

@@ -0,0 +1,52 @@
+/*
+ *  ModeTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 19/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 "ModeTest.h"
+#include <zxing/qrcode/Version.h>
+
+namespace zxing {
+namespace qrcode {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ModeTest);
+
+void ModeTest::testForBits() {
+  CPPUNIT_ASSERT_EQUAL(&Mode::TERMINATOR, &(Mode::forBits(0x00)));
+  CPPUNIT_ASSERT_EQUAL(&Mode::NUMERIC, &(Mode::forBits(0x01)));
+  CPPUNIT_ASSERT_EQUAL(&Mode::ALPHANUMERIC, &(Mode::forBits(0x02)));
+  CPPUNIT_ASSERT_EQUAL(&Mode::BYTE, &(Mode::forBits(0x04)));
+  CPPUNIT_ASSERT_EQUAL(&Mode::KANJI, &(Mode::forBits(0x08)));
+  try {
+    Mode::forBits(0x10);
+    CPPUNIT_FAIL("should have thrown an exception");
+  } catch (zxing::ReaderException const& ex) {
+    // expected
+  }
+}
+
+void ModeTest::testCharacterCount() {
+  CPPUNIT_ASSERT_EQUAL(10, Mode::NUMERIC.getCharacterCountBits(Version::getVersionForNumber(5)));
+  CPPUNIT_ASSERT_EQUAL(12, Mode::NUMERIC.getCharacterCountBits(Version::getVersionForNumber(26)));
+  CPPUNIT_ASSERT_EQUAL(14, Mode::NUMERIC.getCharacterCountBits(Version::getVersionForNumber(40)));
+  CPPUNIT_ASSERT_EQUAL(9, Mode::ALPHANUMERIC.getCharacterCountBits(Version::getVersionForNumber(6)));
+  CPPUNIT_ASSERT_EQUAL(8, Mode::BYTE.getCharacterCountBits(Version::getVersionForNumber(7)));
+  CPPUNIT_ASSERT_EQUAL(8, Mode::KANJI.getCharacterCountBits(Version::getVersionForNumber(8)));
+}
+}
+}

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/decoder/ModeTest.h

@@ -0,0 +1,47 @@
+#ifndef __MODE_TEST_H__
+#define __MODE_TEST_H__
+
+/*
+ *  ModeTest.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/qrcode/decoder/Mode.h>
+
+namespace zxing {
+namespace qrcode {
+
+class ModeTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(ModeTest);
+  CPPUNIT_TEST(testForBits);
+  CPPUNIT_TEST(testCharacterCount);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testForBits();
+  void testCharacterCount();
+
+private:
+};
+}
+}
+
+#endif // __MODE_TEST_H__

data/ext/zxing/zxing.cc

@@ -0,0 +1,224 @@
+// -*- c-basic-offset:2 -*-
+
+#include <zxing/Reader.h>
+#include <zxing/MultiFormatReader.h>
+#include <zxing/datamatrix/DataMatrixReader.h>
+#include <zxing/aztec/AztecReader.h>
+#include <zxing/oned/Code39Reader.h>
+#include <zxing/common/GreyscaleLuminanceSource.h>
+#include <zxing/common/HybridBinarizer.h>
+#include <zxing/FormatException.h>
+#include <zxing/ReaderException.h>
+#include <zxing/ChecksumException.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <zxing/common/Str.h>
+
+#include <stdlib.h>
+#include <stdint.h>
+
+using namespace std;
+
+extern "C" {
+  void Reader_delete(void* reader_ptr) {
+    zxing::Ref<zxing::Reader>* ref = (zxing::Ref<zxing::Reader>*)reader_ptr;
+    delete ref;
+  }
+
+  void* new_exception_data(const char* className, std::exception const& e) {
+    void** exception = (void**)malloc(sizeof(void*)*2);
+    exception[0] = (void*)className;
+    size_t size = strlen(e.what())+1;
+    exception[1] = malloc(size);
+    memcpy(exception[1], e.what(), size);
+    return (void*)((uintptr_t)exception | 1);
+  }
+
+  void* Reader_decode(
+    void* reader_ref_ptr,
+    void* bitmap_ref_ptr,
+    void* hints_ptr) {
+
+    zxing::Ref<zxing::Reader>* reader =
+      (zxing::Ref<zxing::Reader>*)reader_ref_ptr;
+    zxing::Ref<zxing::BinaryBitmap>* bitmap = 
+      (zxing::Ref<zxing::BinaryBitmap>*)bitmap_ref_ptr;
+    zxing::DecodeHints* hints = (zxing::DecodeHints*)hints_ptr;
+    void* result = 0;
+    try {
+      zxing::Ref<zxing::Result> decoded ((*reader)->decode(*bitmap, *hints));
+      result = new zxing::Ref<zxing::Result>(decoded);
+    } catch(zxing::IllegalArgumentException const& e) {
+      result = new_exception_data("zxing::IllegalArgumentException", e);
+    } catch(zxing::ReedSolomonException const& e) {
+      result = new_exception_data("zxing::ReedSolomonException", e);
+    } catch(zxing::FormatException const& e) {
+      result = new_exception_data("zxing::FormatException", e);
+    } catch(zxing::ChecksumException const& e) {
+      result = new_exception_data("zxing::ChecksumException", e);
+    } catch(zxing::ReaderException const& e) {
+      result = new_exception_data("zxing::ReaderException", e);
+    } catch(zxing::Exception const& e) {
+      result = new_exception_data("zxing::Exception", e);
+    } catch(...) {
+      result = new_exception_data("...", std::exception());
+    }
+    return result;
+  }
+
+  void* MultiFormatReader_new() {
+    zxing::MultiFormatReader* reader = new zxing::MultiFormatReader();
+    return new zxing::Ref<zxing::Reader>(reader);
+  }
+
+  void* DataMatrixReader_new() {
+    zxing::datamatrix::DataMatrixReader* reader = new zxing::datamatrix::DataMatrixReader();
+    return new zxing::Ref<zxing::Reader>(reader);
+  }
+
+  void* AztecReader_new() {
+    zxing::aztec::AztecReader* reader = new zxing::aztec::AztecReader();
+    return new zxing::Ref<zxing::Reader>(reader);
+  }
+
+  void* Code39Reader_new(bool usingCheckDigit, bool extendedMode) {
+    zxing::oned::Code39Reader* reader =
+      new zxing::oned::Code39Reader(usingCheckDigit, extendedMode);
+    return new zxing::Ref<zxing::Reader>(reader);
+  }
+
+  void LuminanceSource_delete(void* source_ptr) {
+    zxing::Ref<zxing::LuminanceSource>* ref = (zxing::Ref<zxing::LuminanceSource>*)source_ptr;
+    delete ref;
+  }
+
+  int LuminanceSource_width(void* source_ptr) {
+    zxing::Ref<zxing::LuminanceSource>* ref = (zxing::Ref<zxing::LuminanceSource>*)source_ptr;
+    return (*ref)->getWidth();
+  }
+
+  int LuminanceSource_height(void* source_ptr) {
+    zxing::Ref<zxing::LuminanceSource>* ref = (zxing::Ref<zxing::LuminanceSource>*)source_ptr;
+    return (*ref)->getHeight();
+  }
+
+  void* LuminanceSource_matrix(void* source_ptr) {
+    zxing::Ref<zxing::LuminanceSource>* ref = (zxing::Ref<zxing::LuminanceSource>*)source_ptr;
+    return &(*ref)->getMatrix()[0];
+  }
+
+  void* GreyscaleLuminanceSource_new(
+    char* greyData,
+    int dataWidth,
+    int dataHeight,
+    int left,
+    int top,
+    int width,
+    int height) {
+    zxing::GreyscaleLuminanceSource* source =
+      new zxing::GreyscaleLuminanceSource(
+        zxing::ArrayRef<char>(greyData, dataWidth*dataHeight),
+        dataWidth,
+        dataHeight,
+        left,
+        top,
+        width,
+        height);
+    return new zxing::Ref<zxing::LuminanceSource>(source);
+  }
+
+  void Binarizer_delete(void* binarizer_ptr) {
+    zxing::Ref<zxing::Binarizer>* ref = (zxing::Ref<zxing::Binarizer>*)binarizer_ptr;
+    delete ref;
+  }
+
+  void* Binarizer_black_matrix(void* binarizer_ptr) {
+    zxing::Ref<zxing::Binarizer>* ref = (zxing::Ref<zxing::Binarizer>*)binarizer_ptr;
+    return new zxing::Ref<zxing::BitMatrix>((*ref)->getBlackMatrix());
+  }
+
+  void* BinaryBitmap_black_matrix(void* ref_ptr) {
+    zxing::Ref<zxing::BinaryBitmap>* ref = (zxing::Ref<zxing::BinaryBitmap>*)ref_ptr;
+    return new zxing::Ref<zxing::BitMatrix>((*ref)->getBlackMatrix());
+  }
+
+  bool BitMatrix_get(void* ref_ptr, int x, int y) {
+    zxing::Ref<zxing::BitMatrix>* ref = (zxing::Ref<zxing::BitMatrix>*)ref_ptr;
+    return (*ref)->get(x, y);
+  }
+
+  void* HybridBinarizer_new(zxing::Ref<zxing::LuminanceSource>* luminance_source) {
+    zxing::HybridBinarizer* binarizer = new zxing::HybridBinarizer(*luminance_source);
+    return new zxing::Ref<zxing::Binarizer>(binarizer);
+  }
+
+  void* BinaryBitmap_new(zxing::Ref<zxing::Binarizer>* binarizer) {
+    zxing::BinaryBitmap* bitmap = new zxing::BinaryBitmap(*binarizer);
+    return new zxing::Ref<zxing::BinaryBitmap>(bitmap);
+  }
+
+  int BinaryBitmap_count(void* bitmap_ptr) {
+    zxing::Ref<zxing::BinaryBitmap>* ref = (zxing::Ref<zxing::BinaryBitmap>*)bitmap_ptr;
+    return (*ref)->count();
+  }
+
+  void BinaryBitmap_delete(void* bitmap_ptr) {
+    zxing::Ref<zxing::BinaryBitmap>* ref = (zxing::Ref<zxing::BinaryBitmap>*)bitmap_ptr;
+    delete ref;
+  }
+
+  void* DecodeHints_new(int value) {
+    return new zxing::DecodeHints(value);
+  }
+
+  void* DecodeHints_default() {
+    return new zxing::DecodeHints(zxing::DecodeHints::DEFAULT_HINT);
+  }
+
+  void DecodeHints_delete(void* hints_ptr) {
+    zxing::DecodeHints* hints  = (zxing::DecodeHints*)hints_ptr;
+    delete hints;
+  }
+
+  void DecodeHints_setTryHarder(void* hints_ptr, bool value) {
+    zxing::DecodeHints* hints  = (zxing::DecodeHints*)hints_ptr;
+    hints->setTryHarder(value);
+  }
+
+  void DecodeHints_setDataMatrix(void* hints_ptr, bool) {
+    zxing::DecodeHints* hints  = (zxing::DecodeHints*)hints_ptr;
+    hints->addFormat(zxing::BarcodeFormat::DATA_MATRIX);
+  }
+
+  void Result_delete(void* result_ptr) {
+    zxing::Ref<zxing::Result>* ref = (zxing::Ref<zxing::Result>*)result_ptr;
+    delete ref;
+  }
+
+  int Result_getBarcodeFormat(void* ref_ptr) {
+    zxing::Ref<zxing::Result>* ref = (zxing::Ref<zxing::Result>*)ref_ptr;
+    return (*ref)->getBarcodeFormat();
+  }
+
+  void* Result_getText(void* ref_ptr) {
+    zxing::Ref<zxing::Result>* ref = (zxing::Ref<zxing::Result>*)ref_ptr;
+    zxing::Ref<zxing::String> string = (*ref)->getText();
+    return new zxing::Ref<zxing::String>(string);
+  }
+
+  char const* BarcodeFormat_enum_to_string(zxing::BarcodeFormat format) {
+    return zxing::BarcodeFormat::barcodeFormatNames[format];
+  }
+
+  void String_delete(void* string_ptr) {
+    zxing::Ref<zxing::String>* ref = (zxing::Ref<zxing::String>*)string_ptr;
+    delete ref;
+  }
+
+  char const* String_string(void* string_ptr) {
+    zxing::Ref<zxing::String>* ref = (zxing::Ref<zxing::String>*)string_ptr;
+    return (*ref)->getText().c_str();
+  }
+
+}
+