qrscanner 0.1

data/ext/qrscanner/zxing/core/src/zxing/oned/UPCEANReader.h

@@ -0,0 +1,77 @@
+#ifndef __UPC_EAN_READER_H__
+#define __UPC_EAN_READER_H__
+
+/*
+ *  UPCEANReader.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/oned/OneDReader.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/Result.h>
+
+typedef enum UPC_EAN_PATTERNS {
+	UPC_EAN_PATTERNS_L_PATTERNS = 0,
+	UPC_EAN_PATTERNS_L_AND_G_PATTERNS
+} UPC_EAN_PATTERNS;
+
+namespace zxing {
+	namespace oned {
+		class UPCEANReader : public OneDReader {
+
+		private:
+			static const unsigned int MAX_AVG_VARIANCE = (unsigned int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
+			static const int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.7f);
+
+			static bool findStartGuardPattern(Ref<BitArray> row, int* rangeStart, int* rangeEnd);
+
+			virtual bool decodeEnd(Ref<BitArray> row, int endStart, int* endGuardBegin, int* endGuardEnd);
+
+			static bool checkStandardUPCEANChecksum(std::string s);
+		protected:
+			static bool findGuardPattern(Ref<BitArray> row, int rowOffset, bool whiteFirst,
+			    const int pattern[], int patternLen, int* start, int* end);
+
+			virtual const int getMIDDLE_PATTERN_LEN();
+			virtual const int* getMIDDLE_PATTERN();
+
+		public:
+			UPCEANReader();
+
+      // Returns < 0 on failure, >= 0 on success.
+			virtual int decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
+			    std::string& resultString) = 0;
+
+			Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+
+			// TODO(dswitkin): Should this be virtual so that UPCAReader can override it?
+			Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row, int startGuardBegin,
+          int startGuardEnd);
+
+      // Returns < 0 on failure, >= 0 on success.
+			static int decodeDigit(Ref<BitArray> row, int counters[], int countersLen, int rowOffset,
+			    UPC_EAN_PATTERNS patternType);
+
+			virtual bool checkChecksum(std::string s);
+
+			virtual BarcodeFormat getBarcodeFormat() = 0;
+			virtual ~UPCEANReader();
+		};
+	}
+}
+
+#endif

data/ext/qrscanner/zxing/core/src/zxing/oned/UPCEReader.cpp

@@ -0,0 +1,143 @@
+/*
+ *  UPCEReader.cpp
+ *  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 "UPCEReader.h"
+#include <zxing/ReaderException.h>
+
+namespace zxing {
+  namespace oned {
+
+    /**
+     * The pattern that marks the middle, and end, of a UPC-E pattern.
+     * There is no "second half" to a UPC-E barcode.
+     */
+    static const int MIDDLE_END_PATTERN[6] = {1, 1, 1, 1, 1, 1};
+
+    /**
+     * See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of
+     * even-odd parity encodings of digits that imply both the number system (0 or 1)
+     * used, and the check digit.
+     */
+    static const int NUMSYS_AND_CHECK_DIGIT_PATTERNS[2][10] = {
+      {0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25},
+      {0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A}
+    };
+
+    UPCEReader::UPCEReader() {
+    }
+
+    int UPCEReader::decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
+        std::string& resultString) {
+      const int countersLen = 4;
+      int counters[countersLen] = { 0, 0, 0, 0 };
+
+      int end = row->getSize();
+      int rowOffset = startGuardEnd;
+      int lgPatternFound = 0;
+
+      for (int x = 0; x < 6 && rowOffset < end; x++) {
+        int bestMatch = decodeDigit(row, counters, countersLen, rowOffset,
+            UPC_EAN_PATTERNS_L_AND_G_PATTERNS);
+        if (bestMatch < 0) {
+          return -1;
+        }
+        resultString.append(1, (char) ('0' + bestMatch % 10));
+        for (int i = 0; i < countersLen; i++) {
+          rowOffset += counters[i];
+        }
+        if (bestMatch >= 10) {
+          lgPatternFound |= 1 << (5 - x);
+        }
+      }
+
+      if (!determineNumSysAndCheckDigit(resultString, lgPatternFound)) {
+        return -1;
+      }
+      return rowOffset;
+    }
+
+    bool UPCEReader::decodeEnd(Ref<BitArray> row, int endStart, int* endGuardBegin,
+        int* endGuardEnd) {
+      return findGuardPattern(row, endStart, true, MIDDLE_END_PATTERN,
+          sizeof(MIDDLE_END_PATTERN) / sizeof(int), endGuardBegin, endGuardEnd);
+    }
+
+    bool UPCEReader::checkChecksum(std::string s){
+      return UPCEANReader::checkChecksum(convertUPCEtoUPCA(s));
+    }
+
+
+    bool UPCEReader::determineNumSysAndCheckDigit(std::string& resultString, int lgPatternFound) {
+      for (int numSys = 0; numSys <= 1; numSys++) {
+        for (int d = 0; d < 10; d++) {
+          if (lgPatternFound == NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d]) {
+            resultString.insert(0, 1, (char) ('0' + numSys));
+            resultString.append(1, (char) ('0' + d));
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Expands a UPC-E value back into its full, equivalent UPC-A code value.
+     *
+     * @param upce UPC-E code as string of digits
+     * @return equivalent UPC-A code as string of digits
+     */
+    std::string UPCEReader::convertUPCEtoUPCA(std::string upce) {
+      std::string result;
+      result.append(1, upce[0]);
+      char lastChar = upce[6];
+      switch (lastChar) {
+        case '0':
+        case '1':
+        case '2':
+          result.append(upce.substr(1,2));
+          result.append(1, lastChar);
+          result.append("0000");
+          result.append(upce.substr(3,3));
+          break;
+        case '3':
+          result.append(upce.substr(1,3));
+          result.append("00000");
+          result.append(upce.substr(4,2));
+          break;
+        case '4':
+          result.append(upce.substr(1,4));
+          result.append("00000");
+          result.append(1, upce[5]);
+          break;
+        default:
+          result.append(upce.substr(1,5));
+          result.append("0000");
+          result.append(1, lastChar);
+          break;
+      }
+      result.append(1, upce[7]);
+      return result;
+    }
+
+
+    BarcodeFormat UPCEReader::getBarcodeFormat() {
+      return BarcodeFormat_UPC_E;
+    }
+  }
+}

data/ext/qrscanner/zxing/core/src/zxing/oned/UPCEReader.h

@@ -0,0 +1,47 @@
+#ifndef __UPC_E_READER_H__
+#define __UPC_E_READER_H__
+
+/*
+ *  UPCEReader.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/oned/UPCEANReader.h>
+#include <zxing/Result.h>
+
+namespace zxing {
+  namespace oned {
+    class UPCEReader : public UPCEANReader {
+
+    private:
+      static bool determineNumSysAndCheckDigit(std::string& resultString, int lgPatternFound);
+    protected:
+      bool decodeEnd(Ref<BitArray> row, int endStart, int* endGuardBegin, int* endGuardEnd);
+      bool checkChecksum(std::string s);
+    public:
+      UPCEReader();
+
+      int decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
+          std::string& resultString);
+      static std::string convertUPCEtoUPCA(std::string upce);
+
+      BarcodeFormat getBarcodeFormat();
+    };
+  }
+}
+
+#endif

data/ext/qrscanner/zxing/core/src/zxing/qrcode/ErrorCorrectionLevel.cpp

@@ -0,0 +1,49 @@
+/*
+ *  ErrorCorrectionLevel.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 15/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/ErrorCorrectionLevel.h>
+
+namespace zxing {
+namespace qrcode {
+
+ErrorCorrectionLevel::ErrorCorrectionLevel(int inOrdinal) :
+    ordinal_(inOrdinal) {
+}
+
+int ErrorCorrectionLevel::ordinal() {
+  return ordinal_;
+}
+
+ErrorCorrectionLevel& ErrorCorrectionLevel::forBits(int bits) {
+  if (bits < 0 || bits >= N_LEVELS) {
+    throw ReaderException("Ellegal error correction level bits");
+  }
+  return *FOR_BITS[bits];
+}
+
+ErrorCorrectionLevel ErrorCorrectionLevel::L(0);
+ErrorCorrectionLevel ErrorCorrectionLevel::M(1);
+ErrorCorrectionLevel ErrorCorrectionLevel::Q(2);
+ErrorCorrectionLevel ErrorCorrectionLevel::H(3);
+ErrorCorrectionLevel *ErrorCorrectionLevel::FOR_BITS[] = { &M, &L, &H, &Q };
+int ErrorCorrectionLevel::N_LEVELS = 4;
+
+}
+}

data/ext/qrscanner/zxing/core/src/zxing/qrcode/ErrorCorrectionLevel.h

@@ -0,0 +1,46 @@
+#ifndef __ERROR_CORRECTION_LEVEL_H__
+#define __ERROR_CORRECTION_LEVEL_H__
+
+/*
+ *  ErrorCorrectionLevel.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/ReaderException.h>
+
+namespace zxing {
+namespace qrcode {
+
+class ErrorCorrectionLevel {
+private:
+  int ordinal_;
+  ErrorCorrectionLevel(int inOrdinal);
+  static ErrorCorrectionLevel *FOR_BITS[];
+  static int N_LEVELS;
+public:
+  static ErrorCorrectionLevel L;
+  static ErrorCorrectionLevel M;
+  static ErrorCorrectionLevel Q;
+  static ErrorCorrectionLevel H;
+
+  int ordinal();
+  static ErrorCorrectionLevel& forBits(int bits);
+};
+}
+}
+
+#endif // __ERROR_CORRECTION_LEVEL_H__

data/ext/qrscanner/zxing/core/src/zxing/qrcode/FormatInformation.cpp

@@ -0,0 +1,108 @@
+/*
+ *  FormatInformation.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 18/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/FormatInformation.h>
+#include <limits>
+
+namespace zxing {
+namespace qrcode {
+
+using namespace std;
+
+int FormatInformation::FORMAT_INFO_MASK_QR = 0x5412;
+int FormatInformation::FORMAT_INFO_DECODE_LOOKUP[][2] = { { 0x5412, 0x00 }, { 0x5125, 0x01 }, { 0x5E7C, 0x02 }, {
+    0x5B4B, 0x03 }, { 0x45F9, 0x04 }, { 0x40CE, 0x05 }, { 0x4F97, 0x06 }, { 0x4AA0, 0x07 }, { 0x77C4, 0x08 }, {
+    0x72F3, 0x09 }, { 0x7DAA, 0x0A }, { 0x789D, 0x0B }, { 0x662F, 0x0C }, { 0x6318, 0x0D }, { 0x6C41, 0x0E }, {
+    0x6976, 0x0F }, { 0x1689, 0x10 }, { 0x13BE, 0x11 }, { 0x1CE7, 0x12 }, { 0x19D0, 0x13 }, { 0x0762, 0x14 }, {
+    0x0255, 0x15 }, { 0x0D0C, 0x16 }, { 0x083B, 0x17 }, { 0x355F, 0x18 }, { 0x3068, 0x19 }, { 0x3F31, 0x1A }, {
+    0x3A06, 0x1B }, { 0x24B4, 0x1C }, { 0x2183, 0x1D }, { 0x2EDA, 0x1E }, { 0x2BED, 0x1F },
+};
+int FormatInformation::N_FORMAT_INFO_DECODE_LOOKUPS = 32;
+
+int FormatInformation::BITS_SET_IN_HALF_BYTE[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
+
+FormatInformation::FormatInformation(int formatInfo) :
+    errorCorrectionLevel_(ErrorCorrectionLevel::forBits((formatInfo >> 3) & 0x03)), dataMask_(
+      (unsigned char)(formatInfo & 0x07)) {
+}
+
+ErrorCorrectionLevel& FormatInformation::getErrorCorrectionLevel() {
+  return errorCorrectionLevel_;
+}
+
+unsigned char FormatInformation::getDataMask() {
+  return dataMask_;
+}
+
+int FormatInformation::numBitsDiffering(unsigned int a, unsigned int b) {
+  a ^= b;
+  return BITS_SET_IN_HALF_BYTE[a & 0x0F] + BITS_SET_IN_HALF_BYTE[(a >> 4 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 8
+         & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 12 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 16 & 0x0F)]
+         + BITS_SET_IN_HALF_BYTE[(a >> 20 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 24 & 0x0F)]
+         + BITS_SET_IN_HALF_BYTE[(a >> 28 & 0x0F)];
+}
+
+Ref<FormatInformation> FormatInformation::decodeFormatInformation(int rawFormatInfo) {
+  Ref<FormatInformation> result(doDecodeFormatInformation(rawFormatInfo));
+  if (result != 0) {
+    return result;
+  }
+  return doDecodeFormatInformation(rawFormatInfo ^ FORMAT_INFO_MASK_QR);
+}
+Ref<FormatInformation> FormatInformation::doDecodeFormatInformation(int rawFormatInfo) {
+  // Unmask:
+  int unmaskedFormatInfo = rawFormatInfo ^ FORMAT_INFO_MASK_QR;
+  // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
+  int bestDifference = numeric_limits<int>::max();
+  int bestFormatInfo = 0;
+  for (int i = 0; i < N_FORMAT_INFO_DECODE_LOOKUPS; i++) {
+    int* decodeInfo = FORMAT_INFO_DECODE_LOOKUP[i];
+    int targetInfo = decodeInfo[0];
+    if (targetInfo == unmaskedFormatInfo) {
+      // Found an exact match
+      Ref<FormatInformation> result(new FormatInformation(decodeInfo[1]));
+      return result;
+    }
+    int bitsDifference = numBitsDiffering(unmaskedFormatInfo, targetInfo);
+    if (bitsDifference < bestDifference) {
+      bestFormatInfo = decodeInfo[1];
+      bestDifference = bitsDifference;
+    }
+  }
+  if (bestDifference <= 3) {
+    Ref<FormatInformation> result(new FormatInformation(bestFormatInfo));
+    return result;
+  }
+  Ref<FormatInformation> result;
+  return result;
+}
+
+bool operator==(const FormatInformation &a, const FormatInformation &b) {
+  return &(a.errorCorrectionLevel_) == &(b.errorCorrectionLevel_) && a.dataMask_ == b.dataMask_;
+}
+
+ostream& operator<<(ostream& out, const FormatInformation& fi) {
+  const FormatInformation *fip = &fi;
+  out << "FormatInformation @ " << fip;
+  return out;
+}
+
+}
+}