qrscanner 0.1

data/ext/qrscanner/zxing/core/src/zxing/oned/ITFReader.h

@@ -0,0 +1,56 @@
+#ifndef __ITF_READER_H__
+#define __ITF_READER_H__
+
+/*
+ *  ITFReader.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>
+#include <zxing/common/BitArray.h>
+#include <zxing/Result.h>
+
+namespace zxing {
+	namespace oned {
+		class ITFReader : public OneDReader {
+			
+		private:
+			static const unsigned int MAX_AVG_VARIANCE = (unsigned int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
+			static const int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
+			
+			// Stores the actual narrow line width of the image being decoded.
+			int narrowLineWidth;
+			
+			int* decodeStart(Ref<BitArray> row);																		//throws ReaderException
+			int* decodeEnd(Ref<BitArray> row);																				//throws ReaderException 
+			static void decodeMiddle(Ref<BitArray> row, int payloadStart, int payloadEnd, std::string& resultString);	//throws ReaderException
+			void validateQuietZone(Ref<BitArray> row, int startPattern);												//throws ReaderException 
+			static int skipWhiteSpace(Ref<BitArray> row);																//throws ReaderException 
+			
+			static int* findGuardPattern(Ref<BitArray> row, int rowOffset, const int pattern[], int patternLen);		//throws ReaderException
+			static int decodeDigit(int counters[], int countersLen);													//throws ReaderException 
+			
+			void append(char* s, char c);
+		public:
+			Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);									///throws ReaderException
+			ITFReader();
+			~ITFReader();
+		};
+	}
+}
+
+#endif

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

@@ -0,0 +1,66 @@
+/*
+ *  MultiFormatOneDReader.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 "MultiFormatOneDReader.h"
+
+#include <zxing/oned/MultiFormatUPCEANReader.h>
+#include <zxing/oned/Code39Reader.h>
+#include <zxing/oned/Code128Reader.h>
+#include <zxing/oned/ITFReader.h>
+#include <zxing/ReaderException.h>
+
+namespace zxing {
+  namespace oned {
+    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_128)) {
+        readers.push_back(Ref<OneDReader>(new Code128Reader()));
+      }
+      if (hints.containsFormat(BarcodeFormat_ITF)) {
+        readers.push_back(Ref<OneDReader>(new ITFReader()));
+      }
+      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 Code128Reader()));
+        readers.push_back(Ref<OneDReader>(new ITFReader()));
+      }
+    }
+
+    Ref<Result> MultiFormatOneDReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+      int size = readers.size();
+      for (int i = 0; i < size; i++) {
+        OneDReader* reader = readers[i];
+        Ref<Result> result = reader->decodeRow(rowNumber, row);
+        if (!result.empty()) {
+          return result;
+        }
+      }
+      return Ref<Result>();
+    }
+  }
+}

data/ext/qrscanner/zxing/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/qrscanner/zxing/core/src/zxing/oned/MultiFormatUPCEANReader.cpp

@@ -0,0 +1,87 @@
+/*
+ *  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 "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 <math.h>
+
+namespace zxing {
+  namespace oned {
+
+    MultiFormatUPCEANReader::MultiFormatUPCEANReader(DecodeHints hints) : readers() {
+      if (hints.containsFormat(BarcodeFormat_EAN_13)) {
+        readers.push_back(Ref<OneDReader>(new EAN13Reader()));
+      } else if (hints.containsFormat(BarcodeFormat_UPC_A)) {
+        readers.push_back(Ref<OneDReader>(new UPCAReader()));
+      }
+      if (hints.containsFormat(BarcodeFormat_EAN_8)) {
+        readers.push_back(Ref<OneDReader>(new EAN8Reader()));
+      }
+      if (hints.containsFormat(BarcodeFormat_UPC_E)) {
+        readers.push_back(Ref<OneDReader>(new UPCEReader()));
+      }
+      if (readers.size() == 0) {
+        readers.push_back(Ref<OneDReader>(new EAN13Reader()));
+        // UPC-A is covered by EAN-13
+        readers.push_back(Ref<OneDReader>(new EAN8Reader()));
+        readers.push_back(Ref<OneDReader>(new UPCEReader()));
+      }
+    }
+
+    Ref<Result> MultiFormatUPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+      // Compute this location once and reuse it on multiple implementations
+      int size = readers.size();
+      for (int i = 0; i < size; i++) {
+        Ref<OneDReader> reader = readers[i];
+        Ref<Result> result = reader->decodeRow(rowNumber, row);
+        if (result.empty()) {
+          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.
+        if (result->getBarcodeFormat() == BarcodeFormat_EAN_13) {
+          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;
+          }
+        }
+        return result;
+      }
+      return Ref<Result>();
+    }
+  }
+}

data/ext/qrscanner/zxing/core/src/zxing/oned/MultiFormatUPCEANReader.h

@@ -0,0 +1,38 @@
+#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 MultiFormatUPCEANReader : public OneDReader {
+
+    private:
+      std::vector<Ref<OneDReader> > readers;
+    public:
+      MultiFormatUPCEANReader(DecodeHints hints);
+
+      Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+    };
+  }
+}
+
+#endif

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

@@ -0,0 +1,206 @@
+/*
+ *  OneDReader.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 "OneDReader.h"
+#include <zxing/ReaderException.h>
+#include <zxing/oned/OneDResultPoint.h>
+#include <math.h>
+#include <limits.h>
+
+namespace zxing {
+  namespace oned {
+    using namespace std;
+
+    OneDReader::OneDReader() {
+    }
+
+    Ref<Result> OneDReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+      Ref<Result> result = doDecode(image, hints);
+      if (result.empty() && hints.getTryHarder() && image->isRotateSupported()) {
+        Ref<BinaryBitmap> rotatedImage(image->rotateCounterClockwise());
+        result = doDecode(rotatedImage, hints);
+        if (!result.empty()) {
+          /*
+          // Record that we found it rotated 90 degrees CCW / 270 degrees CW
+          Hashtable metadata = result.getResultMetadata();
+          int orientation = 270;
+          if (metadata != null && metadata.containsKey(ResultMetadataType.ORIENTATION)) {
+            // But if we found it reversed in doDecode(), add in that result here:
+            orientation = (orientation +
+                     ((Integer) metadata.get(ResultMetadataType.ORIENTATION)).intValue()) % 360;
+          }
+          result.putMetadata(ResultMetadataType.ORIENTATION, new Integer(orientation));
+          */
+          // Update result points
+          std::vector<Ref<ResultPoint> > points (result->getResultPoints());
+          int height = rotatedImage->getHeight();
+          for (size_t i = 0; i < points.size(); i++) {
+            points[i].reset(new OneDResultPoint(height - points[i]->getY() - 1, points[i]->getX()));
+          }
+        }
+      }
+      if (result.empty()) {
+        throw ReaderException("");
+      }
+      return result;
+    }
+
+    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 = (int)fmax(1, height >> (tryHarder ? 8 : 5));
+      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 (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 (ReaderException re) {
+          continue;
+        } catch (IllegalArgumentException re) {
+          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
+          }
+
+          // Look for a barcode
+          Ref<Result> result = decodeRow(rowNumber, row);
+          // We found our barcode
+          if (!result.empty()) {
+            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.
+              std::vector<Ref<ResultPoint> > points(result->getResultPoints());
+              // if there's exactly two points (which there should be), flip the x coordinate
+              // if there's not exactly 2, I don't know what do do with it
+              if (points.size() == 2) {
+                Ref<ResultPoint> pointZero(new OneDResultPoint(width - points[0]->getX() - 1,
+                    points[0]->getY()));
+                points[0] = pointZero;
+
+                Ref<ResultPoint> pointOne(new OneDResultPoint(width - points[1]->getX() - 1,
+                    points[1]->getY()));
+                points[1] = pointOne;
+
+                result.reset(new Result(result->getText(), result->getRawBytes(), points,
+                    result->getBarcodeFormat()));
+              }
+            }
+            return result;
+          }
+        }
+      }
+      return Ref<Result>();
+    }
+
+    unsigned int OneDReader::patternMatchVariance(int counters[], int countersSize,
+        const int pattern[], int maxIndividualVariance) {
+      int numCounters = countersSize;
+      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"
+      unsigned int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+      maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+
+      unsigned 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;
+    }
+
+    bool OneDReader::recordPattern(Ref<BitArray> row, int start, int counters[], int countersCount) {
+      int numCounters = countersCount;//sizeof(counters) / sizeof(int);
+      for (int i = 0; i < numCounters; i++) {
+        counters[i] = 0;
+      }
+      int end = row->getSize();
+      if (start >= end) {
+        return false;
+      }
+      bool isWhite = !row->get(start);
+      int counterPosition = 0;
+      int i = start;
+      while (i < end) {
+        bool pixel = row->get(i);
+        if (pixel ^ isWhite) { // that is, exactly one is true
+          counters[counterPosition]++;
+        } else {
+          counterPosition++;
+          if (counterPosition == numCounters) {
+            break;
+          } else {
+            counters[counterPosition] = 1;
+            isWhite ^= true; // 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))) {
+        return false;
+      }
+      return true;
+    }
+
+    OneDReader::~OneDReader() {
+    }
+  }
+}