zxing_cpp_no_cmake 0.1.1

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

@@ -0,0 +1,54 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __ITF_READER_H__
+#define __ITF_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 ITFReader : public OneDReader {
+private:
+  enum {MAX_AVG_VARIANCE = (unsigned int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 420/1000)};
+  enum {MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 780/1000)};
+  // Stores the actual narrow line width of the image being decoded.
+  int narrowLineWidth;
+			
+  Range decodeStart(Ref<BitArray> row);
+  Range decodeEnd(Ref<BitArray> row);
+  static void decodeMiddle(Ref<BitArray> row, int payloadStart, int payloadEnd, std::string& resultString);
+  void validateQuietZone(Ref<BitArray> row, int startPattern);
+  static int skipWhiteSpace(Ref<BitArray> row);
+			
+  static Range findGuardPattern(Ref<BitArray> row, int rowOffset, std::vector<int> const& pattern);
+  static int decodeDigit(std::vector<int>& counters);
+			
+  void append(char* s, char c);
+public:
+  Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+  ITFReader();
+  ~ITFReader();
+};
+
+}
+}
+
+#endif

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

@@ -0,0 +1,96 @@
+// -*- 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/MultiFormatOneDReader.h>
+#include <zxing/oned/MultiFormatUPCEANReader.h>
+#include <zxing/oned/Code39Reader.h>
+#include <zxing/oned/Code128Reader.h>
+#include <zxing/oned/Code93Reader.h>
+#include <zxing/oned/CodaBarReader.h>
+#include <zxing/oned/ITFReader.h>
+#include <zxing/ReaderException.h>
+#include <zxing/NotFoundException.h>
+
+using zxing::Ref;
+using zxing::Result;
+using zxing::oned::MultiFormatOneDReader;
+
+// VC++
+using zxing::DecodeHints;
+using zxing::BitArray;
+
+MultiFormatOneDReader::MultiFormatOneDReader(DecodeHints hints) : readers() {
+  if (hints.containsFormat(BarcodeFormat::EAN_13) ||
+      hints.containsFormat(BarcodeFormat::EAN_8) ||
+      hints.containsFormat(BarcodeFormat::UPC_A) ||
+      hints.containsFormat(BarcodeFormat::UPC_E)) {
+    readers.push_back(Ref<OneDReader>(new MultiFormatUPCEANReader(hints)));
+  }
+  if (hints.containsFormat(BarcodeFormat::CODE_39)) {
+    readers.push_back(Ref<OneDReader>(new Code39Reader()));
+  }
+  if (hints.containsFormat(BarcodeFormat::CODE_93)) {
+    readers.push_back(Ref<OneDReader>(new Code93Reader()));
+  }
+  if (hints.containsFormat(BarcodeFormat::CODE_128)) {
+    readers.push_back(Ref<OneDReader>(new Code128Reader()));
+  }
+  if (hints.containsFormat(BarcodeFormat::ITF)) {
+    readers.push_back(Ref<OneDReader>(new ITFReader()));
+  }
+  if (hints.containsFormat(BarcodeFormat::CODABAR)) {
+    readers.push_back(Ref<OneDReader>(new CodaBarReader()));
+  }
+/*
+  if (hints.containsFormat(BarcodeFormat::RSS_14)) {
+    readers.push_back(Ref<OneDReader>(new RSS14Reader()));
+  }
+*/
+/*
+  if (hints.containsFormat(BarcodeFormat::RSS_EXPANDED)) {
+    readers.push_back(Ref<OneDReader>(new RSS14ExpandedReader()));
+  }
+*/
+  if (readers.size() == 0) {
+    readers.push_back(Ref<OneDReader>(new MultiFormatUPCEANReader(hints)));
+    readers.push_back(Ref<OneDReader>(new Code39Reader()));
+    readers.push_back(Ref<OneDReader>(new CodaBarReader()));
+    readers.push_back(Ref<OneDReader>(new Code93Reader()));
+    readers.push_back(Ref<OneDReader>(new Code128Reader()));
+    readers.push_back(Ref<OneDReader>(new ITFReader()));
+    // readers.push_back(Ref<OneDReader>(new RSS14Reader()));
+    // readers.push_back(Ref<OneDReader>(new RSS14ExpandedReader()));
+  }
+}
+
+#include <typeinfo>
+
+Ref<Result> MultiFormatOneDReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+  int size = readers.size();
+  for (int i = 0; i < size; i++) {
+    OneDReader* reader = readers[i];
+    try {
+      Ref<Result> result = reader->decodeRow(rowNumber, row);
+      return result;
+    } catch (ReaderException const& re) {
+      (void)re;
+      // continue
+    }
+  }
+  throw NotFoundException();
+}

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

@@ -0,0 +1,38 @@
+#ifndef __MULTI_FORMAT_ONED_READER_H__
+#define __MULTI_FORMAT_ONED_READER_H__
+/*
+ *  MultiFormatOneDReader.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>
+
+namespace zxing {
+  namespace oned {
+    class MultiFormatOneDReader : public OneDReader {
+
+    private:
+      std::vector<Ref<OneDReader> > readers;
+    public:
+      MultiFormatOneDReader(DecodeHints hints);
+
+      Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+    };
+  }
+}
+
+#endif

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

@@ -0,0 +1,110 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  MultiFormatUPCEANReader.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/MultiFormatUPCEANReader.h>
+#include <zxing/oned/EAN13Reader.h>
+#include <zxing/oned/EAN8Reader.h>
+#include <zxing/oned/UPCEReader.h>
+#include <zxing/oned/UPCAReader.h>
+#include <zxing/oned/OneDResultPoint.h>
+#include <zxing/common/Array.h>
+#include <zxing/ReaderException.h>
+#include <zxing/NotFoundException.h>
+#include <math.h>
+
+using zxing::NotFoundException;
+using zxing::Ref;
+using zxing::Result;
+using zxing::oned::MultiFormatUPCEANReader;
+    
+// VC++
+using zxing::DecodeHints;
+using zxing::BitArray;
+
+MultiFormatUPCEANReader::MultiFormatUPCEANReader(DecodeHints hints) : readers() {
+  if (hints.containsFormat(BarcodeFormat::EAN_13)) {
+    readers.push_back(Ref<UPCEANReader>(new EAN13Reader()));
+  } else if (hints.containsFormat(BarcodeFormat::UPC_A)) {
+    readers.push_back(Ref<UPCEANReader>(new UPCAReader()));
+  }
+  if (hints.containsFormat(BarcodeFormat::EAN_8)) {
+    readers.push_back(Ref<UPCEANReader>(new EAN8Reader()));
+  }
+  if (hints.containsFormat(BarcodeFormat::UPC_E)) {
+    readers.push_back(Ref<UPCEANReader>(new UPCEReader()));
+  }
+  if (readers.size() == 0) {
+    readers.push_back(Ref<UPCEANReader>(new EAN13Reader()));
+    // UPC-A is covered by EAN-13
+    readers.push_back(Ref<UPCEANReader>(new EAN8Reader()));
+    readers.push_back(Ref<UPCEANReader>(new UPCEReader()));
+  }
+}
+
+#include <typeinfo>
+
+Ref<Result> MultiFormatUPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+  // Compute this location once and reuse it on multiple implementations
+  UPCEANReader::Range startGuardPattern = UPCEANReader::findStartGuardPattern(row);
+  for (int i = 0, e = readers.size(); i < e; i++) {
+    Ref<UPCEANReader> reader = readers[i];
+    Ref<Result> result;
+    try {
+      result = reader->decodeRow(rowNumber, row, startGuardPattern);
+    } catch (ReaderException const& ignored) {
+      (void)ignored;
+      continue;
+    }
+
+    // Special case: a 12-digit code encoded in UPC-A is identical
+    // to a "0" followed by those 12 digits encoded as EAN-13. Each
+    // will recognize such a code, UPC-A as a 12-digit string and
+    // EAN-13 as a 13-digit string starting with "0".  Individually
+    // these are correct and their readers will both read such a
+    // code and correctly call it EAN-13, or UPC-A, respectively.
+    //
+    // In this case, if we've been looking for both types, we'd like
+    // to call it a UPC-A code. But for efficiency we only run the
+    // EAN-13 decoder to also read UPC-A. So we special case it
+    // here, and convert an EAN-13 result to a UPC-A result if
+    // appropriate.
+    bool ean13MayBeUPCA =
+      result->getBarcodeFormat() == BarcodeFormat::EAN_13 &&
+      result->getText()->charAt(0) == '0';
+
+    // Note: doesn't match Java which uses hints
+
+    bool canReturnUPCA = true;
+
+    if (ean13MayBeUPCA && canReturnUPCA) {
+      // Transfer the metdata across
+      Ref<Result> resultUPCA (new Result(result->getText()->substring(1),
+                                         result->getRawBytes(),
+                                         result->getResultPoints(),
+                                         BarcodeFormat::UPC_A));
+      // needs java metadata stuff
+      return resultUPCA;
+    }
+    return result;
+  }
+
+  throw NotFoundException();
+}

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

@@ -0,0 +1,41 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __MULTI_FORMAT_UPC_EAN_READER_H__
+#define __MULTI_FORMAT_UPC_EAN_READER_H__
+/*
+ *  MultiFormatUPCEANReader.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>
+
+namespace zxing {
+namespace oned {
+
+class UPCEANReader;
+
+class MultiFormatUPCEANReader : public OneDReader {
+private:
+    std::vector< Ref<UPCEANReader> > readers;
+public:
+    MultiFormatUPCEANReader(DecodeHints hints);
+    Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+};
+
+}
+}
+
+#endif

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

@@ -0,0 +1,228 @@
+// -*- 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/OneDReader.h>
+#include <zxing/ReaderException.h>
+#include <zxing/oned/OneDResultPoint.h>
+#include <zxing/NotFoundException.h>
+#include <math.h>
+#include <limits.h>
+#include <algorithm>  // vs12, std::min und std:max
+
+using std::vector;
+using zxing::Ref;
+using zxing::Result;
+using zxing::NotFoundException;
+using zxing::oned::OneDReader;
+
+// VC++
+using zxing::BinaryBitmap;
+using zxing::BitArray;
+using zxing::DecodeHints;
+
+OneDReader::OneDReader() {}
+
+Ref<Result> OneDReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+  try {
+    return doDecode(image, hints);
+  } catch (NotFoundException const& nfe) {
+    // std::cerr << "trying harder" << std::endl;
+    bool tryHarder = hints.getTryHarder();
+    if (tryHarder && image->isRotateSupported()) {
+      // std::cerr << "v rotate" << std::endl;
+      Ref<BinaryBitmap> rotatedImage(image->rotateCounterClockwise());
+      // std::cerr << "^ rotate" << std::endl;
+      Ref<Result> result = doDecode(rotatedImage, hints);
+      // Doesn't have java metadata stuff
+      ArrayRef< Ref<ResultPoint> >& points (result->getResultPoints());
+      if (points && !points->empty()) {
+        int height = rotatedImage->getHeight();
+        for (int i = 0; i < points->size(); i++) {
+          points[i].reset(new OneDResultPoint(height - points[i]->getY() - 1, points[i]->getX()));
+        }
+      }
+      // std::cerr << "tried harder" << std::endl;
+      return result;
+    } else {
+      // std::cerr << "tried harder nfe" << std::endl;
+      throw nfe;
+    }
+  }
+}
+
+#include <typeinfo>
+
+Ref<Result> OneDReader::doDecode(Ref<BinaryBitmap> image, DecodeHints hints) {
+  int width = image->getWidth();
+  int height = image->getHeight();
+  Ref<BitArray> row(new BitArray(width));
+
+  int middle = height >> 1;
+  bool tryHarder = hints.getTryHarder();
+  int rowStep = std::max(1, height >> (tryHarder ? 8 : 5));
+  using namespace std;
+  // cerr << "rS " << rowStep << " " << height << " " << tryHarder << endl;
+  int maxLines;
+  if (tryHarder) {
+    maxLines = height; // Look at the whole image, not just the center
+  } else {
+    maxLines = 15; // 15 rows spaced 1/32 apart is roughly the middle half of the image
+  }
+
+  for (int x = 0; x < maxLines; x++) {
+
+    // Scanning from the middle out. Determine which row we're looking at next:
+    int rowStepsAboveOrBelow = (x + 1) >> 1;
+    bool isAbove = (x & 0x01) == 0; // i.e. is x even?
+    int rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);
+    if (false) {
+      std::cerr << "rN "
+                << rowNumber << " "
+                << height << " "
+                << middle << " "
+                << rowStep << " "
+                << isAbove << " "
+                << rowStepsAboveOrBelow
+                << std::endl;
+    }
+    if (rowNumber < 0 || rowNumber >= height) {
+      // Oops, if we run off the top or bottom, stop
+      break;
+    }
+
+    // Estimate black point for this row and load it:
+    try {
+      row = image->getBlackRow(rowNumber, row);
+    } catch (NotFoundException const& ignored) {
+      (void)ignored;
+      continue;
+    }
+
+    // While we have the image data in a BitArray, it's fairly cheap to reverse it in place to
+    // handle decoding upside down barcodes.
+    for (int attempt = 0; attempt < 2; attempt++) {
+      if (attempt == 1) {
+        row->reverse(); // reverse the row and continue
+      }
+
+      // Java hints stuff missing
+
+      try {
+        // Look for a barcode
+        // std::cerr << "rn " << rowNumber << " " << typeid(*this).name() << std::endl;
+        Ref<Result> result = decodeRow(rowNumber, row);
+        // We found our barcode
+        if (attempt == 1) {
+          // But it was upside down, so note that
+          // result.putMetadata(ResultMetadataType.ORIENTATION, new Integer(180));
+          // And remember to flip the result points horizontally.
+          ArrayRef< Ref<ResultPoint> > points(result->getResultPoints());
+          if (points) {
+            points[0] = Ref<ResultPoint>(new OneDResultPoint(width - points[0]->getX() - 1,
+                                                             points[0]->getY()));
+            points[1] = Ref<ResultPoint>(new OneDResultPoint(width - points[1]->getX() - 1,
+                                                             points[1]->getY()));
+            
+          }
+        }
+        return result;
+      } catch (ReaderException const& re) {
+        (void)re;
+        continue;
+      }
+    }
+  }
+  throw NotFoundException();
+}
+
+int OneDReader::patternMatchVariance(vector<int>& counters,
+                                     vector<int> const& pattern,
+                                     int maxIndividualVariance) {
+  return patternMatchVariance(counters, &pattern[0], maxIndividualVariance);
+}
+
+int OneDReader::patternMatchVariance(vector<int>& counters,
+                                     int const pattern[],
+                                     int maxIndividualVariance) {
+  int numCounters = counters.size();
+  unsigned int total = 0;
+  unsigned int patternLength = 0;
+  for (int i = 0; i < numCounters; i++) {
+    total += counters[i];
+    patternLength += pattern[i];
+  }
+  if (total < patternLength) {
+    // If we don't even have one pixel per unit of bar width, assume this is too small
+    // to reliably match, so fail:
+    return INT_MAX;
+  }
+  // We're going to fake floating-point math in integers. We just need to use more bits.
+  // Scale up patternLength so that intermediate values below like scaledCounter will have
+  // more "significant digits"
+  int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+  maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+
+  int totalVariance = 0;
+  for (int x = 0; x < numCounters; x++) {
+    int counter = counters[x] << INTEGER_MATH_SHIFT;
+    int scaledPattern = pattern[x] * unitBarWidth;
+    int variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
+    if (variance > maxIndividualVariance) {
+      return INT_MAX;
+    }
+    totalVariance += variance;
+  }
+  return totalVariance / total;
+}
+
+void OneDReader::recordPattern(Ref<BitArray> row,
+                               int start,
+                               vector<int>& counters) {
+  int numCounters = counters.size();
+  for (int i = 0; i < numCounters; i++) {
+    counters[i] = 0;
+  }
+  int end = row->getSize();
+  if (start >= end) {
+    throw NotFoundException();
+  }
+  bool isWhite = !row->get(start);
+  int counterPosition = 0;
+  int i = start;
+  while (i < end) {
+    if (row->get(i) ^ isWhite) { // that is, exactly one is true
+      counters[counterPosition]++;
+    } else {
+      counterPosition++;
+      if (counterPosition == numCounters) {
+        break;
+      } else {
+        counters[counterPosition] = 1;
+        isWhite = !isWhite;
+      }
+    }
+    i++;
+  }
+  // If we read fully the last section of pixels and filled up our counters -- or filled
+  // the last counter but ran off the side of the image, OK. Otherwise, a problem.
+  if (!(counterPosition == numCounters || (counterPosition == numCounters - 1 && i == end))) {
+    throw NotFoundException();
+  }
+}
+
+OneDReader::~OneDReader() {}