rhodes 5.5.15 → 5.5.17

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/QRDecoder.cpp

@@ -0,0 +1,107 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Decoder.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/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/qrcode/decoder/Decoder.h>
+#include <zxing/qrcode/decoder/BitMatrixParser.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+#include <zxing/qrcode/Version.h>
+#include <zxing/qrcode/decoder/DataBlock.h>
+#include <zxing/qrcode/decoder/DecodedBitStreamParser.h>
+#include <zxing/ReaderException.h>
+#include <zxing/ChecksumException.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+
+using zxing::qrcode::Decoder;
+using zxing::DecoderResult;
+using zxing::Ref;
+
+// VC++
+using zxing::ArrayRef;
+using zxing::BitMatrix;
+
+Decoder::Decoder() :
+  rsDecoder_(GenericGF::QR_CODE_FIELD_256) {
+}
+
+void Decoder::correctErrors(ArrayRef<char> codewordBytes, int numDataCodewords) {
+  int numCodewords = codewordBytes->size();
+  ArrayRef<int> codewordInts(numCodewords);
+  for (int i = 0; i < numCodewords; i++) {
+    codewordInts[i] = codewordBytes[i] & 0xff;
+  }
+  int numECCodewords = numCodewords - numDataCodewords;
+
+  try {
+    rsDecoder_.decode(codewordInts, numECCodewords);
+  } catch (ReedSolomonException const& ignored) {
+    (void)ignored;
+    throw ChecksumException();
+  }
+
+  for (int i = 0; i < numDataCodewords; i++) {
+    codewordBytes[i] = (char)codewordInts[i];
+  }
+}
+
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
+  // Construct a parser and read version, error-correction level
+  BitMatrixParser parser(bits);
+
+  // std::cerr << *bits << std::endl;
+
+  Version *version = parser.readVersion();
+  ErrorCorrectionLevel &ecLevel = parser.readFormatInformation()->getErrorCorrectionLevel();
+
+
+  // Read codewords
+  ArrayRef<char> codewords(parser.readCodewords());
+
+
+  // Separate into data blocks
+  std::vector<Ref<DataBlock> > dataBlocks(DataBlock::getDataBlocks(codewords, version, ecLevel));
+
+
+  // Count total number of data bytes
+  int totalBytes = 0;
+  for (size_t i = 0; i < dataBlocks.size(); i++) {
+    totalBytes += dataBlocks[i]->getNumDataCodewords();
+  }
+  ArrayRef<char> resultBytes(totalBytes);
+  int resultOffset = 0;
+
+
+  // Error-correct and copy data blocks together into a stream of bytes
+  for (size_t j = 0; j < dataBlocks.size(); j++) {
+    Ref<DataBlock> dataBlock(dataBlocks[j]);
+    ArrayRef<char> codewordBytes = dataBlock->getCodewords();
+    int numDataCodewords = dataBlock->getNumDataCodewords();
+    correctErrors(codewordBytes, numDataCodewords);
+    for (int i = 0; i < numDataCodewords; i++) {
+      resultBytes[resultOffset++] = codewordBytes[i];
+    }
+  }
+
+  return DecodedBitStreamParser::decode(resultBytes,
+                                        version,
+                                        ecLevel,
+                                        DecodedBitStreamParser::Hashtable());
+}
+

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/decoder/QRMode.cpp

@@ -0,0 +1,118 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Mode.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 19/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/ZXing.h>
+#include <zxing/qrcode/decoder/Mode.h>
+#include <zxing/common/Counted.h>
+#include <zxing/ReaderException.h>
+#include <zxing/qrcode/Version.h>
+#include <sstream>
+
+using zxing::qrcode::Mode;
+using std::ostringstream;
+
+// VC++
+using zxing::qrcode::Version;
+
+Mode Mode::TERMINATOR(0, 0, 0, 0x00, "TERMINATOR");
+Mode Mode::NUMERIC(10, 12, 14, 0x01, "NUMERIC");
+Mode Mode::ALPHANUMERIC(9, 11, 13, 0x02, "ALPHANUMERIC");
+Mode Mode::STRUCTURED_APPEND(0, 0, 0, 0x03, "STRUCTURED_APPEND");
+Mode Mode::BYTE(8, 16, 16, 0x04, "BYTE");
+Mode Mode::ECI(0, 0, 0, 0x07, "ECI");
+Mode Mode::KANJI(8, 10, 12, 0x08, "KANJI");
+Mode Mode::FNC1_FIRST_POSITION(0, 0, 0, 0x05, "FNC1_FIRST_POSITION");
+Mode Mode::FNC1_SECOND_POSITION(0, 0, 0, 0x09, "FNC1_SECOND_POSITION");
+Mode Mode::HANZI(8, 10, 12, 0x0D, "HANZI");
+
+Mode::Mode() :
+    characterCountBitsForVersions0To9_(0),
+    characterCountBitsForVersions10To26_(0),
+    characterCountBitsForVersions27AndHigher_(0),
+    bits_(0),
+    name_("")
+{}
+
+Mode::Mode(int cbv0_9, int cbv10_26, int cbv27, int bits, char const* name) :
+    characterCountBitsForVersions0To9_(cbv0_9), characterCountBitsForVersions10To26_(cbv10_26),
+    characterCountBitsForVersions27AndHigher_(cbv27), bits_(bits), name_(name)
+{
+}
+
+Mode::Mode(const zxing::qrcode::Mode &mode)
+{
+    characterCountBitsForVersions0To9_ = mode.characterCountBitsForVersions0To9_;
+    characterCountBitsForVersions10To26_ = mode.characterCountBitsForVersions10To26_;
+    characterCountBitsForVersions27AndHigher_ = mode.characterCountBitsForVersions27AndHigher_;
+    bits_ = mode.bits_;
+    name_ = mode.name_;
+}
+
+Mode& Mode::forBits(int bits) {
+    switch (bits) {
+    case 0x0:
+        return TERMINATOR;
+    case 0x1:
+        return NUMERIC;
+    case 0x2:
+        return ALPHANUMERIC;
+    case 0x3:
+        return STRUCTURED_APPEND;
+    case 0x4:
+        return BYTE;
+    case 0x5:
+        return FNC1_FIRST_POSITION;
+    case 0x7:
+        return ECI;
+    case 0x8:
+        return KANJI;
+    case 0x9:
+        return FNC1_SECOND_POSITION;
+    case 0xD:
+        // 0xD is defined in GBT 18284-2000, may not be supported in foreign country
+        return HANZI;
+    default:
+        ostringstream s;
+        s << "Illegal mode bits: " << bits;
+        throw ReaderException(s.str().c_str());
+    }
+}
+
+int Mode::getCharacterCountBits(const Version *version) const
+{
+    int number = version->getVersionNumber();
+    if (number <= 9) {
+        return characterCountBitsForVersions0To9_;
+    } else if (number <= 26) {
+        return characterCountBitsForVersions10To26_;
+    } else {
+        return characterCountBitsForVersions27AndHigher_;
+    }
+}
+
+bool Mode::operator==(const Mode& other)
+{
+    return ( characterCountBitsForVersions0To9_ == other.characterCountBitsForVersions0To9_
+            && characterCountBitsForVersions10To26_ == other.characterCountBitsForVersions10To26_
+            && characterCountBitsForVersions27AndHigher_ == other.characterCountBitsForVersions27AndHigher_
+            && name_ == other.name_
+            && bits_ == other.bits_ );
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/detector/AlignmentPattern.h

@@ -0,0 +1,45 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __ALIGNMENT_PATTERN_H__
+#define __ALIGNMENT_PATTERN_H__
+
+/*
+ *  AlignmentPattern.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/ResultPoint.h>
+#include <cmath>
+
+namespace zxing {
+	namespace qrcode {
+		
+		class AlignmentPattern : public ResultPoint {
+		private:
+			float estimatedModuleSize_;
+			
+		public:
+			AlignmentPattern(float posX, float posY, float estimatedModuleSize);
+			bool aboutEquals(float moduleSize, float i, float j) const;
+      Ref<AlignmentPattern> combineEstimate(float i, float j,
+                                            float newModuleSize) const;
+		};
+		
+	}
+}
+
+#endif // __ALIGNMENT_PATTERN_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/detector/AlignmentPatternFinder.h

@@ -0,0 +1,68 @@
+#ifndef __ALIGNMENT_PATTERN_FINDER_H__
+#define __ALIGNMENT_PATTERN_FINDER_H__
+
+/*
+ *  AlignmentPatternFinder.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 "AlignmentPattern.h"
+#include <zxing/common/Counted.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/ResultPointCallback.h>
+#include <vector>
+
+namespace zxing {
+namespace qrcode {
+
+class AlignmentPatternFinder : public Counted {
+private:
+  static int CENTER_QUORUM;
+  static int MIN_SKIP;
+  static int MAX_MODULES;
+
+  Ref<BitMatrix> image_;
+  std::vector<AlignmentPattern *> *possibleCenters_;
+  int startX_;
+  int startY_;
+  int width_;
+  int height_;
+  float moduleSize_;
+
+  static float centerFromEnd(std::vector<int> &stateCount, int end);
+  bool foundPatternCross(std::vector<int> &stateCount);
+
+  float crossCheckVertical(int startI, int centerJ, int maxCount, int originalStateCountTotal);
+
+  Ref<AlignmentPattern> handlePossibleCenter(std::vector<int> &stateCount, int i, int j);
+
+public:
+  AlignmentPatternFinder(Ref<BitMatrix> image, int startX, int startY, int width, int height,
+                         float moduleSize, Ref<ResultPointCallback>const& callback);
+  ~AlignmentPatternFinder();
+  Ref<AlignmentPattern> find();
+  
+private:
+  AlignmentPatternFinder(const AlignmentPatternFinder&);
+  AlignmentPatternFinder& operator =(const AlignmentPatternFinder&);
+  
+  Ref<ResultPointCallback> callback_;
+};
+}
+}
+
+#endif // __ALIGNMENT_PATTERN_FINDER_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/detector/Detector.h

@@ -0,0 +1,69 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __DETECTOR_H__
+#define __DETECTOR_H__
+
+/*
+ *  Detector.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/DetectorResult.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/qrcode/detector/AlignmentPattern.h>
+#include <zxing/common/PerspectiveTransform.h>
+#include <zxing/ResultPointCallback.h>
+#include <zxing/qrcode/detector/FinderPatternInfo.h>
+
+namespace zxing {
+
+class DecodeHints;
+
+namespace qrcode {
+
+class Detector : public Counted {
+private:
+  Ref<BitMatrix> image_;
+  Ref<ResultPointCallback> callback_;
+
+protected:
+  Ref<BitMatrix> getImage() const;
+  Ref<ResultPointCallback> getResultPointCallback() const;
+
+  static Ref<BitMatrix> sampleGrid(Ref<BitMatrix> image, int dimension, Ref<PerspectiveTransform>);
+  static int computeDimension(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft,
+                              float moduleSize);
+  float calculateModuleSize(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft);
+  float calculateModuleSizeOneWay(Ref<ResultPoint> pattern, Ref<ResultPoint> otherPattern);
+  float sizeOfBlackWhiteBlackRunBothWays(int fromX, int fromY, int toX, int toY);
+  float sizeOfBlackWhiteBlackRun(int fromX, int fromY, int toX, int toY);
+  Ref<AlignmentPattern> findAlignmentInRegion(float overallEstModuleSize, int estAlignmentX, int estAlignmentY,
+      float allowanceFactor);
+  Ref<DetectorResult> processFinderPatternInfo(Ref<FinderPatternInfo> info);
+public:
+  virtual Ref<PerspectiveTransform> createTransform(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref <
+      ResultPoint > bottomLeft, Ref<ResultPoint> alignmentPattern, int dimension);
+
+  Detector(Ref<BitMatrix> image);
+  Ref<DetectorResult> detect(DecodeHints const& hints);
+
+
+};
+}
+}
+
+#endif // __DETECTOR_H__

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/qrcode/detector/FinderPattern.h

@@ -0,0 +1,48 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __FINDER_PATTERN_H__
+#define __FINDER_PATTERN_H__
+
+/*
+ *  FinderPattern.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/ResultPoint.h>
+#include <cmath>
+
+namespace zxing {
+	namespace qrcode {
+		
+		class FinderPattern : public ResultPoint {
+		private:
+			float estimatedModuleSize_;
+			int count_;
+			
+			FinderPattern(float posX, float posY, float estimatedModuleSize, int count);
+
+		public:
+			FinderPattern(float posX, float posY, float estimatedModuleSize);
+			int getCount() const;
+			float getEstimatedModuleSize() const;
+			void incrementCount();
+			bool aboutEquals(float moduleSize, float i, float j) const;
+			Ref<FinderPattern> combineEstimate(float i, float j, float newModuleSize) const;
+		};
+	}
+}
+
+#endif // __FINDER_PATTERN_H__