zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/oned/UPCEANReader.h

@@ -0,0 +1,88 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __UPC_EAN_READER_H__
+#define __UPC_EAN_READER_H__
+
+/*
+ *  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>
+
+namespace zxing {
+namespace oned {
+
+class UPCEANReader : public OneDReader {
+ private:
+  std::string decodeRowStringBuffer;
+  // UPCEANExtensionSupport extensionReader;
+  // EANManufacturerOrgSupport eanManSupport;
+
+  static const int MAX_AVG_VARIANCE;
+  static const int MAX_INDIVIDUAL_VARIANCE;
+
+  static Range findStartGuardPattern(Ref<BitArray> row);
+
+  virtual Range decodeEnd(Ref<BitArray> row, int endStart);
+
+  static bool checkStandardUPCEANChecksum(Ref<String> const& s);
+
+  static Range findGuardPattern(Ref<BitArray> row,
+                                int rowOffset,
+                                bool whiteFirst,
+                                std::vector<int> const& pattern,
+                                std::vector<int>& counters);
+
+
+protected:
+  static const std::vector<int> START_END_PATTERN;
+  static const std::vector<int> MIDDLE_PATTERN;
+
+  static const std::vector<int const*> L_PATTERNS;
+  static const std::vector<int const*> L_AND_G_PATTERNS;
+
+  static Range findGuardPattern(Ref<BitArray> row,
+                                int rowOffset,
+                                bool whiteFirst,
+                                std::vector<int> const& pattern);
+
+public:
+  UPCEANReader();
+
+  virtual int decodeMiddle(Ref<BitArray> row,
+                           Range const& startRange,
+                           std::string& resultString) = 0;
+
+  virtual Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+  virtual Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row, Range const& range);
+
+  static int decodeDigit(Ref<BitArray> row,
+                         std::vector<int>& counters,
+                         int rowOffset,
+                         std::vector<int const*> const& patterns);
+
+  virtual bool checkChecksum(Ref<String> const& s);
+
+  virtual BarcodeFormat getBarcodeFormat() = 0;
+  virtual ~UPCEANReader();
+
+  friend class MultiFormatUPCEANReader;
+};
+
+}
+}
+
+#endif

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

@@ -0,0 +1,146 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  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/ZXing.h>
+#include <zxing/oned/UPCEReader.h>
+#include <zxing/ReaderException.h>
+
+using std::string;
+using std::vector;
+using zxing::Ref;
+using zxing::String;
+using zxing::oned::UPCEReader;
+
+// VC++
+using zxing::BitArray;
+
+#define VECTOR_INIT(v) v, v + sizeof(v)/sizeof(v[0])
+
+namespace {
+  /**
+   * The pattern that marks the middle, and end, of a UPC-E pattern.
+   * There is no "second half" to a UPC-E barcode.
+   */
+  const int MIDDLE_END_PATTERN_[6] = {1, 1, 1, 1, 1, 1};
+  const vector<int> MIDDLE_END_PATTERN (VECTOR_INIT(MIDDLE_END_PATTERN_));
+  
+
+  /**
+   * 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.
+   */
+  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, Range const& startRange, string& result) {
+  vector<int>& counters (decodeMiddleCounters);
+  counters.clear();
+  counters.resize(4);
+  int end = row->getSize();
+  int rowOffset = startRange[1];
+
+  int lgPatternFound = 0;
+
+  for (int x = 0; x < 6 && rowOffset < end; x++) {
+    int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);
+    result.append(1, (char) ('0' + bestMatch % 10));
+    for (int i = 0, e = counters.size(); i < e; i++) {
+      rowOffset += counters[i];
+    }
+    if (bestMatch >= 10) {
+      lgPatternFound |= 1 << (5 - x);
+    }
+  }
+
+  determineNumSysAndCheckDigit(result, lgPatternFound);
+
+  return rowOffset;
+}
+
+UPCEReader::Range UPCEReader::decodeEnd(Ref<BitArray> row, int endStart) {
+  return findGuardPattern(row, endStart, true, MIDDLE_END_PATTERN);
+}
+
+bool UPCEReader::checkChecksum(Ref<String> const& 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
+ */
+Ref<String> UPCEReader::convertUPCEtoUPCA(Ref<String> const& upce_) {
+  string const& upce(upce_->getText());
+  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 Ref<String>(new String(result));
+}
+
+
+zxing::BarcodeFormat UPCEReader::getBarcodeFormat() {
+  return BarcodeFormat::UPC_E;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/oned/UPCEReader.h

@@ -0,0 +1,47 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __UPC_E_READER_H__
+#define __UPC_E_READER_H__
+
+/*
+ *  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:
+  std::vector<int> decodeMiddleCounters;
+  static bool determineNumSysAndCheckDigit(std::string& resultString, int lgPatternFound);
+
+protected:
+  Range decodeEnd(Ref<BitArray> row, int endStart);
+  bool checkChecksum(Ref<String> const& s);
+public:
+  UPCEReader();
+
+  int decodeMiddle(Ref<BitArray> row, Range const& startRange, std::string& resultString);
+  static Ref<String> convertUPCEtoUPCA(Ref<String> const& upce);
+
+  BarcodeFormat getBarcodeFormat();
+};
+
+}
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/pdf417/PDF417Reader.cpp

@@ -0,0 +1,170 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * 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/pdf417/PDF417Reader.h>
+#include <zxing/pdf417/detector/Detector.h>
+
+using zxing::Ref;
+using zxing::Result;
+using zxing::BitMatrix;
+using zxing::pdf417::PDF417Reader;
+using zxing::pdf417::detector::Detector;
+
+// VC++
+using zxing::ArrayRef;
+using zxing::BinaryBitmap;
+using zxing::DecodeHints;
+
+Ref<Result> PDF417Reader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+  Ref<DecoderResult> decoderResult;
+  /* 2012-05-30 hfn C++ DecodeHintType does not yet know a type "PURE_BARCODE", */
+  /* therefore skip this for now, todo: may be add this type later */
+  /*
+    if (!hints.isEmpty() && hints.containsKey(DecodeHintType.PURE_BARCODE)) {
+    BitMatrix bits = extractPureBits(image.getBlackMatrix());
+    decoderResult = decoder.decode(bits);
+    points = NO_POINTS;
+    } else {
+  */
+  Detector detector(image);
+  Ref<DetectorResult> detectorResult = detector.detect(hints); /* 2012-09-17 hints ("try_harder") */
+  ArrayRef< Ref<ResultPoint> > points(detectorResult->getPoints());
+  
+  if (!hints.isEmpty()) {
+    Ref<ResultPointCallback> rpcb = hints.getResultPointCallback();
+    /* .get(DecodeHintType.NEED_RESULT_POINT_CALLBACK); */
+    if (rpcb != NULL) {
+      for (int i = 0; i < points->size(); i++) {
+        rpcb->foundPossibleResultPoint(*points[i]);
+      }
+    }
+  }
+  decoderResult = decoder.decode(detectorResult->getBits(),hints);
+  /*
+    }
+  */
+  Ref<Result> r(new Result(decoderResult->getText(), decoderResult->getRawBytes(), points,
+                           BarcodeFormat::PDF_417));
+  return r;
+}
+
+void PDF417Reader::reset() {
+  // do nothing
+}
+
+Ref<BitMatrix> PDF417Reader::extractPureBits(Ref<BitMatrix> image) {
+  ArrayRef<int> leftTopBlack = image->getTopLeftOnBit();
+  ArrayRef<int> rightBottomBlack = image->getBottomRightOnBit();
+  /* see BitMatrix::getTopLeftOnBit etc.:
+     if (leftTopBlack == null || rightBottomBlack == null) {
+     throw NotFoundException.getNotFoundInstance();
+     } */
+  
+  int nModuleSize = moduleSize(leftTopBlack, image);
+  
+  int top = leftTopBlack[1];
+  int bottom = rightBottomBlack[1];
+  int left = findPatternStart(leftTopBlack[0], top, image);
+  int right = findPatternEnd(leftTopBlack[0], top, image);
+  
+  int matrixWidth = (right - left + 1) / nModuleSize;
+  int matrixHeight = (bottom - top + 1) / nModuleSize;
+  if (matrixWidth <= 0 || matrixHeight <= 0) {
+    throw NotFoundException("PDF417Reader::extractPureBits: no matrix found!");
+  }
+  
+  // Push in the "border" by half the module width so that we start
+  // sampling in the middle of the module. Just in case the image is a
+  // little off, this will help recover.
+  int nudge = nModuleSize >> 1;
+  top += nudge;
+  left += nudge;
+  
+  // Now just read off the bits
+  Ref<BitMatrix> bits(new BitMatrix(matrixWidth, matrixHeight));
+  for (int y = 0; y < matrixHeight; y++) {
+    int iOffset = top + y * nModuleSize;
+    for (int x = 0; x < matrixWidth; x++) {
+      if (image->get(left + x * nModuleSize, iOffset)) {
+        bits->set(x, y);
+      }
+    }
+  }
+  return bits;
+}
+
+int PDF417Reader::moduleSize(ArrayRef<int> leftTopBlack, Ref<BitMatrix> image) {
+  int x = leftTopBlack[0];
+  int y = leftTopBlack[1];
+  int width = image->getWidth();
+  while (x < width && image->get(x, y)) {
+    x++;
+  }
+  if (x == width) {
+    throw NotFoundException("PDF417Reader::moduleSize: not found!");
+  }
+  
+  int moduleSize = (int)(((unsigned)(x - leftTopBlack[0])) >> 3); // We've crossed left first bar, which is 8x
+  if (moduleSize == 0) {
+    throw NotFoundException("PDF417Reader::moduleSize: is zero!");
+  }
+  
+  return moduleSize;
+}
+
+int PDF417Reader::findPatternStart(int x, int y, Ref<BitMatrix> image) {
+  int width = image->getWidth();
+  int start = x;
+  // start should be on black
+  int transitions = 0;
+  bool black = true;
+  while (start < width - 1 && transitions < 8) {
+    start++;
+    bool newBlack = image->get(start, y);
+    if (black != newBlack) {
+      transitions++;
+    }
+    black = newBlack;
+  }
+  if (start == width - 1) {
+    throw NotFoundException("PDF417Reader::findPatternStart: no pattern start found!");
+  }
+  return start;
+}
+
+int PDF417Reader::findPatternEnd(int x, int y, Ref<BitMatrix> image) {
+  int width = image->getWidth();
+  int end = width - 1;
+  // end should be on black
+  while (end > x && !image->get(end, y)) {
+    end--;
+  }
+  int transitions = 0;
+  bool black = true;
+  while (end > x && transitions < 9) {
+    end--;
+    bool newBlack = image->get(end, y);
+    if (black != newBlack) {
+      transitions++;
+    }
+    black = newBlack;
+  }
+  if (end == x) {
+    throw NotFoundException("PDF417Reader::findPatternEnd: no pattern end found!");
+  }
+  return end;
+}