rhodes 5.5.15 → 5.5.17

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/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));
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/GlobalHistogramBinarizer.h

@@ -0,0 +1,48 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __GLOBALHISTOGRAMBINARIZER_H__
+#define __GLOBALHISTOGRAMBINARIZER_H__
+/*
+ *  GlobalHistogramBinarizer.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/Binarizer.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Array.h>
+
+namespace zxing {
+	
+class GlobalHistogramBinarizer : public Binarizer {
+private:
+  ArrayRef<char> luminances;
+  ArrayRef<int> buckets;
+public:
+  GlobalHistogramBinarizer(Ref<LuminanceSource> source);
+  virtual ~GlobalHistogramBinarizer();
+		
+  virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row);
+  virtual Ref<BitMatrix> getBlackMatrix();
+  static int estimateBlackPoint(ArrayRef<int> const& buckets);
+  Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source);
+private:
+  void initArrays(int luminanceSize);
+};
+
+}
+	
+#endif /* GLOBALHISTOGRAMBINARIZER_H_ */

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/GreyscaleLuminanceSource.cpp

@@ -0,0 +1,80 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  GreyscaleLuminanceSource.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/GreyscaleLuminanceSource.h>
+#include <zxing/common/GreyscaleRotatedLuminanceSource.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+using zxing::Ref;
+using zxing::ArrayRef;
+using zxing::LuminanceSource;
+using zxing::GreyscaleLuminanceSource;
+
+GreyscaleLuminanceSource::
+GreyscaleLuminanceSource(ArrayRef<char> greyData,
+                         int dataWidth, int dataHeight,
+                         int left, int top,
+                         int width, int height) 
+    : Super(width, height),
+      greyData_(greyData),
+      dataWidth_(dataWidth), dataHeight_(dataHeight),
+      left_(left), top_(top) {
+
+  if (left + width > dataWidth || top + height > dataHeight || top < 0 || left < 0) {
+    throw IllegalArgumentException("Crop rectangle does not fit within image data.");
+  }
+}
+
+ArrayRef<char> GreyscaleLuminanceSource::getRow(int y, ArrayRef<char> row) const {
+  if (y < 0 || y >= this->getHeight()) {
+    throw IllegalArgumentException("Requested row is outside the image.");
+  }
+  int width = getWidth();
+  if (!row || row->size() < width) {
+    ArrayRef<char> temp (width);
+    row = temp;
+  }
+  int offset = (y + top_) * dataWidth_ + left_;
+  memcpy(&row[0], &greyData_[offset], width);
+  return row;
+}
+
+ArrayRef<char> GreyscaleLuminanceSource::getMatrix() const {
+  int size = getWidth() * getHeight();
+  ArrayRef<char> result (size);
+  if (left_ == 0 && top_ == 0 && dataWidth_ == getWidth() && dataHeight_ == getHeight()) {
+    memcpy(&result[0], &greyData_[0], size);
+  } else {
+    for (int row = 0; row < getHeight(); row++) {
+      memcpy(&result[row * getWidth()], &greyData_[(top_ + row) * dataWidth_ + left_], getWidth());
+    }
+  }
+  return result;
+}
+
+Ref<LuminanceSource> GreyscaleLuminanceSource::rotateCounterClockwise() const {
+  // Intentionally flip the left, top, width, and height arguments as
+  // needed. dataWidth and dataHeight are always kept unrotated.
+  Ref<LuminanceSource> result ( 
+      new GreyscaleRotatedLuminanceSource(greyData_,
+                                          dataWidth_, dataHeight_,
+                                          top_, left_, getHeight(), getWidth()));
+  return result;
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/GreyscaleLuminanceSource.h

@@ -0,0 +1,53 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __GREYSCALE_LUMINANCE_SOURCE__
+#define __GREYSCALE_LUMINANCE_SOURCE__
+/*
+ *  GreyscaleLuminanceSource.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/LuminanceSource.h>
+
+namespace zxing {
+
+class GreyscaleLuminanceSource : public LuminanceSource {
+
+private:
+  typedef LuminanceSource Super;
+  ArrayRef<char> greyData_;
+  const int dataWidth_;
+  const int dataHeight_;
+  const int left_;
+  const int top_;
+
+public:
+  GreyscaleLuminanceSource(ArrayRef<char> greyData, int dataWidth, int dataHeight, int left,
+                           int top, int width, int height);
+
+  ArrayRef<char> getRow(int y, ArrayRef<char> row) const;
+  ArrayRef<char> getMatrix() const;
+
+  bool isRotateSupported() const {
+    return true;
+  }
+
+  Ref<LuminanceSource> rotateCounterClockwise() const;
+};
+
+}
+
+#endif

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/common/GreyscaleRotatedLuminanceSource.cpp

@@ -0,0 +1,81 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  GreyscaleRotatedLuminanceSource.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/GreyscaleRotatedLuminanceSource.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+using zxing::ArrayRef;
+using zxing::GreyscaleRotatedLuminanceSource;
+
+// Note that dataWidth and dataHeight are not reversed, as we need to
+// be able to traverse the greyData correctly, which does not get
+// rotated.
+GreyscaleRotatedLuminanceSource::
+GreyscaleRotatedLuminanceSource(ArrayRef<char> greyData,
+                                int dataWidth, int dataHeight,
+                                int left, int top,
+                                int width, int height)
+    : Super(width, height),
+      greyData_(greyData),
+      dataWidth_(dataWidth),
+      left_(left), top_(top) {
+  // Intentionally comparing to the opposite dimension since we're rotated.
+  if (left + width > dataHeight || top + height > dataWidth) {
+    throw IllegalArgumentException("Crop rectangle does not fit within image data.");
+  }
+}
+
+// The API asks for rows, but we're rotated, so we return columns.
+ArrayRef<char>
+GreyscaleRotatedLuminanceSource::getRow(int y, ArrayRef<char> row) const {
+  if (y < 0 || y >= getHeight()) {
+    throw IllegalArgumentException("Requested row is outside the image.");
+  }
+  if (!row || row->size() < getWidth()) {
+    row = ArrayRef<char>(getWidth());
+  }
+  int offset = (left_ * dataWidth_) + (dataWidth_ - 1 - (y + top_));
+  using namespace std;
+  if (false) {
+    cerr << offset << " = "
+         << top_ << " " << left_ << " "
+         << getHeight() << " " << getWidth() << " "
+         << y << endl;
+  }
+  for (int x = 0; x < getWidth(); x++) {
+    row[x] = greyData_[offset];
+    offset += dataWidth_;
+  }
+  return row;
+}
+
+ArrayRef<char> GreyscaleRotatedLuminanceSource::getMatrix() const {
+  ArrayRef<char> result (getWidth() * getHeight());
+  for (int y = 0; y < getHeight(); y++) {
+    char* row = &result[y * getWidth()];
+    int offset = (left_ * dataWidth_) + (dataWidth_ - 1 - (y + top_));
+    for (int x = 0; x < getWidth(); x++) {
+      row[x] = greyData_[offset];
+      offset += dataWidth_;
+    }
+  }
+  return result;
+}