zxing_cpp_mac_big_sur 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/common/CharacterSetECI.h

@@ -0,0 +1,53 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __CHARACTERSET_ECI__
+#define __CHARACTERSET_ECI__
+
+/*
+ * Copyright 2008-2011 ZXing authors
+ *
+ * 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 <map>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+namespace common {
+
+class CharacterSetECI : public Counted {
+private:
+  static std::map<int, zxing::Ref<CharacterSetECI> > VALUE_TO_ECI;
+  static std::map<std::string, zxing::Ref<CharacterSetECI> > NAME_TO_ECI;
+  static const bool inited;
+  static bool init_tables();
+
+  int const* const values_;
+  char const* const* const names_;
+
+  CharacterSetECI(int const* values, char const* const* names);
+
+  static void addCharacterSet(int const* value, char const* const* encodingNames);
+
+public:
+  char const* name() const;
+  int getValue() const;
+
+  static CharacterSetECI* getCharacterSetECIByValue(int value);
+  static CharacterSetECI* getCharacterSetECIByName(std::string const& name);
+};
+
+}
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/common/Counted.h

@@ -0,0 +1,140 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __COUNTED_H__
+#define __COUNTED_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 <iostream>
+
+namespace zxing {
+
+/* base class for reference-counted objects */
+class Counted {
+private:
+  unsigned int count_;
+public:
+  Counted() :
+      count_(0) {
+  }
+  virtual ~Counted() {
+  }
+  Counted *retain() {
+    count_++;
+    return this;
+  }
+  void release() {
+    count_--;
+    if (count_ == 0) {
+      count_ = 0xDEADF001;
+      delete this;
+    }
+  }
+
+
+  /* return the current count for denugging purposes or similar */
+  int count() const {
+    return count_;
+  }
+};
+
+/* counting reference to reference-counted objects */
+template<typename T> class Ref {
+private:
+public:
+  T *object_;
+  explicit Ref(T *o = 0) :
+      object_(0) {
+    reset(o);
+  }
+  Ref(const Ref &other) :
+      object_(0) {
+    reset(other.object_);
+  }
+
+  template<class Y>
+  Ref(const Ref<Y> &other) :
+      object_(0) {
+    reset(other.object_);
+  }
+
+  ~Ref() {
+    if (object_) {
+      object_->release();
+    }
+  }
+
+  void reset(T *o) {
+    if (o) {
+      o->retain();
+    }
+    if (object_ != 0) {
+      object_->release();
+    }
+    object_ = o;
+  }
+  Ref& operator=(const Ref &other) {
+    reset(other.object_);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(const Ref<Y> &other) {
+    reset(other.object_);
+    return *this;
+  }
+  Ref& operator=(T* o) {
+    reset(o);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(Y* o) {
+    reset(o);
+    return *this;
+  }
+
+  T& operator*() {
+    return *object_;
+  }
+  T* operator->() const {
+    return object_;
+  }
+  operator T*() const {
+    return object_;
+  }
+
+  bool operator==(const T* that) {
+    return object_ == that;
+  }
+  bool operator==(const Ref &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+  template<class Y>
+  bool operator==(const Ref<Y> &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+
+  bool operator!=(const T* that) {
+    return !(*this == that);
+  }
+
+  bool empty() const {
+    return object_ == 0;
+  }
+};
+
+}
+
+#endif // __COUNTED_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/DecoderResult.cpp

@@ -0,0 +1,46 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DecoderResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/05/2008.
+ *  Copyright 2008-2011 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/common/DecoderResult.h>
+
+using namespace std;
+using namespace zxing;
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes,
+                             Ref<String> text,
+                             ArrayRef< ArrayRef<char> >& byteSegments,
+                             string const& ecLevel) :
+  rawBytes_(rawBytes),
+  text_(text),
+  byteSegments_(byteSegments),
+  ecLevel_(ecLevel) {}
+
+DecoderResult::DecoderResult(ArrayRef<char> rawBytes,
+                             Ref<String> text)
+  : rawBytes_(rawBytes), text_(text) {}
+
+ArrayRef<char> DecoderResult::getRawBytes() {
+  return rawBytes_;
+}
+
+Ref<String> DecoderResult::getText() {
+  return text_;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/DecoderResult.h

@@ -0,0 +1,51 @@
+#ifndef __DECODER_RESULT_H__
+#define __DECODER_RESULT_H__
+
+/*
+ *  DecoderResult.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/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <string>
+#include <zxing/common/Str.h>
+
+namespace zxing {
+
+class DecoderResult : public Counted {
+private:
+  ArrayRef<char> rawBytes_;
+  Ref<String> text_;
+  ArrayRef< ArrayRef<char> > byteSegments_;
+  std::string ecLevel_;
+
+public:
+  DecoderResult(ArrayRef<char> rawBytes,
+                Ref<String> text,
+                ArrayRef< ArrayRef<char> >& byteSegments,
+                std::string const& ecLevel);
+
+  DecoderResult(ArrayRef<char> rawBytes, Ref<String> text);
+
+  ArrayRef<char> getRawBytes();
+  Ref<String> getText();
+};
+
+}
+
+#endif // __DECODER_RESULT_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/DetectorResult.cpp

@@ -0,0 +1,39 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DetectorResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 14/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/common/DetectorResult.h>
+
+namespace zxing {
+
+DetectorResult::DetectorResult(Ref<BitMatrix> bits,
+                               ArrayRef< Ref<ResultPoint> > points)
+  : bits_(bits), points_(points) {
+}
+
+Ref<BitMatrix> DetectorResult::getBits() {
+  return bits_;
+}
+
+ArrayRef< Ref<ResultPoint> > DetectorResult::getPoints() {
+  return points_;
+}
+
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/DetectorResult.h

@@ -0,0 +1,43 @@
+#ifndef __DETECTOR_RESULT_H__
+#define __DETECTOR_RESULT_H__
+
+/*
+ *  DetectorResult.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/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/ResultPoint.h>
+
+namespace zxing {
+
+class DetectorResult : public Counted {
+private:
+  Ref<BitMatrix> bits_;
+  ArrayRef< Ref<ResultPoint> > points_;
+
+public:
+  DetectorResult(Ref<BitMatrix> bits, ArrayRef< Ref<ResultPoint> > points);
+  Ref<BitMatrix> getBits();
+  ArrayRef< Ref<ResultPoint> > getPoints();
+};
+
+}
+
+#endif // __DETECTOR_RESULT_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/GlobalHistogramBinarizer.cpp

@@ -0,0 +1,212 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  GlobalHistogramBinarizer.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/common/GlobalHistogramBinarizer.h>
+#include <zxing/NotFoundException.h>
+#include <zxing/common/Array.h>
+
+using zxing::GlobalHistogramBinarizer;
+using zxing::Binarizer;
+using zxing::ArrayRef;
+using zxing::Ref;
+using zxing::BitArray;
+using zxing::BitMatrix;
+
+// VC++
+using zxing::LuminanceSource;
+
+namespace {
+  const int LUMINANCE_BITS = 5;
+  const int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+  const int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+  const ArrayRef<char> EMPTY (0);
+}
+
+GlobalHistogramBinarizer::GlobalHistogramBinarizer(Ref<LuminanceSource> source) 
+  : Binarizer(source), luminances(EMPTY), buckets(LUMINANCE_BUCKETS) {}
+
+GlobalHistogramBinarizer::~GlobalHistogramBinarizer() {}
+
+void GlobalHistogramBinarizer::initArrays(int luminanceSize) {
+  if (luminances->size() < luminanceSize) {
+    luminances = ArrayRef<char>(luminanceSize);
+  }
+  for (int x = 0; x < LUMINANCE_BUCKETS; x++) {
+    buckets[x] = 0;
+  }
+}
+
+Ref<BitArray> GlobalHistogramBinarizer::getBlackRow(int y, Ref<BitArray> row) {
+  // std::cerr << "gbr " << y << std::endl;
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  if (row == NULL || static_cast<int>(row->getSize()) < width) {
+    row = new BitArray(width);
+  } else {
+    row->clear();
+  }
+
+  initArrays(width);
+  ArrayRef<char> localLuminances = source.getRow(y, luminances);
+  if (false) {
+    std::cerr << "gbr " << y << " r ";
+    for(int i=0, e=localLuminances->size(); i < e; ++i) {
+      std::cerr << 0+localLuminances[i] << " ";
+    }
+    std::cerr << std::endl;
+  }
+  ArrayRef<int> localBuckets = buckets;
+  for (int x = 0; x < width; x++) {
+    int pixel = localLuminances[x] & 0xff;
+    localBuckets[pixel >> LUMINANCE_SHIFT]++;
+  }
+  int blackPoint = estimateBlackPoint(localBuckets);
+  // std::cerr << "gbr bp " << y << " " << blackPoint << std::endl;
+
+  int left = localLuminances[0] & 0xff;
+  int center = localLuminances[1] & 0xff;
+  for (int x = 1; x < width - 1; x++) {
+    int right = localLuminances[x + 1] & 0xff;
+    // A simple -1 4 -1 box filter with a weight of 2.
+    int luminance = ((center << 2) - left - right) >> 1;
+    if (luminance < blackPoint) {
+      row->set(x);
+    }
+    left = center;
+    center = right;
+  }
+  return row;
+}
+ 
+Ref<BitMatrix> GlobalHistogramBinarizer::getBlackMatrix() {
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  int height = source.getHeight();
+  Ref<BitMatrix> matrix(new BitMatrix(width, height));
+
+  // Quickly calculates the histogram by sampling four rows from the image.
+  // This proved to be more robust on the blackbox tests than sampling a
+  // diagonal as we used to do.
+  initArrays(width);
+  ArrayRef<int> localBuckets = buckets;
+  for (int y = 1; y < 5; y++) {
+    int row = height * y / 5;
+    ArrayRef<char> localLuminances = source.getRow(row, luminances);
+    int right = (width << 2) / 5;
+    for (int x = width / 5; x < right; x++) {
+      int pixel = localLuminances[x] & 0xff;
+      localBuckets[pixel >> LUMINANCE_SHIFT]++;
+    }
+  }
+
+  int blackPoint = estimateBlackPoint(localBuckets);
+
+  ArrayRef<char> localLuminances = source.getMatrix();
+  for (int y = 0; y < height; y++) {
+    int offset = y * width;
+    for (int x = 0; x < width; x++) {
+      int pixel = localLuminances[offset + x] & 0xff;
+      if (pixel < blackPoint) {
+        matrix->set(x, y);
+      }
+    }
+  }
+  
+  return matrix;
+}
+
+using namespace std;
+
+int GlobalHistogramBinarizer::estimateBlackPoint(ArrayRef<int> const& buckets) {
+  // Find tallest peak in histogram
+  int numBuckets = buckets->size();
+  int maxBucketCount = 0;
+  int firstPeak = 0;
+  int firstPeakSize = 0;
+  if (false) {
+    for (int x = 0; x < numBuckets; x++) {
+      cerr << buckets[x] << " ";
+    }
+    cerr << endl;
+  }
+  for (int x = 0; x < numBuckets; x++) {
+    if (buckets[x] > firstPeakSize) {
+      firstPeak = x;
+      firstPeakSize = buckets[x];
+    }
+    if (buckets[x] > maxBucketCount) {
+      maxBucketCount = buckets[x];
+    }
+  }
+
+  // Find second-tallest peak -- well, another peak that is tall and not
+  // so close to the first one
+  int secondPeak = 0;
+  int secondPeakScore = 0;
+  for (int x = 0; x < numBuckets; x++) {
+    int distanceToBiggest = x - firstPeak;
+    // Encourage more distant second peaks by multiplying by square of distance
+    int score = buckets[x] * distanceToBiggest * distanceToBiggest;
+    if (score > secondPeakScore) {
+      secondPeak = x;
+      secondPeakScore = score;
+    }
+  }
+
+  if (firstPeak > secondPeak) {
+    int temp = firstPeak;
+    firstPeak = secondPeak;
+    secondPeak = temp;
+  }
+
+  // Kind of arbitrary; if the two peaks are very close, then we figure there is
+  // so little dynamic range in the image, that discriminating black and white
+  // is too error-prone.
+  // Decoding the image/line is either pointless, or may in some cases lead to
+  // a false positive for 1D formats, which are relatively lenient.
+  // We arbitrarily say "close" is
+  // "<= 1/16 of the total histogram buckets apart"
+  // std::cerr << "! " << secondPeak << " " << firstPeak << " " << numBuckets << std::endl;
+  if (secondPeak - firstPeak <= numBuckets >> 4) {
+    throw NotFoundException();
+  }
+
+  // Find a valley between them that is low and closer to the white peak
+  int bestValley = secondPeak - 1;
+  int bestValleyScore = -1;
+  for (int x = secondPeak - 1; x > firstPeak; x--) {
+    int fromFirst = x - firstPeak;
+    // Favor a "valley" that is not too close to either peak -- especially not
+    // the black peak -- and that has a low value of course
+    int score = fromFirst * fromFirst * (secondPeak - x) *
+      (maxBucketCount - buckets[x]);
+    if (score > bestValleyScore) {
+      bestValley = x;
+      bestValleyScore = score;
+    }
+  }
+
+  // std::cerr << "bps " << (bestValley << LUMINANCE_SHIFT) << std::endl;
+  return bestValley << LUMINANCE_SHIFT;
+}
+
+Ref<Binarizer> GlobalHistogramBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+  return Ref<Binarizer> (new GlobalHistogramBinarizer(source));
+}