zxing_cpp_mac_big_sur 0.1.1

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

@@ -0,0 +1,81 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __ONED_READER_H__
+#define __ONED_READER_H__
+
+/*
+ *  OneDReader.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/Reader.h>
+
+namespace zxing {
+namespace oned {
+
+class OneDReader : public Reader {
+private:
+  Ref<Result> doDecode(Ref<BinaryBitmap> image, DecodeHints hints);
+
+protected:
+  static const int INTEGER_MATH_SHIFT = 8;
+
+  struct Range {
+  private:
+    int data[2];
+  public:
+    Range() {}
+    Range(int zero, int one) {
+      data[0] = zero;
+      data[1] = one;
+    }
+    int& operator [] (int index) {
+      return data[index];
+    }
+    int const& operator [] (int index) const {
+      return data[index];
+    }
+  };
+
+  static int patternMatchVariance(std::vector<int>& counters,
+                                  std::vector<int> const& pattern,
+                                  int maxIndividualVariance);
+  static int patternMatchVariance(std::vector<int>& counters,
+                                  int const pattern[],
+                                  int maxIndividualVariance);
+
+protected:
+  static const int PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
+
+public:
+
+  OneDReader();
+  virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
+
+  // Implementations must not throw any exceptions. If a barcode is not found on this row,
+  // a empty ref should be returned e.g. return Ref<Result>();
+  virtual Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row) = 0;
+
+  static void recordPattern(Ref<BitArray> row,
+                            int start,
+                            std::vector<int>& counters);
+  virtual ~OneDReader();
+};
+
+}
+}
+
+#endif

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

@@ -0,0 +1,28 @@
+/*
+ *  OneDResultPoint.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 "OneDResultPoint.h"
+
+namespace zxing {
+	namespace oned {
+
+		OneDResultPoint::OneDResultPoint(float posX, float posY) : ResultPoint(posX,posY) {
+		}
+	}
+}

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

@@ -0,0 +1,35 @@
+#ifndef __ONED_RESULT_POINT_H__
+#define __ONED_RESULT_POINT_H__
+/*
+ *  OneDResultPoint.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/ResultPoint.h>
+#include <cmath>
+
+namespace zxing {
+	namespace oned {
+		
+		class OneDResultPoint : public ResultPoint {
+			
+		public:
+			OneDResultPoint(float posX, float posY);
+		};
+	}
+}
+
+#endif

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

@@ -0,0 +1,70 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  UPCAReader.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 "UPCAReader.h"
+#include <zxing/FormatException.h>
+
+using zxing::oned::UPCAReader;
+using zxing::Ref;
+using zxing::Result;
+
+// VC++
+using zxing::BitArray;
+using zxing::BinaryBitmap;
+using zxing::DecodeHints;
+using zxing::FormatException;
+
+UPCAReader::UPCAReader() : ean13Reader() {}
+
+Ref<Result> UPCAReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+  return maybeReturnResult(ean13Reader.decodeRow(rowNumber, row));
+}
+
+Ref<Result> UPCAReader::decodeRow(int rowNumber,
+                                  Ref<BitArray> row,
+                                  Range const& startGuardRange) {
+  return maybeReturnResult(ean13Reader.decodeRow(rowNumber, row, startGuardRange));
+}
+
+Ref<Result> UPCAReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+  return maybeReturnResult(ean13Reader.decode(image, hints));
+}
+
+int UPCAReader::decodeMiddle(Ref<BitArray> row,
+                             Range const& startRange,
+                             std::string& resultString) {
+  return ean13Reader.decodeMiddle(row, startRange, resultString);
+}
+
+Ref<Result> UPCAReader::maybeReturnResult(Ref<Result> result) {
+  const std::string& text = (result->getText())->getText();
+  if (text[0] == '0') {
+    Ref<String> resultString(new String(text.substr(1)));
+    Ref<Result> res(new Result(resultString, result->getRawBytes(), result->getResultPoints(),
+                               BarcodeFormat::UPC_A));
+    return res;
+  } else {
+    throw FormatException();
+  }
+}
+
+zxing::BarcodeFormat UPCAReader::getBarcodeFormat(){
+  return BarcodeFormat::UPC_A;
+}

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

@@ -0,0 +1,50 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __UPCA_READER_H__
+#define __UPCA_READER_H__
+/*
+ *  UPCAReader.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/EAN13Reader.h>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+namespace oned {
+
+class UPCAReader : public UPCEANReader {
+
+private:
+  EAN13Reader ean13Reader;
+  static Ref<Result> maybeReturnResult(Ref<Result> result);
+
+public:
+  UPCAReader();
+
+  int decodeMiddle(Ref<BitArray> row, Range const& startRange, std::string& resultString);
+
+  Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+  Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row, Range const& startGuardRange);
+  Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
+
+  BarcodeFormat getBarcodeFormat();
+};
+
+}
+}
+
+#endif

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

@@ -0,0 +1,309 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  UPCEANReader.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 <zxing/ZXing.h>
+#include <zxing/oned/UPCEANReader.h>
+#include <zxing/oned/OneDResultPoint.h>
+#include <zxing/ReaderException.h>
+#include <zxing/NotFoundException.h>
+#include <zxing/FormatException.h>
+#include <zxing/ChecksumException.h>
+
+using std::vector;
+using std::string;
+
+using zxing::Ref;
+using zxing::Result;
+using zxing::NotFoundException;
+using zxing::FormatException;
+using zxing::ChecksumException;
+using zxing::oned::UPCEANReader;
+
+// VC++
+using zxing::BitArray;
+using zxing::String;
+
+#define LEN(v) ((int)(sizeof(v)/sizeof(v[0])))
+
+namespace {
+
+  /**
+   * Start/end guard pattern.
+   */
+  const int START_END_PATTERN_[] = {1, 1, 1};
+  const int START_END_PATTERN_LEN = LEN(START_END_PATTERN_);
+
+  /**
+   * Pattern marking the middle of a UPC/EAN pattern, separating the two halves.
+   */
+  const int MIDDLE_PATTERN_[] = {1, 1, 1, 1, 1};
+  const int MIDDLE_PATTERN_LEN = LEN(MIDDLE_PATTERN_);
+
+  /**
+   * "Odd", or "L" patterns used to encode UPC/EAN digits.
+   */
+  const int L_PATTERNS_[][4] = {
+    {3, 2, 1, 1}, // 0
+    {2, 2, 2, 1}, // 1
+    {2, 1, 2, 2}, // 2
+    {1, 4, 1, 1}, // 3
+    {1, 1, 3, 2}, // 4
+    {1, 2, 3, 1}, // 5
+    {1, 1, 1, 4}, // 6
+    {1, 3, 1, 2}, // 7
+    {1, 2, 1, 3}, // 8
+    {3, 1, 1, 2}  // 9
+  };
+  const int L_PATTERNS_LEN = LEN(L_PATTERNS_);
+
+  /**
+   * As above but also including the "even", or "G" patterns used to encode UPC/EAN digits.
+   */
+  const int L_AND_G_PATTERNS_[][4] = {
+    {3, 2, 1, 1}, // 0
+    {2, 2, 2, 1}, // 1
+    {2, 1, 2, 2}, // 2
+    {1, 4, 1, 1}, // 3
+    {1, 1, 3, 2}, // 4
+    {1, 2, 3, 1}, // 5
+    {1, 1, 1, 4}, // 6
+    {1, 3, 1, 2}, // 7
+    {1, 2, 1, 3}, // 8
+    {3, 1, 1, 2}, // 9
+    {1, 1, 2, 3}, // 10 reversed 0
+    {1, 2, 2, 2}, // 11 reversed 1
+    {2, 2, 1, 2}, // 12 reversed 2
+    {1, 1, 4, 1}, // 13 reversed 3
+    {2, 3, 1, 1}, // 14 reversed 4
+    {1, 3, 2, 1}, // 15 reversed 5
+    {4, 1, 1, 1}, // 16 reversed 6
+    {2, 1, 3, 1}, // 17 reversed 7
+    {3, 1, 2, 1}, // 18 reversed 8
+    {2, 1, 1, 3}  // 19 reversed 9
+  };
+  const int L_AND_G_PATTERNS_LEN = LEN(L_AND_G_PATTERNS_);
+}
+
+const int UPCEANReader::MAX_AVG_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.48f);
+const int UPCEANReader::MAX_INDIVIDUAL_VARIANCE = (int)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.7f);
+
+#define VECTOR_INIT(v) v, v + sizeof(v)/sizeof(v[0])
+
+const vector<int>
+UPCEANReader::START_END_PATTERN (VECTOR_INIT(START_END_PATTERN_));
+
+const vector<int>
+UPCEANReader::MIDDLE_PATTERN (VECTOR_INIT(MIDDLE_PATTERN_));
+const vector<int const*>
+UPCEANReader::L_PATTERNS (VECTOR_INIT(L_PATTERNS_));
+const vector<int const*>
+UPCEANReader::L_AND_G_PATTERNS (VECTOR_INIT(L_AND_G_PATTERNS_));
+
+UPCEANReader::UPCEANReader() {}
+
+Ref<Result> UPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+  return decodeRow(rowNumber, row, findStartGuardPattern(row));
+}
+
+Ref<Result> UPCEANReader::decodeRow(int rowNumber,
+                                    Ref<BitArray> row,
+                                    Range const& startGuardRange) {
+  string& result = decodeRowStringBuffer;
+  result.clear();
+  int endStart = decodeMiddle(row, startGuardRange, result);
+
+  Range endRange = decodeEnd(row, endStart);
+
+  // Make sure there is a quiet zone at least as big as the end pattern after the barcode.
+  // The spec might want more whitespace, but in practice this is the maximum we can count on.
+
+  int end = endRange[1];
+  int quietEnd = end + (end - endRange[0]);
+  if (quietEnd >= row->getSize() || !row->isRange(end, quietEnd, false)) {
+    throw NotFoundException();
+  }
+
+  // UPC/EAN should never be less than 8 chars anyway
+  if (result.length() < 8) {
+    throw FormatException();
+  }
+
+  Ref<String> resultString (new String(result));
+  if (!checkChecksum(resultString)) {
+    throw ChecksumException();
+  }
+  
+  float left = (float) (startGuardRange[1] + startGuardRange[0]) / 2.0f;
+  float right = (float) (endRange[1] + endRange[0]) / 2.0f;
+  BarcodeFormat format = getBarcodeFormat();
+  ArrayRef< Ref<ResultPoint> > resultPoints(2);
+  resultPoints[0] = Ref<ResultPoint>(new OneDResultPoint(left, (float) rowNumber));
+  resultPoints[1] = Ref<ResultPoint>(new OneDResultPoint(right, (float) rowNumber));
+  Ref<Result> decodeResult (new Result(resultString, ArrayRef<char>(), resultPoints, format));
+  // Java extension and man stuff
+  return decodeResult;
+}
+
+UPCEANReader::Range UPCEANReader::findStartGuardPattern(Ref<BitArray> row) {
+  bool foundStart = false;
+  Range startRange;
+  int nextStart = 0;
+  vector<int> counters(START_END_PATTERN.size(), 0);
+  // std::cerr << "fsgp " << *row << std::endl;
+  while (!foundStart) {
+    for(int i=0; i < (int)START_END_PATTERN.size(); ++i) {
+      counters[i] = 0;
+    }
+    startRange = findGuardPattern(row, nextStart, false, START_END_PATTERN, counters);
+    // std::cerr << "sr " << startRange[0] << " " << startRange[1] << std::endl;
+    int start = startRange[0];
+    nextStart = startRange[1];
+    // Make sure there is a quiet zone at least as big as the start pattern before the barcode.
+    // If this check would run off the left edge of the image, do not accept this barcode,
+    // as it is very likely to be a false positive.
+    int quietStart = start - (nextStart - start);
+    if (quietStart >= 0) {
+      foundStart = row->isRange(quietStart, start, false);
+    }
+  }
+  return startRange;
+}
+
+UPCEANReader::Range UPCEANReader::findGuardPattern(Ref<BitArray> row,
+                                                   int rowOffset,
+                                                   bool whiteFirst,
+                                                   vector<int> const& pattern) {
+  vector<int> counters (pattern.size(), 0);
+  return findGuardPattern(row, rowOffset, whiteFirst, pattern, counters);
+}
+
+UPCEANReader::Range UPCEANReader::findGuardPattern(Ref<BitArray> row,
+                                                   int rowOffset,
+                                                   bool whiteFirst,
+                                                   vector<int> const& pattern,
+                                                   vector<int>& counters) {
+  // cerr << "fGP " << rowOffset  << " " << whiteFirst << endl;
+  if (false) {
+    for(int i=0; i < (int)pattern.size(); ++i) {
+      std::cerr << pattern[i];
+    }
+    std::cerr << std::endl;
+  }
+  int patternLength = pattern.size();
+  int width = row->getSize();
+  bool isWhite = whiteFirst;
+  rowOffset = whiteFirst ? row->getNextUnset(rowOffset) : row->getNextSet(rowOffset);
+  int counterPosition = 0;
+  int patternStart = rowOffset;
+  for (int x = rowOffset; x < width; x++) {
+    // std::cerr << "rg " << x << " " << row->get(x) << std::endl;
+    if (row->get(x) ^ isWhite) {
+      counters[counterPosition]++;
+    } else {
+      if (counterPosition == patternLength - 1) {
+        if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
+          return Range(patternStart, x);
+        }
+        patternStart += counters[0] + counters[1];
+        for (int y = 2; y < patternLength; y++) {
+          counters[y - 2] = counters[y];
+        }
+        counters[patternLength - 2] = 0;
+        counters[patternLength - 1] = 0;
+        counterPosition--;
+      } else {
+        counterPosition++;
+      }
+      counters[counterPosition] = 1;
+      isWhite = !isWhite;
+    }
+  }
+  throw NotFoundException();
+}
+
+UPCEANReader::Range UPCEANReader::decodeEnd(Ref<BitArray> row, int endStart) {
+  return findGuardPattern(row, endStart, false, START_END_PATTERN);
+}
+
+int UPCEANReader::decodeDigit(Ref<BitArray> row,
+                              vector<int> & counters,
+                              int rowOffset,
+                              vector<int const*> const& patterns) {
+  recordPattern(row, rowOffset, counters);
+  int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
+  int bestMatch = -1;
+  int max = patterns.size();
+  for (int i = 0; i < max; i++) {
+    int const* pattern (patterns[i]);
+    int variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
+    if (variance < bestVariance) {
+      bestVariance = variance;
+      bestMatch = i;
+    }
+  }
+  if (bestMatch >= 0) {
+    return bestMatch;
+  } else {
+    throw NotFoundException();
+  }
+}
+
+/**
+ * @return {@link #checkStandardUPCEANChecksum(String)}
+ */
+bool UPCEANReader::checkChecksum(Ref<String> const& s) {
+  return checkStandardUPCEANChecksum(s);
+}
+
+/**
+ * Computes the UPC/EAN checksum on a string of digits, and reports
+ * whether the checksum is correct or not.
+ *
+ * @param s string of digits to check
+ * @return true iff string of digits passes the UPC/EAN checksum algorithm
+ */
+bool UPCEANReader::checkStandardUPCEANChecksum(Ref<String> const& s_) {
+  std::string const& s (s_->getText());
+  int length = s.length();
+  if (length == 0) {
+    return false;
+  }
+
+  int sum = 0;
+  for (int i = length - 2; i >= 0; i -= 2) {
+    int digit = (int) s[i] - (int) '0';
+    if (digit < 0 || digit > 9) {
+      return false;
+    }
+    sum += digit;
+  }
+  sum *= 3;
+  for (int i = length - 1; i >= 0; i -= 2) {
+    int digit = (int) s[i] - (int) '0';
+    if (digit < 0 || digit > 9) {
+      return false;
+    }
+    sum += digit;
+  }
+  return sum % 10 == 0;
+}
+
+UPCEANReader::~UPCEANReader() {
+}