zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/src/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/ext/zxing/zxing-cpp/core/src/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/ext/zxing/zxing-cpp/core/src/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/ext/zxing/zxing-cpp/core/src/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;
+}

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

@@ -0,0 +1,46 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __GREYSCALE_ROTATED_LUMINANCE_SOURCE__
+#define __GREYSCALE_ROTATED_LUMINANCE_SOURCE__
+/*
+ *  GreyscaleRotatedLuminanceSource.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 GreyscaleRotatedLuminanceSource : public LuminanceSource {
+ private:
+  typedef LuminanceSource Super;
+  ArrayRef<char> greyData_;
+  const int dataWidth_;
+  const int left_;
+  const int top_;
+
+public:
+  GreyscaleRotatedLuminanceSource(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;
+};
+
+}
+
+#endif

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

@@ -0,0 +1,122 @@
+/*
+ *  GridSampler.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 18/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/GridSampler.h>
+#include <zxing/common/PerspectiveTransform.h>
+#include <zxing/ReaderException.h>
+#include <iostream>
+#include <sstream>
+
+namespace zxing {
+using namespace std;
+
+GridSampler GridSampler::gridSampler;
+
+GridSampler::GridSampler() {
+}
+
+Ref<BitMatrix> GridSampler::sampleGrid(Ref<BitMatrix> image, int dimension, Ref<PerspectiveTransform> transform) {
+  Ref<BitMatrix> bits(new BitMatrix(dimension));
+  vector<float> points(dimension << 1, (const float)0.0f);
+  for (int y = 0; y < dimension; y++) {
+    int max = points.size();
+    float yValue = (float)y + 0.5f;
+    for (int x = 0; x < max; x += 2) {
+      points[x] = (float)(x >> 1) + 0.5f;
+      points[x + 1] = yValue;
+    }
+    transform->transformPoints(points);
+    checkAndNudgePoints(image, points);
+    for (int x = 0; x < max; x += 2) {
+      if (image->get((int)points[x], (int)points[x + 1])) {
+        bits->set(x >> 1, y);
+      }
+    }
+  }
+  return bits;
+}
+
+Ref<BitMatrix> GridSampler::sampleGrid(Ref<BitMatrix> image, int dimensionX, int dimensionY, Ref<PerspectiveTransform> transform) {
+  Ref<BitMatrix> bits(new BitMatrix(dimensionX, dimensionY));
+  vector<float> points(dimensionX << 1, (const float)0.0f);
+  for (int y = 0; y < dimensionY; y++) {
+    int max = points.size();
+    float yValue = (float)y + 0.5f;
+    for (int x = 0; x < max; x += 2) {
+      points[x] = (float)(x >> 1) + 0.5f;
+      points[x + 1] = yValue;
+    }
+    transform->transformPoints(points);
+    checkAndNudgePoints(image, points);
+    for (int x = 0; x < max; x += 2) {
+      if (image->get((int)points[x], (int)points[x + 1])) {
+        bits->set(x >> 1, y);
+      }
+    }
+  }
+  return bits;
+}
+
+Ref<BitMatrix> GridSampler::sampleGrid(Ref<BitMatrix> image, int dimension, float p1ToX, float p1ToY, float p2ToX,
+                                       float p2ToY, float p3ToX, float p3ToY, float p4ToX, float p4ToY, float p1FromX, float p1FromY, float p2FromX,
+                                       float p2FromY, float p3FromX, float p3FromY, float p4FromX, float p4FromY) {
+  Ref<PerspectiveTransform> transform(PerspectiveTransform::quadrilateralToQuadrilateral(p1ToX, p1ToY, p2ToX, p2ToY,
+                                      p3ToX, p3ToY, p4ToX, p4ToY, p1FromX, p1FromY, p2FromX, p2FromY, p3FromX, p3FromY, p4FromX, p4FromY));
+
+  return sampleGrid(image, dimension, transform);
+
+}
+
+void GridSampler::checkAndNudgePoints(Ref<BitMatrix> image, vector<float> &points) {
+  int width = image->getWidth();
+  int height = image->getHeight();
+
+
+  // The Java code assumes that if the start and end points are in bounds, the rest will also be.
+  // However, in some unusual cases points in the middle may also be out of bounds.
+  // Since we can't rely on an ArrayIndexOutOfBoundsException like Java, we check every point.
+
+  for (size_t offset = 0; offset < points.size(); offset += 2) {
+    int x = (int)points[offset];
+    int y = (int)points[offset + 1];
+    if (x < -1 || x > width || y < -1 || y > height) {
+      ostringstream s;
+      s << "Transformed point out of bounds at " << x << "," << y;
+      throw ReaderException(s.str().c_str());
+    }
+
+    if (x == -1) {
+      points[offset] = 0.0f;
+    } else if (x == width) {
+      points[offset] = float(width - 1);
+    }
+    if (y == -1) {
+      points[offset + 1] = 0.0f;
+    } else if (y == height) {
+      points[offset + 1] = float(height - 1);
+    }
+  }
+
+}
+
+GridSampler &GridSampler::getInstance() {
+  return gridSampler;
+}
+}

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

@@ -0,0 +1,45 @@
+#ifndef __GRID_SAMPLER_H__
+#define __GRID_SAMPLER_H__
+
+/*
+ *  GridSampler.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/BitMatrix.h>
+#include <zxing/common/PerspectiveTransform.h>
+
+namespace zxing {
+class GridSampler {
+private:
+  static GridSampler gridSampler;
+  GridSampler();
+
+public:
+  Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimension, Ref<PerspectiveTransform> transform);
+  Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimensionX, int dimensionY, Ref<PerspectiveTransform> transform);
+
+  Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimension, float p1ToX, float p1ToY, float p2ToX, float p2ToY,
+                            float p3ToX, float p3ToY, float p4ToX, float p4ToY, float p1FromX, float p1FromY, float p2FromX,
+                            float p2FromY, float p3FromX, float p3FromY, float p4FromX, float p4FromY);
+  static void checkAndNudgePoints(Ref<BitMatrix> image, std::vector<float> &points);
+  static GridSampler &getInstance();
+};
+}
+
+#endif // __GRID_SAMPLER_H__