|
| xqd
@@ -0,0 +1,11982 @@
|
|
|
+
|
|
|
+#include "zxing-all-in-one.h"
|
|
|
+
|
|
|
+// file: zxing/BarcodeFormat.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Created by Christian Brunschen on 13/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/BarcodeFormat.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+const char *barcodeFormatNames[] = {
|
|
|
+ "None",
|
|
|
+ "QR_CODE",
|
|
|
+ "DATA_MATRIX",
|
|
|
+ "UPC_E",
|
|
|
+ "UPC_A",
|
|
|
+ "EAN_8",
|
|
|
+ "EAN_13",
|
|
|
+ "CODE_128",
|
|
|
+ "CODE_39",
|
|
|
+ "ITF"
|
|
|
+};
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/Binarizer.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Binarizer.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Ralf Kistner on 16/10/2009.
|
|
|
+ * Copyright 2008 ZXing authors All rights reserved.
|
|
|
+ * Modified by Lukasz Warchol on 02/02/2010.
|
|
|
+ *
|
|
|
+ * 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>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ Binarizer::Binarizer(Ref<LuminanceSource> source) : source_(source) {
|
|
|
+ }
|
|
|
+
|
|
|
+ Binarizer::~Binarizer() {
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<LuminanceSource> Binarizer::getLuminanceSource() const {
|
|
|
+ return source_;
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/BinaryBitmap.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * BinaryBitmap.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/BinaryBitmap.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ BinaryBitmap::BinaryBitmap(Ref<Binarizer> binarizer) : binarizer_(binarizer) {
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ BinaryBitmap::~BinaryBitmap() {
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BitArray> BinaryBitmap::getBlackRow(int y, Ref<BitArray> row) {
|
|
|
+ return binarizer_->getBlackRow(y, row);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BitMatrix> BinaryBitmap::getBlackMatrix() {
|
|
|
+ return binarizer_->getBlackMatrix();
|
|
|
+ }
|
|
|
+
|
|
|
+ int BinaryBitmap::getWidth() const {
|
|
|
+ return getLuminanceSource()->getWidth();
|
|
|
+ }
|
|
|
+
|
|
|
+ int BinaryBitmap::getHeight() const {
|
|
|
+ return getLuminanceSource()->getHeight();
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<LuminanceSource> BinaryBitmap::getLuminanceSource() const {
|
|
|
+ return binarizer_->getLuminanceSource();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ bool BinaryBitmap::isCropSupported() const {
|
|
|
+ return getLuminanceSource()->isCropSupported();
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BinaryBitmap> BinaryBitmap::crop(int left, int top, int width, int height) {
|
|
|
+ return Ref<BinaryBitmap> (new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->crop(left, top, width, height))));
|
|
|
+ }
|
|
|
+
|
|
|
+ bool BinaryBitmap::isRotateSupported() const {
|
|
|
+ return getLuminanceSource()->isRotateSupported();
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BinaryBitmap> BinaryBitmap::rotateCounterClockwise() {
|
|
|
+ return Ref<BinaryBitmap> (new BinaryBitmap(binarizer_->createBinarizer(getLuminanceSource()->rotateCounterClockwise())));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/DecodeHints.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * DecodeHintType.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/DecodeHints.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+const DecodeHintType DecodeHints::CHARACTER_SET;
|
|
|
+
|
|
|
+const DecodeHints DecodeHints::PRODUCT_HINT(
|
|
|
+ BARCODEFORMAT_UPC_E_HINT |
|
|
|
+ BARCODEFORMAT_UPC_A_HINT |
|
|
|
+ BARCODEFORMAT_EAN_8_HINT |
|
|
|
+ BARCODEFORMAT_EAN_13_HINT);
|
|
|
+
|
|
|
+const DecodeHints DecodeHints::ONED_HINT(
|
|
|
+ BARCODEFORMAT_UPC_E_HINT |
|
|
|
+ BARCODEFORMAT_UPC_A_HINT |
|
|
|
+ BARCODEFORMAT_EAN_8_HINT |
|
|
|
+ BARCODEFORMAT_EAN_13_HINT |
|
|
|
+ BARCODEFORMAT_CODE_128_HINT |
|
|
|
+ BARCODEFORMAT_CODE_39_HINT |
|
|
|
+ BARCODEFORMAT_ITF_HINT);
|
|
|
+
|
|
|
+const DecodeHints DecodeHints::DEFAULT_HINT(
|
|
|
+ BARCODEFORMAT_UPC_E_HINT |
|
|
|
+ BARCODEFORMAT_UPC_A_HINT |
|
|
|
+ BARCODEFORMAT_EAN_8_HINT |
|
|
|
+ BARCODEFORMAT_EAN_13_HINT |
|
|
|
+ BARCODEFORMAT_CODE_128_HINT |
|
|
|
+ BARCODEFORMAT_CODE_39_HINT |
|
|
|
+ BARCODEFORMAT_ITF_HINT |
|
|
|
+ BARCODEFORMAT_DATA_MATRIX_HINT |
|
|
|
+ BARCODEFORMAT_QR_CODE_HINT);
|
|
|
+
|
|
|
+DecodeHints::DecodeHints() {
|
|
|
+ hints = 0;
|
|
|
+}
|
|
|
+
|
|
|
+DecodeHints::DecodeHints(DecodeHintType init) {
|
|
|
+ hints = init;
|
|
|
+}
|
|
|
+
|
|
|
+void DecodeHints::addFormat(BarcodeFormat toadd) {
|
|
|
+ switch (toadd) {
|
|
|
+ case BarcodeFormat_QR_CODE: hints |= BARCODEFORMAT_QR_CODE_HINT; break;
|
|
|
+ case BarcodeFormat_DATA_MATRIX: hints |= BARCODEFORMAT_DATA_MATRIX_HINT; break;
|
|
|
+ case BarcodeFormat_UPC_E: hints |= BARCODEFORMAT_UPC_E_HINT; break;
|
|
|
+ case BarcodeFormat_UPC_A: hints |= BARCODEFORMAT_UPC_A_HINT; break;
|
|
|
+ case BarcodeFormat_EAN_8: hints |= BARCODEFORMAT_EAN_8_HINT; break;
|
|
|
+ case BarcodeFormat_EAN_13: hints |= BARCODEFORMAT_EAN_13_HINT; break;
|
|
|
+ case BarcodeFormat_CODE_128: hints |= BARCODEFORMAT_CODE_128_HINT; break;
|
|
|
+ case BarcodeFormat_CODE_39: hints |= BARCODEFORMAT_CODE_39_HINT; break;
|
|
|
+ case BarcodeFormat_ITF: hints |= BARCODEFORMAT_ITF_HINT; break;
|
|
|
+ default: throw IllegalArgumentException("Unrecognizd barcode format");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool DecodeHints::containsFormat(BarcodeFormat tocheck) const {
|
|
|
+ DecodeHintType checkAgainst;
|
|
|
+ switch (tocheck) {
|
|
|
+ case BarcodeFormat_QR_CODE: checkAgainst = BARCODEFORMAT_QR_CODE_HINT; break;
|
|
|
+ case BarcodeFormat_DATA_MATRIX: checkAgainst = BARCODEFORMAT_DATA_MATRIX_HINT; break;
|
|
|
+ case BarcodeFormat_UPC_E: checkAgainst = BARCODEFORMAT_UPC_E_HINT; break;
|
|
|
+ case BarcodeFormat_UPC_A: checkAgainst = BARCODEFORMAT_UPC_A_HINT; break;
|
|
|
+ case BarcodeFormat_EAN_8: checkAgainst = BARCODEFORMAT_EAN_8_HINT; break;
|
|
|
+ case BarcodeFormat_EAN_13: checkAgainst = BARCODEFORMAT_EAN_13_HINT; break;
|
|
|
+ case BarcodeFormat_CODE_128: checkAgainst = BARCODEFORMAT_CODE_128_HINT; break;
|
|
|
+ case BarcodeFormat_CODE_39: checkAgainst = BARCODEFORMAT_CODE_39_HINT; break;
|
|
|
+ case BarcodeFormat_ITF: checkAgainst = BARCODEFORMAT_ITF_HINT; break;
|
|
|
+ default: throw IllegalArgumentException("Unrecognizd barcode format");
|
|
|
+ }
|
|
|
+ return (hints & checkAgainst);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodeHints::setTryHarder(bool toset) {
|
|
|
+ if (toset) {
|
|
|
+ hints |= TRYHARDER_HINT;
|
|
|
+ } else {
|
|
|
+ hints &= ~TRYHARDER_HINT;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool DecodeHints::getTryHarder() const {
|
|
|
+ return (hints & TRYHARDER_HINT);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodeHints::setResultPointCallback(Ref<ResultPointCallback> const& _callback) {
|
|
|
+ callback = _callback;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<ResultPointCallback> DecodeHints::getResultPointCallback() const {
|
|
|
+ return callback;
|
|
|
+}
|
|
|
+
|
|
|
+} /* namespace */
|
|
|
+
|
|
|
+// file: zxing/Exception.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Exception.cpp
|
|
|
+ * ZXing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 03/06/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/Exception.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+Exception::Exception() {}
|
|
|
+
|
|
|
+Exception::Exception(const char *msg) :
|
|
|
+ message(msg) {
|
|
|
+}
|
|
|
+
|
|
|
+const char* Exception::what() const throw() {
|
|
|
+ return message.c_str();
|
|
|
+}
|
|
|
+
|
|
|
+Exception::~Exception() throw() {
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/FormatException.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * FormatException.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/FormatException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+FormatException::FormatException() {}
|
|
|
+
|
|
|
+FormatException::FormatException(const char *msg) :
|
|
|
+ ReaderException(msg) {
|
|
|
+}
|
|
|
+
|
|
|
+FormatException::~FormatException() throw() {
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/LuminanceSource.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * LuminanceSource.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * 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 <sstream>
|
|
|
+// #include <zxing/LuminanceSource.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+LuminanceSource::LuminanceSource() {
|
|
|
+}
|
|
|
+
|
|
|
+LuminanceSource::~LuminanceSource() {
|
|
|
+}
|
|
|
+
|
|
|
+bool LuminanceSource::isCropSupported() const {
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<LuminanceSource> LuminanceSource::crop(int left, int top, int width, int height) {
|
|
|
+ (void)left;
|
|
|
+ (void)top;
|
|
|
+ (void)width;
|
|
|
+ (void)height;
|
|
|
+ throw IllegalArgumentException("This luminance source does not support cropping.");
|
|
|
+}
|
|
|
+
|
|
|
+bool LuminanceSource::isRotateSupported() const {
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<LuminanceSource> LuminanceSource::rotateCounterClockwise() {
|
|
|
+ throw IllegalArgumentException("This luminance source does not support rotation.");
|
|
|
+}
|
|
|
+
|
|
|
+LuminanceSource::operator std::string() {
|
|
|
+ unsigned char* row = 0;
|
|
|
+ std::ostringstream oss;
|
|
|
+ for (int y = 0; y < getHeight(); y++) {
|
|
|
+ row = getRow(y, row);
|
|
|
+ for (int x = 0; x < getWidth(); x++) {
|
|
|
+ int luminance = row[x] & 0xFF;
|
|
|
+ char c;
|
|
|
+ if (luminance < 0x40) {
|
|
|
+ c = '#';
|
|
|
+ } else if (luminance < 0x80) {
|
|
|
+ c = '+';
|
|
|
+ } else if (luminance < 0xC0) {
|
|
|
+ c = '.';
|
|
|
+ } else {
|
|
|
+ c = ' ';
|
|
|
+ }
|
|
|
+ oss << c;
|
|
|
+ }
|
|
|
+ oss << '\n';
|
|
|
+ }
|
|
|
+ delete [] row;
|
|
|
+ return oss.str();
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/MultiFormatReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * MultiFormatBarcodeReader.cpp
|
|
|
+ * ZXing
|
|
|
+ *
|
|
|
+ * Created by Lukasz Warchol on 10-01-26.
|
|
|
+ * Modified by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/MultiFormatReader.h>
|
|
|
+// #include <zxing/qrcode/QRCodeReader.h>
|
|
|
+// #include <zxing/datamatrix/DataMatrixReader.h>
|
|
|
+// #include <zxing/oned/MultiFormatUPCEANReader.h>
|
|
|
+// #include <zxing/oned/MultiFormatOneDReader.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ MultiFormatReader::MultiFormatReader() {
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> MultiFormatReader::decode(Ref<BinaryBitmap> image) {
|
|
|
+ setHints(DecodeHints::DEFAULT_HINT);
|
|
|
+ return decodeInternal(image);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> MultiFormatReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
|
|
|
+ setHints(hints);
|
|
|
+ return decodeInternal(image);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> MultiFormatReader::decodeWithState(Ref<BinaryBitmap> image) {
|
|
|
+ // Make sure to set up the default state so we don't crash
|
|
|
+ if (readers_.size() == 0) {
|
|
|
+ setHints(DecodeHints::DEFAULT_HINT);
|
|
|
+ }
|
|
|
+ return decodeInternal(image);
|
|
|
+ }
|
|
|
+
|
|
|
+ void MultiFormatReader::setHints(DecodeHints hints) {
|
|
|
+ hints_ = hints;
|
|
|
+ readers_.clear();
|
|
|
+ bool tryHarder = hints.getTryHarder();
|
|
|
+
|
|
|
+ bool addOneDReader = hints.containsFormat(BarcodeFormat_UPC_E) ||
|
|
|
+ hints.containsFormat(BarcodeFormat_UPC_A) ||
|
|
|
+ hints.containsFormat(BarcodeFormat_EAN_8) ||
|
|
|
+ hints.containsFormat(BarcodeFormat_EAN_13) ||
|
|
|
+ hints.containsFormat(BarcodeFormat_CODE_128) ||
|
|
|
+ hints.containsFormat(BarcodeFormat_CODE_39) ||
|
|
|
+ hints.containsFormat(BarcodeFormat_ITF);
|
|
|
+ if (addOneDReader && !tryHarder) {
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
|
|
|
+ }
|
|
|
+ if (hints.containsFormat(BarcodeFormat_QR_CODE)) {
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::qrcode::QRCodeReader()));
|
|
|
+ }
|
|
|
+ if (hints.containsFormat(BarcodeFormat_DATA_MATRIX)) {
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::datamatrix::DataMatrixReader()));
|
|
|
+ }
|
|
|
+ //TODO: add PDF417 here once PDF417 reader is implemented
|
|
|
+ if (addOneDReader && tryHarder) {
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
|
|
|
+ }
|
|
|
+ if (readers_.size() == 0) {
|
|
|
+ if (!tryHarder) {
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
|
|
|
+ }
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::qrcode::QRCodeReader()));
|
|
|
+ if (tryHarder) {
|
|
|
+ readers_.push_back(Ref<Reader>(new zxing::oned::MultiFormatOneDReader(hints)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> MultiFormatReader::decodeInternal(Ref<BinaryBitmap> image) {
|
|
|
+ for (unsigned int i = 0; i < readers_.size(); i++) {
|
|
|
+ try {
|
|
|
+ return readers_[i]->decode(image, hints_);
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ // continue
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw ReaderException("No code detected");
|
|
|
+ }
|
|
|
+
|
|
|
+ MultiFormatReader::~MultiFormatReader() {
|
|
|
+
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/NotFoundException.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Copyright 20011 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 <zxing/NotFoundException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ NotFoundException::NotFoundException(const char *msg)
|
|
|
+ : ReaderException(msg) {}
|
|
|
+
|
|
|
+ NotFoundException::~NotFoundException() throw() {
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/Reader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Reader.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/Reader.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+Reader::~Reader() { }
|
|
|
+
|
|
|
+Ref<Result> Reader::decode(Ref<BinaryBitmap> image) {
|
|
|
+ return decode(image, DecodeHints::DEFAULT_HINT);
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/ReaderException.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * ReaderException.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ReaderException::ReaderException() {}
|
|
|
+
|
|
|
+ReaderException::ReaderException(const char *msg) :
|
|
|
+ Exception(msg) {
|
|
|
+}
|
|
|
+
|
|
|
+ReaderException::~ReaderException() throw() {
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/Result.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Result.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/Result.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+Result::Result(Ref<String> text, ArrayRef<unsigned char> rawBytes, std::vector<Ref<ResultPoint> > resultPoints,
|
|
|
+ BarcodeFormat format) :
|
|
|
+ text_(text), rawBytes_(rawBytes), resultPoints_(resultPoints), format_(format) {
|
|
|
+}
|
|
|
+
|
|
|
+Result::~Result() {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<String> Result::getText() {
|
|
|
+ return text_;
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<unsigned char> Result::getRawBytes() {
|
|
|
+ return rawBytes_;
|
|
|
+}
|
|
|
+
|
|
|
+const std::vector<Ref<ResultPoint> >& Result::getResultPoints() const {
|
|
|
+ return resultPoints_;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<Ref<ResultPoint> >& Result::getResultPoints() {
|
|
|
+ return resultPoints_;
|
|
|
+}
|
|
|
+
|
|
|
+BarcodeFormat Result::getBarcodeFormat() const {
|
|
|
+ return format_;
|
|
|
+}
|
|
|
+
|
|
|
+ostream& operator<<(ostream &out, Result& result) {
|
|
|
+ if (result.text_ != 0) {
|
|
|
+ out << result.text_->getText();
|
|
|
+ } else {
|
|
|
+ out << "[" << result.rawBytes_->size() << " bytes]";
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/ResultPoint.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * ResultPoint.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/ResultPoint.h>
|
|
|
+// #include <math.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ResultPoint::ResultPoint() : posX_(0), posY_(0) {}
|
|
|
+
|
|
|
+ResultPoint::ResultPoint(float x, float y) : posX_(x), posY_(y) {}
|
|
|
+
|
|
|
+ResultPoint::~ResultPoint() {}
|
|
|
+
|
|
|
+float ResultPoint::getX() const {
|
|
|
+ return posX_;
|
|
|
+}
|
|
|
+
|
|
|
+float ResultPoint::getY() const {
|
|
|
+ return posY_;
|
|
|
+}
|
|
|
+
|
|
|
+bool ResultPoint::equals(Ref<ResultPoint> other) {
|
|
|
+ return posX_ == other->getX() && posY_ == other->getY();
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * <p>Orders an array of three ResultPoints in an order [A,B,C] such that AB < AC and
|
|
|
+ * BC < AC and the angle between BC and BA is less than 180 degrees.
|
|
|
+ */
|
|
|
+void ResultPoint::orderBestPatterns(std::vector<Ref<ResultPoint> > &patterns) {
|
|
|
+ // Find distances between pattern centers
|
|
|
+ float zeroOneDistance = distance(patterns[0]->getX(), patterns[1]->getX(),patterns[0]->getY(), patterns[1]->getY());
|
|
|
+ float oneTwoDistance = distance(patterns[1]->getX(), patterns[2]->getX(),patterns[1]->getY(), patterns[2]->getY());
|
|
|
+ float zeroTwoDistance = distance(patterns[0]->getX(), patterns[2]->getX(),patterns[0]->getY(), patterns[2]->getY());
|
|
|
+
|
|
|
+ Ref<ResultPoint> pointA, pointB, pointC;
|
|
|
+ // Assume one closest to other two is B; A and C will just be guesses at first
|
|
|
+ if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
|
|
|
+ pointB = patterns[0];
|
|
|
+ pointA = patterns[1];
|
|
|
+ pointC = patterns[2];
|
|
|
+ } else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
|
|
|
+ pointB = patterns[1];
|
|
|
+ pointA = patterns[0];
|
|
|
+ pointC = patterns[2];
|
|
|
+ } else {
|
|
|
+ pointB = patterns[2];
|
|
|
+ pointA = patterns[0];
|
|
|
+ pointC = patterns[1];
|
|
|
+ }
|
|
|
+
|
|
|
+ // Use cross product to figure out whether A and C are correct or flipped.
|
|
|
+ // This asks whether BC x BA has a positive z component, which is the arrangement
|
|
|
+ // we want for A, B, C. If it's negative, then we've got it flipped around and
|
|
|
+ // should swap A and C.
|
|
|
+ if (crossProductZ(pointA, pointB, pointC) < 0.0f) {
|
|
|
+ Ref<ResultPoint> temp = pointA;
|
|
|
+ pointA = pointC;
|
|
|
+ pointC = temp;
|
|
|
+ }
|
|
|
+
|
|
|
+ patterns[0] = pointA;
|
|
|
+ patterns[1] = pointB;
|
|
|
+ patterns[2] = pointC;
|
|
|
+}
|
|
|
+
|
|
|
+float ResultPoint::distance(Ref<ResultPoint> point1, Ref<ResultPoint> point2) {
|
|
|
+ return distance(point1->getX(), point1->getY(), point2->getX(), point2->getY());
|
|
|
+}
|
|
|
+
|
|
|
+float ResultPoint::distance(float x1, float x2, float y1, float y2) {
|
|
|
+ float xDiff = x1 - x2;
|
|
|
+ float yDiff = y1 - y2;
|
|
|
+ return (float) sqrt((double) (xDiff * xDiff + yDiff * yDiff));
|
|
|
+}
|
|
|
+
|
|
|
+float ResultPoint::crossProductZ(Ref<ResultPoint> pointA, Ref<ResultPoint> pointB, Ref<ResultPoint> pointC) {
|
|
|
+ float bX = pointB->getX();
|
|
|
+ float bY = pointB->getY();
|
|
|
+ return ((pointC->getX() - bX) * (pointA->getY() - bY)) - ((pointC->getY() - bY) * (pointA->getX() - bX));
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/ResultPointCallback.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * ResultPointCallback.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/ResultPointCallback.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ResultPointCallback::~ResultPointCallback() {}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/Array.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Array.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 07/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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/Array.h>
|
|
|
+
|
|
|
+
|
|
|
+// file: zxing/common/BitArray.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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/BitArray.h>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+
|
|
|
+size_t BitArray::wordsForBits(size_t bits) {
|
|
|
+ int arraySize = (bits + bitsPerWord_ - 1) >> logBits_;
|
|
|
+ return arraySize;
|
|
|
+}
|
|
|
+
|
|
|
+BitArray::BitArray(size_t size) :
|
|
|
+ size_(size), bits_(wordsForBits(size), (const unsigned int)0) {
|
|
|
+}
|
|
|
+
|
|
|
+BitArray::~BitArray() {
|
|
|
+}
|
|
|
+
|
|
|
+size_t BitArray::getSize() {
|
|
|
+ return size_;
|
|
|
+}
|
|
|
+
|
|
|
+void BitArray::setBulk(size_t i, unsigned int newBits) {
|
|
|
+ bits_[i >> logBits_] = newBits;
|
|
|
+}
|
|
|
+
|
|
|
+void BitArray::setRange(int start, int end) {
|
|
|
+ if (end < start) {
|
|
|
+ throw IllegalArgumentException("invalid call to BitArray::setRange");
|
|
|
+ }
|
|
|
+ if (end == start) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ end--; // will be easier to treat this as the last actually set bit -- inclusive
|
|
|
+ int firstInt = start >> 5;
|
|
|
+ int lastInt = end >> 5;
|
|
|
+ for (int i = firstInt; i <= lastInt; i++) {
|
|
|
+ int firstBit = i > firstInt ? 0 : start & 0x1F;
|
|
|
+ int lastBit = i < lastInt ? 31 : end & 0x1F;
|
|
|
+ int mask;
|
|
|
+ if (firstBit == 0 && lastBit == 31) {
|
|
|
+ mask = -1;
|
|
|
+ } else {
|
|
|
+ mask = 0;
|
|
|
+ for (int j = firstBit; j <= lastBit; j++) {
|
|
|
+ mask |= 1 << j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ bits_[i] |= mask;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void BitArray::clear() {
|
|
|
+ size_t max = bits_.size();
|
|
|
+ for (size_t i = 0; i < max; i++) {
|
|
|
+ bits_[i] = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool BitArray::isRange(size_t start, size_t end, bool value) {
|
|
|
+ if (end < start) {
|
|
|
+ throw IllegalArgumentException("end must be after start");
|
|
|
+ }
|
|
|
+ if (end == start) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ // treat the 'end' as inclusive, rather than exclusive
|
|
|
+ end--;
|
|
|
+ size_t firstWord = start >> logBits_;
|
|
|
+ size_t lastWord = end >> logBits_;
|
|
|
+ for (size_t i = firstWord; i <= lastWord; i++) {
|
|
|
+ size_t firstBit = i > firstWord ? 0 : start & bitsMask_;
|
|
|
+ size_t lastBit = i < lastWord ? bitsPerWord_ - 1: end & bitsMask_;
|
|
|
+ unsigned int mask;
|
|
|
+ if (firstBit == 0 && lastBit == bitsPerWord_ - 1) {
|
|
|
+ mask = numeric_limits<unsigned int>::max();
|
|
|
+ } else {
|
|
|
+ mask = 0;
|
|
|
+ for (size_t j = firstBit; j <= lastBit; j++) {
|
|
|
+ mask |= 1 << j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (value) {
|
|
|
+ if ((bits_[i] & mask) != mask) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if ((bits_[i] & mask) != 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+vector<unsigned int>& BitArray::getBitArray() {
|
|
|
+ return bits_;
|
|
|
+}
|
|
|
+
|
|
|
+void BitArray::reverse() {
|
|
|
+ std::vector<unsigned int> newBits(bits_.size(),(const unsigned int) 0);
|
|
|
+ for (size_t i = 0; i < size_; i++) {
|
|
|
+ if (get(size_ - i - 1)) {
|
|
|
+ newBits[i >> logBits_] |= 1<< (i & bitsMask_);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ bits_ = newBits;
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/BitMatrix.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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/BitMatrix.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+// #include <iostream>
|
|
|
+// #include <sstream>
|
|
|
+// #include <string>
|
|
|
+
|
|
|
+using std::ostream;
|
|
|
+using std::ostringstream;
|
|
|
+
|
|
|
+using zxing::BitMatrix;
|
|
|
+using zxing::BitArray;
|
|
|
+using zxing::Ref;
|
|
|
+
|
|
|
+namespace {
|
|
|
+ size_t wordsForSize(size_t width,
|
|
|
+ size_t height,
|
|
|
+ unsigned int bitsPerWord,
|
|
|
+ unsigned int logBits) {
|
|
|
+ size_t bits = width * height;
|
|
|
+ int arraySize = (bits + bitsPerWord - 1) >> logBits;
|
|
|
+ return arraySize;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+BitMatrix::BitMatrix(size_t dimension) :
|
|
|
+ width_(dimension), height_(dimension), words_(0), bits_(NULL) {
|
|
|
+ words_ = wordsForSize(width_, height_, bitsPerWord, logBits);
|
|
|
+ bits_ = new unsigned int[words_];
|
|
|
+ clear();
|
|
|
+}
|
|
|
+
|
|
|
+BitMatrix::BitMatrix(size_t width, size_t height) :
|
|
|
+ width_(width), height_(height), words_(0), bits_(NULL) {
|
|
|
+ words_ = wordsForSize(width_, height_, bitsPerWord, logBits);
|
|
|
+ bits_ = new unsigned int[words_];
|
|
|
+ clear();
|
|
|
+}
|
|
|
+
|
|
|
+BitMatrix::~BitMatrix() {
|
|
|
+ delete[] bits_;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+void BitMatrix::flip(size_t x, size_t y) {
|
|
|
+ size_t offset = x + width_ * y;
|
|
|
+ bits_[offset >> logBits] ^= 1 << (offset & bitsMask);
|
|
|
+}
|
|
|
+
|
|
|
+void BitMatrix::clear() {
|
|
|
+ std::fill(bits_, bits_+words_, 0);
|
|
|
+}
|
|
|
+
|
|
|
+void BitMatrix::setRegion(size_t left, size_t top, size_t width, size_t height) {
|
|
|
+ if ((long)top < 0 || (long)left < 0) {
|
|
|
+ throw IllegalArgumentException("topI and leftJ must be nonnegative");
|
|
|
+ }
|
|
|
+ if (height < 1 || width < 1) {
|
|
|
+ throw IllegalArgumentException("height and width must be at least 1");
|
|
|
+ }
|
|
|
+ size_t right = left + width;
|
|
|
+ size_t bottom = top + height;
|
|
|
+ if (right > width_ || bottom > height_) {
|
|
|
+ throw IllegalArgumentException("top + height and left + width must be <= matrix dimension");
|
|
|
+ }
|
|
|
+ for (size_t y = top; y < bottom; y++) {
|
|
|
+ int yOffset = width_ * y;
|
|
|
+ for (size_t x = left; x < right; x++) {
|
|
|
+ size_t offset = x + yOffset;
|
|
|
+ bits_[offset >> logBits] |= 1 << (offset & bitsMask);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitArray> BitMatrix::getRow(int y, Ref<BitArray> row) {
|
|
|
+ if (row.empty() || row->getSize() < width_) {
|
|
|
+ row = new BitArray(width_);
|
|
|
+ } else {
|
|
|
+ row->clear();
|
|
|
+ }
|
|
|
+ size_t start = y * width_;
|
|
|
+ size_t end = start + width_ - 1; // end is inclusive
|
|
|
+ size_t firstWord = start >> logBits;
|
|
|
+ size_t lastWord = end >> logBits;
|
|
|
+ size_t bitOffset = start & bitsMask;
|
|
|
+ for (size_t i = firstWord; i <= lastWord; i++) {
|
|
|
+ size_t firstBit = i > firstWord ? 0 : start & bitsMask;
|
|
|
+ size_t lastBit = i < lastWord ? bitsPerWord - 1 : end & bitsMask;
|
|
|
+ unsigned int mask;
|
|
|
+ if (firstBit == 0 && lastBit == logBits) {
|
|
|
+ mask = std::numeric_limits<unsigned int>::max();
|
|
|
+ } else {
|
|
|
+ mask = 0;
|
|
|
+ for (size_t j = firstBit; j <= lastBit; j++) {
|
|
|
+ mask |= 1 << j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ row->setBulk((i - firstWord) << logBits, (bits_[i] & mask) >> bitOffset);
|
|
|
+ if (firstBit == 0 && bitOffset != 0) {
|
|
|
+ unsigned int prevBulk = row->getBitArray()[i - firstWord - 1];
|
|
|
+ prevBulk |= (bits_[i] & mask) << (bitsPerWord - bitOffset);
|
|
|
+ row->setBulk((i - firstWord - 1) << logBits, prevBulk);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return row;
|
|
|
+}
|
|
|
+
|
|
|
+size_t BitMatrix::getWidth() const {
|
|
|
+ return width_;
|
|
|
+}
|
|
|
+
|
|
|
+size_t BitMatrix::getHeight() const {
|
|
|
+ return height_;
|
|
|
+}
|
|
|
+
|
|
|
+size_t BitMatrix::getDimension() const {
|
|
|
+ return width_;
|
|
|
+}
|
|
|
+
|
|
|
+unsigned int* BitMatrix::getBits() const {
|
|
|
+ return bits_;
|
|
|
+}
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ ostream& operator<<(ostream &out, const BitMatrix &bm) {
|
|
|
+ for (size_t y = 0; y < bm.height_; y++) {
|
|
|
+ for (size_t x = 0; x < bm.width_; x++) {
|
|
|
+ out << (bm.get(x, y) ? "X " : " ");
|
|
|
+ }
|
|
|
+ out << "\n";
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const char* BitMatrix::description() {
|
|
|
+ ostringstream out;
|
|
|
+ out << *this;
|
|
|
+ return out.str().c_str();
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/BitSource.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * BitSource.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 09/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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/BitSource.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+int BitSource::readBits(int numBits) {
|
|
|
+ if (numBits < 0 || numBits > 32) {
|
|
|
+ throw IllegalArgumentException("cannot read <1 or >32 bits");
|
|
|
+ } else if (numBits > available()) {
|
|
|
+ throw IllegalArgumentException("reading more bits than are available");
|
|
|
+ }
|
|
|
+
|
|
|
+ int result = 0;
|
|
|
+
|
|
|
+ // First, read remainder from current byte
|
|
|
+ if (bitOffset_ > 0) {
|
|
|
+ int bitsLeft = 8 - bitOffset_;
|
|
|
+ int toRead = numBits < bitsLeft ? numBits : bitsLeft;
|
|
|
+ int bitsToNotRead = bitsLeft - toRead;
|
|
|
+ int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
|
|
|
+ result = (bytes_[byteOffset_] & mask) >> bitsToNotRead;
|
|
|
+ numBits -= toRead;
|
|
|
+ bitOffset_ += toRead;
|
|
|
+ if (bitOffset_ == 8) {
|
|
|
+ bitOffset_ = 0;
|
|
|
+ byteOffset_++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Next read whole bytes
|
|
|
+ if (numBits > 0) {
|
|
|
+ while (numBits >= 8) {
|
|
|
+ result = (result << 8) | (bytes_[byteOffset_] & 0xFF);
|
|
|
+ byteOffset_++;
|
|
|
+ numBits -= 8;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // Finally read a partial byte
|
|
|
+ if (numBits > 0) {
|
|
|
+ int bitsToNotRead = 8 - numBits;
|
|
|
+ int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
|
|
|
+ result = (result << numBits) | ((bytes_[byteOffset_] & mask) >> bitsToNotRead);
|
|
|
+ bitOffset_ += numBits;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+int BitSource::available() {
|
|
|
+ return 8 * (bytes_.size() - byteOffset_) - bitOffset_;
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/CharacterSetECI.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 <zxing/common/CharacterSetECI.h>
|
|
|
+// #include <sstream>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+using std::string;
|
|
|
+
|
|
|
+using zxing::common::CharacterSetECI;
|
|
|
+using zxing::IllegalArgumentException;
|
|
|
+
|
|
|
+std::map<int, CharacterSetECI*> CharacterSetECI::VALUE_TO_ECI;
|
|
|
+std::map<std::string, CharacterSetECI*> CharacterSetECI::NAME_TO_ECI;
|
|
|
+
|
|
|
+const bool CharacterSetECI::inited = CharacterSetECI::init_tables();
|
|
|
+
|
|
|
+bool CharacterSetECI::init_tables() {
|
|
|
+ addCharacterSet(0, "Cp437");
|
|
|
+ { char const* s[] = {"ISO8859_1", "ISO-8859-1", 0};
|
|
|
+ addCharacterSet(1, s); }
|
|
|
+ addCharacterSet(2, "Cp437");
|
|
|
+ { char const* s[] = {"ISO8859_1", "ISO-8859-1", 0};
|
|
|
+ addCharacterSet(3, s); }
|
|
|
+ addCharacterSet(4, "ISO8859_2");
|
|
|
+ addCharacterSet(5, "ISO8859_3");
|
|
|
+ addCharacterSet(6, "ISO8859_4");
|
|
|
+ addCharacterSet(7, "ISO8859_5");
|
|
|
+ addCharacterSet(8, "ISO8859_6");
|
|
|
+ addCharacterSet(9, "ISO8859_7");
|
|
|
+ addCharacterSet(10, "ISO8859_8");
|
|
|
+ addCharacterSet(11, "ISO8859_9");
|
|
|
+ addCharacterSet(12, "ISO8859_10");
|
|
|
+ addCharacterSet(13, "ISO8859_11");
|
|
|
+ addCharacterSet(15, "ISO8859_13");
|
|
|
+ addCharacterSet(16, "ISO8859_14");
|
|
|
+ addCharacterSet(17, "ISO8859_15");
|
|
|
+ addCharacterSet(18, "ISO8859_16");
|
|
|
+ { char const* s[] = {"SJIS", "Shift_JIS", 0};
|
|
|
+ addCharacterSet(20, s ); }
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+CharacterSetECI::CharacterSetECI(int value, char const* encodingName_)
|
|
|
+ : ECI(value), encodingName(encodingName_) {}
|
|
|
+
|
|
|
+char const* CharacterSetECI::getEncodingName() {
|
|
|
+ return encodingName;
|
|
|
+}
|
|
|
+
|
|
|
+void CharacterSetECI::addCharacterSet(int value, char const* encodingName) {
|
|
|
+ CharacterSetECI* eci = new CharacterSetECI(value, encodingName);
|
|
|
+ VALUE_TO_ECI[value] = eci; // can't use valueOf
|
|
|
+ NAME_TO_ECI[string(encodingName)] = eci;
|
|
|
+}
|
|
|
+
|
|
|
+void CharacterSetECI::addCharacterSet(int value, char const* const* encodingNames) {
|
|
|
+ CharacterSetECI* eci = new CharacterSetECI(value, encodingNames[0]);
|
|
|
+ VALUE_TO_ECI[value] = eci;
|
|
|
+ for (int i = 0; encodingNames[i]; i++) {
|
|
|
+ NAME_TO_ECI[string(encodingNames[i])] = eci;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByValue(int value) {
|
|
|
+ if (value < 0 || value >= 900) {
|
|
|
+ std::ostringstream oss;
|
|
|
+ oss << "Bad ECI value: " << value;
|
|
|
+ throw IllegalArgumentException(oss.str().c_str());
|
|
|
+ }
|
|
|
+ return VALUE_TO_ECI[value];
|
|
|
+}
|
|
|
+
|
|
|
+CharacterSetECI* CharacterSetECI::getCharacterSetECIByName(string const& name) {
|
|
|
+ return NAME_TO_ECI[name];
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/Counted.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Counted.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 07/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+template<class T>
|
|
|
+ostream& operator<<(ostream &out, Ref<T>& ref) {
|
|
|
+ out << "Ref(" << (ref.object_ ? (*ref.object_) : "NULL") << ")";
|
|
|
+ return out;
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/DecoderResult.cpp
|
|
|
+
|
|
|
+// -*- 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<unsigned char> rawBytes,
|
|
|
+ Ref<String> text,
|
|
|
+ ArrayRef< ArrayRef<unsigned char> >& byteSegments,
|
|
|
+ string const& ecLevel) :
|
|
|
+ rawBytes_(rawBytes),
|
|
|
+ text_(text),
|
|
|
+ byteSegments_(byteSegments),
|
|
|
+ ecLevel_(ecLevel) {}
|
|
|
+
|
|
|
+DecoderResult::DecoderResult(ArrayRef<unsigned char> rawBytes,
|
|
|
+ Ref<String> text)
|
|
|
+ : rawBytes_(rawBytes), text_(text) {}
|
|
|
+
|
|
|
+ArrayRef<unsigned char> DecoderResult::getRawBytes() {
|
|
|
+ return rawBytes_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<String> DecoderResult::getText() {
|
|
|
+ return text_;
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/DetectorResult.cpp
|
|
|
+
|
|
|
+// -*- 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, std::vector<Ref<ResultPoint> > points, Ref<PerspectiveTransform> transform) :
|
|
|
+ bits_(bits), points_(points), transform_(transform) {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> DetectorResult::getBits() {
|
|
|
+ return bits_;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<Ref<ResultPoint> > DetectorResult::getPoints() {
|
|
|
+ return points_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> DetectorResult::getTransform() {
|
|
|
+ return transform_;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/ECI.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 <zxing/common/ECI.h>
|
|
|
+// #include <sstream>
|
|
|
+// #include <zxing/common/CharacterSetECI.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+using zxing::common::ECI;
|
|
|
+using zxing::IllegalArgumentException;
|
|
|
+
|
|
|
+ECI::ECI(int value_) : value(value_) {}
|
|
|
+
|
|
|
+int ECI::getValue() const {
|
|
|
+ return value;
|
|
|
+}
|
|
|
+
|
|
|
+ECI* ECI::getECIByValue(int value) {
|
|
|
+ if (value < 0 || value > 999999) {
|
|
|
+ std::ostringstream oss;
|
|
|
+ oss << "Bad ECI value: " << value;
|
|
|
+ throw IllegalArgumentException(oss.str().c_str());
|
|
|
+ }
|
|
|
+ if (value < 900) { // Character set ECIs use 000000 - 000899
|
|
|
+ return CharacterSetECI::getCharacterSetECIByValue(value);
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/EdgeDetector.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * EdgeDetector.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Ralf Kistner on 7/12/2009.
|
|
|
+ * 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/EdgeDetector.h>
|
|
|
+// #include <algorithm>
|
|
|
+// #include <cmath>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace EdgeDetector {
|
|
|
+
|
|
|
+void findEdgePoints(std::vector<Point>& points, const BitMatrix& image, Point start, Point end, bool invert, int skip, float deviation) {
|
|
|
+ float xdist = end.x - start.x;
|
|
|
+ float ydist = end.y - start.y;
|
|
|
+ float length = sqrt(xdist * xdist + ydist * ydist);
|
|
|
+
|
|
|
+
|
|
|
+ int var;
|
|
|
+
|
|
|
+ if (abs(xdist) > abs(ydist)) {
|
|
|
+ // Horizontal
|
|
|
+ if (xdist < 0)
|
|
|
+ skip = -skip;
|
|
|
+
|
|
|
+ var = int(abs(deviation * length / xdist));
|
|
|
+
|
|
|
+ float dy = ydist / xdist * skip;
|
|
|
+ bool left = (skip < 0) ^ invert;
|
|
|
+ int x = int(start.x);
|
|
|
+
|
|
|
+ int steps = int(xdist / skip);
|
|
|
+ for (int i = 0; i < steps; i++) {
|
|
|
+ x += skip;
|
|
|
+ if (x < 0 || x >= (int)image.getWidth())
|
|
|
+ continue; // In case we start off the edge
|
|
|
+ int my = int(start.y + dy * i);
|
|
|
+ int ey = min(my + var + 1, (int)image.getHeight() - 1);
|
|
|
+ int sy = max(my - var, 0);
|
|
|
+ for (int y = sy + 1; y < ey; y++) {
|
|
|
+ if (left) {
|
|
|
+ if (image.get(x, y) && !image.get(x, y + 1)) {
|
|
|
+ points.push_back(Point(x, y + 0.5f));
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (!image.get(x, y) && image.get(x, y + 1)) {
|
|
|
+ points.push_back(Point(x, y + 0.5f));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // Vertical
|
|
|
+ if (ydist < 0)
|
|
|
+ skip = -skip;
|
|
|
+
|
|
|
+ var = int(abs(deviation * length / ydist));
|
|
|
+
|
|
|
+ float dx = xdist / ydist * skip;
|
|
|
+ bool down = (skip > 0) ^ invert;
|
|
|
+ int y = int(start.y);
|
|
|
+
|
|
|
+ int steps = int(ydist / skip);
|
|
|
+ for (int i = 0; i < steps; i++) {
|
|
|
+ y += skip;
|
|
|
+ if (y < 0 || y >= (int)image.getHeight())
|
|
|
+ continue; // In case we start off the edge
|
|
|
+ int mx = int(start.x + dx * i);
|
|
|
+ int ex = min(mx + var + 1, (int)image.getWidth() - 1);
|
|
|
+ int sx = max(mx - var, 0);
|
|
|
+ for (int x = sx + 1; x < ex; x++) {
|
|
|
+ if (down) {
|
|
|
+ if (image.get(x, y) && !image.get(x + 1, y)) {
|
|
|
+ points.push_back(Point(x + 0.5f, y));
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+ if (!image.get(x, y) && image.get(x + 1, y)) {
|
|
|
+ points.push_back(Point(x + 0.5f, y));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Line findLine(const BitMatrix& image, Line estimate, bool invert, int deviation, float threshold, int skip) {
|
|
|
+ float t = threshold * threshold;
|
|
|
+
|
|
|
+ Point start = estimate.start;
|
|
|
+ Point end = estimate.end;
|
|
|
+
|
|
|
+ vector<Point> edges;
|
|
|
+ edges.clear();
|
|
|
+ findEdgePoints(edges, image, start, end, invert, skip, deviation);
|
|
|
+
|
|
|
+ int n = edges.size();
|
|
|
+
|
|
|
+ float xdist = end.x - start.x;
|
|
|
+ float ydist = end.y - start.y;
|
|
|
+
|
|
|
+ bool horizontal = abs(xdist) > abs(ydist);
|
|
|
+
|
|
|
+ float max = 0;
|
|
|
+ Line bestLine(start, end); // prepopulate with the given line, in case we can't find any line for some reason
|
|
|
+
|
|
|
+ for (int i = -deviation; i < deviation; i++) {
|
|
|
+ float x1, y1;
|
|
|
+ if (horizontal) {
|
|
|
+ y1 = start.y + i;
|
|
|
+ x1 = start.x - i * ydist / xdist;
|
|
|
+ } else {
|
|
|
+ y1 = start.y - i * xdist / ydist;
|
|
|
+ x1 = start.x + i;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int j = -deviation; j < deviation; j++) {
|
|
|
+ float x2, y2;
|
|
|
+ if (horizontal) {
|
|
|
+ y2 = end.y + j;
|
|
|
+ x2 = end.x - j * ydist / xdist;
|
|
|
+ } else {
|
|
|
+ y2 = end.y - j * xdist / ydist;
|
|
|
+ x2 = end.x + j;
|
|
|
+ }
|
|
|
+
|
|
|
+ float dx = x1 - x2;
|
|
|
+ float dy = y1 - y2;
|
|
|
+ float length = sqrt(dx * dx + dy * dy);
|
|
|
+
|
|
|
+ float score = 0;
|
|
|
+
|
|
|
+ for(int k = 0; k < n; k++) {
|
|
|
+ const Point& edge = edges[k];
|
|
|
+ float dist = ((x1 - edge.x) * dy - (y1 - edge.y) * dx) / length;
|
|
|
+ // Similar to least squares method
|
|
|
+ float s = t - dist * dist;
|
|
|
+ if (s > 0)
|
|
|
+ score += s;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (score > max) {
|
|
|
+ max = score;
|
|
|
+ bestLine.start = Point(x1, y1);
|
|
|
+ bestLine.end = Point(x2, y2);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return bestLine;
|
|
|
+}
|
|
|
+
|
|
|
+Point intersection(Line a, Line b) {
|
|
|
+ float dxa = a.start.x - a.end.x;
|
|
|
+ float dxb = b.start.x - b.end.x;
|
|
|
+ float dya = a.start.y - a.end.y;
|
|
|
+ float dyb = b.start.y - b.end.y;
|
|
|
+
|
|
|
+ float p = a.start.x * a.end.y - a.start.y * a.end.x;
|
|
|
+ float q = b.start.x * b.end.y - b.start.y * b.end.x;
|
|
|
+ float denom = dxa * dyb - dya * dxb;
|
|
|
+ if(denom == 0) // Lines don't intersect
|
|
|
+ return Point(INFINITY, INFINITY);
|
|
|
+
|
|
|
+ float x = (p * dxb - dxa * q) / denom;
|
|
|
+ float y = (p * dyb - dya * q) / denom;
|
|
|
+
|
|
|
+ return Point(x, y);
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace EdgeDetector
|
|
|
+} // namespace zxing
|
|
|
+
|
|
|
+// file: zxing/common/GlobalHistogramBinarizer.cpp
|
|
|
+
|
|
|
+// -*- 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/common/IllegalArgumentException.h>
|
|
|
+// #include <zxing/common/Array.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+const int LUMINANCE_BITS_25 = 5;
|
|
|
+const int LUMINANCE_SHIFT_25 = 8 - LUMINANCE_BITS_25;
|
|
|
+const int LUMINANCE_BUCKETS_25 = 1 << LUMINANCE_BITS_25;
|
|
|
+
|
|
|
+GlobalHistogramBinarizer::GlobalHistogramBinarizer(Ref<LuminanceSource> source) :
|
|
|
+ Binarizer(source), cached_matrix_(NULL), cached_row_(NULL), cached_row_num_(-1) {
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+GlobalHistogramBinarizer::~GlobalHistogramBinarizer() {
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+Ref<BitArray> GlobalHistogramBinarizer::getBlackRow(int y, Ref<BitArray> row) {
|
|
|
+ if (y == cached_row_num_) {
|
|
|
+ if (cached_row_ != NULL) {
|
|
|
+ return cached_row_;
|
|
|
+ } else {
|
|
|
+ throw IllegalArgumentException("Too little dynamic range in luminance");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ vector<int> histogram(LUMINANCE_BUCKETS_25, 0);
|
|
|
+ LuminanceSource& source = *getLuminanceSource();
|
|
|
+ int width = source.getWidth();
|
|
|
+ if (row == NULL || static_cast<int>(row->getSize()) < width) {
|
|
|
+ row = new BitArray(width);
|
|
|
+ } else {
|
|
|
+ row->clear();
|
|
|
+ }
|
|
|
+
|
|
|
+ //TODO(flyashi): cache this instead of allocating and deleting per row
|
|
|
+ unsigned char* row_pixels = NULL;
|
|
|
+ try {
|
|
|
+ row_pixels = new unsigned char[width];
|
|
|
+ row_pixels = source.getRow(y, row_pixels);
|
|
|
+ for (int x = 0; x < width; x++) {
|
|
|
+ histogram[row_pixels[x] >> LUMINANCE_SHIFT_25]++;
|
|
|
+ }
|
|
|
+ int blackPoint = estimate(histogram);
|
|
|
+
|
|
|
+ BitArray& array = *row;
|
|
|
+ int left = row_pixels[0];
|
|
|
+ int center = row_pixels[1];
|
|
|
+ for (int x = 1; x < width - 1; x++) {
|
|
|
+ int right = row_pixels[x + 1];
|
|
|
+ // A simple -1 4 -1 box filter with a weight of 2.
|
|
|
+ int luminance = ((center << 2) - left - right) >> 1;
|
|
|
+ if (luminance < blackPoint) {
|
|
|
+ array.set(x);
|
|
|
+ }
|
|
|
+ left = center;
|
|
|
+ center = right;
|
|
|
+ }
|
|
|
+
|
|
|
+ cached_row_ = row;
|
|
|
+ cached_row_num_ = y;
|
|
|
+ delete [] row_pixels;
|
|
|
+ return row;
|
|
|
+ } catch (IllegalArgumentException const& iae) {
|
|
|
+ // Cache the fact that this row failed.
|
|
|
+ cached_row_ = NULL;
|
|
|
+ cached_row_num_ = y;
|
|
|
+ delete [] row_pixels;
|
|
|
+ throw iae;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> GlobalHistogramBinarizer::getBlackMatrix() {
|
|
|
+ if (cached_matrix_ != NULL) {
|
|
|
+ return cached_matrix_;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Faster than working with the reference
|
|
|
+ LuminanceSource& source = *getLuminanceSource();
|
|
|
+ int width = source.getWidth();
|
|
|
+ int height = source.getHeight();
|
|
|
+ vector<int> histogram(LUMINANCE_BUCKETS_25, 0);
|
|
|
+
|
|
|
+ // 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.
|
|
|
+ ArrayRef<unsigned char> ref (width);
|
|
|
+ unsigned char* row = &ref[0];
|
|
|
+ for (int y = 1; y < 5; y++) {
|
|
|
+ int rownum = height * y / 5;
|
|
|
+ int right = (width << 2) / 5;
|
|
|
+ row = source.getRow(rownum, row);
|
|
|
+ for (int x = width / 5; x < right; x++) {
|
|
|
+ histogram[row[x] >> LUMINANCE_SHIFT_25]++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int blackPoint = estimate(histogram);
|
|
|
+
|
|
|
+ Ref<BitMatrix> matrix_ref(new BitMatrix(width, height));
|
|
|
+ BitMatrix& matrix = *matrix_ref;
|
|
|
+ for (int y = 0; y < height; y++) {
|
|
|
+ row = source.getRow(y, row);
|
|
|
+ for (int x = 0; x < width; x++) {
|
|
|
+ if (row[x] < blackPoint)
|
|
|
+ matrix.set(x, y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ cached_matrix_ = matrix_ref;
|
|
|
+ // delete [] row;
|
|
|
+ return matrix_ref;
|
|
|
+}
|
|
|
+
|
|
|
+int GlobalHistogramBinarizer::estimate(vector<int> &histogram) {
|
|
|
+ int numBuckets = histogram.size();
|
|
|
+ int maxBucketCount = 0;
|
|
|
+
|
|
|
+ // Find tallest peak in histogram
|
|
|
+ int firstPeak = 0;
|
|
|
+ int firstPeakSize = 0;
|
|
|
+ for (int i = 0; i < numBuckets; i++) {
|
|
|
+ if (histogram[i] > firstPeakSize) {
|
|
|
+ firstPeak = i;
|
|
|
+ firstPeakSize = histogram[i];
|
|
|
+ }
|
|
|
+ if (histogram[i] > maxBucketCount) {
|
|
|
+ maxBucketCount = histogram[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 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 i = 0; i < numBuckets; i++) {
|
|
|
+ int distanceToBiggest = i - firstPeak;
|
|
|
+ // Encourage more distant second peaks by multiplying by square of distance
|
|
|
+ int score = histogram[i] * distanceToBiggest * distanceToBiggest;
|
|
|
+ if (score > secondPeakScore) {
|
|
|
+ secondPeak = i;
|
|
|
+ secondPeakScore = score;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Put firstPeak first
|
|
|
+ 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"
|
|
|
+ if (secondPeak - firstPeak <= numBuckets >> 4) {
|
|
|
+ throw IllegalArgumentException("Too little dynamic range in luminance");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Find a valley between them that is low and closer to the white peak
|
|
|
+ int bestValley = secondPeak - 1;
|
|
|
+ int bestValleyScore = -1;
|
|
|
+ for (int i = secondPeak - 1; i > firstPeak; i--) {
|
|
|
+ int fromFirst = i - 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 - i) *
|
|
|
+ (maxBucketCount - histogram[i]);
|
|
|
+ if (score > bestValleyScore) {
|
|
|
+ bestValley = i;
|
|
|
+ bestValleyScore = score;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return bestValley << LUMINANCE_SHIFT_25;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<Binarizer> GlobalHistogramBinarizer::createBinarizer(Ref<LuminanceSource> source) {
|
|
|
+ return Ref<Binarizer> (new GlobalHistogramBinarizer(source));
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace zxing
|
|
|
+
|
|
|
+// file: zxing/common/GreyscaleLuminanceSource.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+GreyscaleLuminanceSource::GreyscaleLuminanceSource(unsigned char* greyData, int dataWidth,
|
|
|
+ int dataHeight, int left, int top, int width, int height) : greyData_(greyData),
|
|
|
+ dataWidth_(dataWidth), dataHeight_(dataHeight), left_(left), top_(top), width_(width),
|
|
|
+ height_(height) {
|
|
|
+
|
|
|
+ if (left + width > dataWidth || top + height > dataHeight || top < 0 || left < 0) {
|
|
|
+ throw IllegalArgumentException("Crop rectangle does not fit within image data.");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+unsigned char* GreyscaleLuminanceSource::getRow(int y, unsigned char* row) {
|
|
|
+ if (y < 0 || y >= this->getHeight()) {
|
|
|
+ throw IllegalArgumentException("Requested row is outside the image.");
|
|
|
+ }
|
|
|
+ int width = getWidth();
|
|
|
+ // TODO(flyashi): determine if row has enough size.
|
|
|
+ if (row == NULL) {
|
|
|
+ row = new unsigned char[width_];
|
|
|
+ }
|
|
|
+ int offset = (y + top_) * dataWidth_ + left_;
|
|
|
+ memcpy(row, &greyData_[offset], width);
|
|
|
+ return row;
|
|
|
+}
|
|
|
+
|
|
|
+unsigned char* GreyscaleLuminanceSource::getMatrix() {
|
|
|
+ int size = width_ * height_;
|
|
|
+ unsigned char* result = new unsigned char[size];
|
|
|
+ if (left_ == 0 && top_ == 0 && dataWidth_ == width_ && dataHeight_ == height_) {
|
|
|
+ memcpy(result, greyData_, size);
|
|
|
+ } else {
|
|
|
+ for (int row = 0; row < height_; row++) {
|
|
|
+ memcpy(result + row * width_, greyData_ + (top_ + row) * dataWidth_ + left_, width_);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<LuminanceSource> GreyscaleLuminanceSource::rotateCounterClockwise() {
|
|
|
+ // Intentionally flip the left, top, width, and height arguments as needed. dataWidth and
|
|
|
+ // dataHeight are always kept unrotated.
|
|
|
+ return Ref<LuminanceSource> (new GreyscaleRotatedLuminanceSource(greyData_, dataWidth_,
|
|
|
+ dataHeight_, top_, left_, height_, width_));
|
|
|
+}
|
|
|
+
|
|
|
+} /* namespace */
|
|
|
+
|
|
|
+// file: zxing/common/GreyscaleRotatedLuminanceSource.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+// 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(unsigned char* greyData,
|
|
|
+ int dataWidth, int dataHeight, int left, int top, int width, int height) : greyData_(greyData),
|
|
|
+ dataWidth_(dataWidth), dataHeight_(dataHeight), left_(left), top_(top), width_(width),
|
|
|
+ height_(height) {
|
|
|
+
|
|
|
+ // 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.
|
|
|
+unsigned char* GreyscaleRotatedLuminanceSource::getRow(int y, unsigned char* row) {
|
|
|
+ if (y < 0 || y >= getHeight()) {
|
|
|
+ throw IllegalArgumentException("Requested row is outside the image");
|
|
|
+ }
|
|
|
+ int width = getWidth();
|
|
|
+ if (row == NULL) {
|
|
|
+ row = new unsigned char[width];
|
|
|
+ }
|
|
|
+ int offset = (left_ * dataWidth_) + (dataWidth_ - (y + top_));
|
|
|
+ for (int x = 0; x < width; x++) {
|
|
|
+ row[x] = greyData_[offset];
|
|
|
+ offset += dataWidth_;
|
|
|
+ }
|
|
|
+ return row;
|
|
|
+}
|
|
|
+
|
|
|
+unsigned char* GreyscaleRotatedLuminanceSource::getMatrix() {
|
|
|
+ unsigned char* result = new unsigned char[width_ * height_];
|
|
|
+ // This depends on getRow() honoring its second parameter.
|
|
|
+ for (int y = 0; y < height_; y++) {
|
|
|
+ getRow(y, &result[y * width_]);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace
|
|
|
+
|
|
|
+// file: zxing/common/GridSampler.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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] = width - 1;
|
|
|
+ }
|
|
|
+ if (y == -1) {
|
|
|
+ points[offset + 1] = 0.0f;
|
|
|
+ } else if (y == height) {
|
|
|
+ points[offset + 1] = height - 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+GridSampler &GridSampler::getInstance() {
|
|
|
+ return gridSampler;
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/HybridBinarizer.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * HybridBinarizer.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/HybridBinarizer.h>
|
|
|
+
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+using namespace zxing;
|
|
|
+
|
|
|
+namespace {
|
|
|
+ const int BLOCK_SIZE_POWER = 3;
|
|
|
+ const int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER;
|
|
|
+ const int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;
|
|
|
+ const int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
|
|
|
+}
|
|
|
+
|
|
|
+HybridBinarizer::HybridBinarizer(Ref<LuminanceSource> source) :
|
|
|
+ GlobalHistogramBinarizer(source), matrix_(NULL), cached_row_(NULL), cached_row_num_(-1) {
|
|
|
+}
|
|
|
+
|
|
|
+HybridBinarizer::~HybridBinarizer() {
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+Ref<Binarizer>
|
|
|
+HybridBinarizer::createBinarizer(Ref<LuminanceSource> source) {
|
|
|
+ return Ref<Binarizer> (new HybridBinarizer(source));
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> HybridBinarizer::getBlackMatrix() {
|
|
|
+ // Calculates the final BitMatrix once for all requests. This could
|
|
|
+ // be called once from the constructor instead, but there are some
|
|
|
+ // advantages to doing it lazily, such as making profiling easier,
|
|
|
+ // and not doing heavy lifting when callers don't expect it.
|
|
|
+ if (matrix_) {
|
|
|
+ return matrix_;
|
|
|
+ }
|
|
|
+ LuminanceSource& source = *getLuminanceSource();
|
|
|
+ if (source.getWidth() >= MINIMUM_DIMENSION &&
|
|
|
+ source.getHeight() >= MINIMUM_DIMENSION) {
|
|
|
+ unsigned char* luminances = source.getMatrix();
|
|
|
+ int width = source.getWidth();
|
|
|
+ int height = source.getHeight();
|
|
|
+ int subWidth = width >> BLOCK_SIZE_POWER;
|
|
|
+ if ((width & BLOCK_SIZE_MASK) != 0) {
|
|
|
+ subWidth++;
|
|
|
+ }
|
|
|
+ int subHeight = height >> BLOCK_SIZE_POWER;
|
|
|
+ if ((height & BLOCK_SIZE_MASK) != 0) {
|
|
|
+ subHeight++;
|
|
|
+ }
|
|
|
+ int* blackPoints =
|
|
|
+ calculateBlackPoints(luminances, subWidth, subHeight, width, height);
|
|
|
+
|
|
|
+ Ref<BitMatrix> newMatrix (new BitMatrix(width, height));
|
|
|
+ calculateThresholdForBlock(luminances,
|
|
|
+ subWidth,
|
|
|
+ subHeight,
|
|
|
+ width,
|
|
|
+ height,
|
|
|
+ blackPoints,
|
|
|
+ newMatrix);
|
|
|
+ matrix_ = newMatrix;
|
|
|
+
|
|
|
+ // N.B.: these deletes are inadequate if anything between the new
|
|
|
+ // and this point can throw. As of this writing, it doesn't look
|
|
|
+ // like they do.
|
|
|
+
|
|
|
+ delete [] blackPoints;
|
|
|
+ delete [] luminances;
|
|
|
+ } else {
|
|
|
+ // If the image is too small, fall back to the global histogram approach.
|
|
|
+ matrix_ = GlobalHistogramBinarizer::getBlackMatrix();
|
|
|
+ }
|
|
|
+ return matrix_;
|
|
|
+}
|
|
|
+
|
|
|
+void
|
|
|
+HybridBinarizer::calculateThresholdForBlock(unsigned char* luminances,
|
|
|
+ int subWidth,
|
|
|
+ int subHeight,
|
|
|
+ int width,
|
|
|
+ int height,
|
|
|
+ int blackPoints[],
|
|
|
+ Ref<BitMatrix> const& matrix) {
|
|
|
+ for (int y = 0; y < subHeight; y++) {
|
|
|
+ int yoffset = y << BLOCK_SIZE_POWER;
|
|
|
+ if (yoffset + BLOCK_SIZE >= height) {
|
|
|
+ yoffset = height - BLOCK_SIZE;
|
|
|
+ }
|
|
|
+ for (int x = 0; x < subWidth; x++) {
|
|
|
+ int xoffset = x << BLOCK_SIZE_POWER;
|
|
|
+ if (xoffset + BLOCK_SIZE >= width) {
|
|
|
+ xoffset = width - BLOCK_SIZE;
|
|
|
+ }
|
|
|
+ int left = (x > 1) ? x : 2;
|
|
|
+ left = (left < subWidth - 2) ? left : subWidth - 3;
|
|
|
+ int top = (y > 1) ? y : 2;
|
|
|
+ top = (top < subHeight - 2) ? top : subHeight - 3;
|
|
|
+ int sum = 0;
|
|
|
+ for (int z = -2; z <= 2; z++) {
|
|
|
+ int *blackRow = &blackPoints[(top + z) * subWidth];
|
|
|
+ sum += blackRow[left - 2];
|
|
|
+ sum += blackRow[left - 1];
|
|
|
+ sum += blackRow[left];
|
|
|
+ sum += blackRow[left + 1];
|
|
|
+ sum += blackRow[left + 2];
|
|
|
+ }
|
|
|
+ int average = sum / 25;
|
|
|
+ threshold8x8Block(luminances, xoffset, yoffset, average, width, matrix);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void HybridBinarizer::threshold8x8Block(unsigned char* luminances,
|
|
|
+ int xoffset,
|
|
|
+ int yoffset,
|
|
|
+ int threshold,
|
|
|
+ int stride,
|
|
|
+ Ref<BitMatrix> const& matrix) {
|
|
|
+ for (int y = 0, offset = yoffset * stride + xoffset;
|
|
|
+ y < BLOCK_SIZE;
|
|
|
+ y++, offset += stride) {
|
|
|
+ for (int x = 0; x < BLOCK_SIZE; x++) {
|
|
|
+ int pixel = luminances[offset + x] & 0xff;
|
|
|
+ if (pixel <= threshold) {
|
|
|
+ matrix->set(xoffset + x, yoffset + y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+namespace {
|
|
|
+ inline int getBlackPointFromNeighbors(int* blackPoints, int subWidth, int x, int y) {
|
|
|
+ return (blackPoints[(y-1)*subWidth+x] +
|
|
|
+ 2*blackPoints[y*subWidth+x-1] +
|
|
|
+ blackPoints[(y-1)*subWidth+x-1]) >> 2;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int* HybridBinarizer::calculateBlackPoints(unsigned char* luminances, int subWidth, int subHeight,
|
|
|
+ int width, int height) {
|
|
|
+ int *blackPoints = new int[subHeight * subWidth];
|
|
|
+ for (int y = 0; y < subHeight; y++) {
|
|
|
+ int yoffset = y << BLOCK_SIZE_POWER;
|
|
|
+ if (yoffset + BLOCK_SIZE >= height) {
|
|
|
+ yoffset = height - BLOCK_SIZE;
|
|
|
+ }
|
|
|
+ for (int x = 0; x < subWidth; x++) {
|
|
|
+ int xoffset = x << BLOCK_SIZE_POWER;
|
|
|
+ if (xoffset + BLOCK_SIZE >= width) {
|
|
|
+ xoffset = width - BLOCK_SIZE;
|
|
|
+ }
|
|
|
+ int sum = 0;
|
|
|
+ int min = 0xFF;
|
|
|
+ int max = 0;
|
|
|
+ for (int yy = 0, offset = yoffset * width + xoffset;
|
|
|
+ yy < BLOCK_SIZE;
|
|
|
+ yy++, offset += width) {
|
|
|
+ for (int xx = 0; xx < BLOCK_SIZE; xx++) {
|
|
|
+ int pixel = luminances[offset + xx] & 0xFF;
|
|
|
+ sum += pixel;
|
|
|
+ if (pixel < min) {
|
|
|
+ min = pixel;
|
|
|
+ }
|
|
|
+ if (pixel > max) {
|
|
|
+ max = pixel;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // See
|
|
|
+ // http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
|
|
|
+ int average = sum >> 6;
|
|
|
+ if (max - min <= 24) {
|
|
|
+ average = min >> 1;
|
|
|
+ if (y > 0 && x > 0) {
|
|
|
+ int bp = getBlackPointFromNeighbors(blackPoints, subWidth, x, y);
|
|
|
+ if (min < bp) {
|
|
|
+ average = bp;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ blackPoints[y * subWidth + x] = average;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return blackPoints;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// file: zxing/common/IllegalArgumentException.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * IllegalArgumentException.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 06/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+IllegalArgumentException::IllegalArgumentException(const char *msg) :
|
|
|
+ Exception(msg) {
|
|
|
+}
|
|
|
+IllegalArgumentException::~IllegalArgumentException() throw() {
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/PerspectiveTransform.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * PerspectiveTransform.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 12/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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/PerspectiveTransform.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+PerspectiveTransform::PerspectiveTransform(float inA11, float inA21,
|
|
|
+ float inA31, float inA12,
|
|
|
+ float inA22, float inA32,
|
|
|
+ float inA13, float inA23,
|
|
|
+ float inA33) :
|
|
|
+ a11(inA11), a12(inA12), a13(inA13), a21(inA21), a22(inA22), a23(inA23),
|
|
|
+ a31(inA31), a32(inA32), a33(inA33) {}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToQuadrilateral(float x0, float y0, float x1, float y1,
|
|
|
+ float x2, float y2, float x3, float y3, float x0p, float y0p, float x1p, float y1p, float x2p, float y2p,
|
|
|
+ float x3p, float y3p) {
|
|
|
+ Ref<PerspectiveTransform> qToS = PerspectiveTransform::quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
|
|
|
+ Ref<PerspectiveTransform> sToQ =
|
|
|
+ PerspectiveTransform::squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
|
|
|
+ return sToQ->times(qToS);
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> PerspectiveTransform::squareToQuadrilateral(float x0, float y0, float x1, float y1, float x2,
|
|
|
+ float y2, float x3, float y3) {
|
|
|
+ float dy2 = y3 - y2;
|
|
|
+ float dy3 = y0 - y1 + y2 - y3;
|
|
|
+ if (dy2 == 0.0f && dy3 == 0.0f) {
|
|
|
+ Ref<PerspectiveTransform> result(new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f,
|
|
|
+ 0.0f, 1.0f));
|
|
|
+ return result;
|
|
|
+ } else {
|
|
|
+ float dx1 = x1 - x2;
|
|
|
+ float dx2 = x3 - x2;
|
|
|
+ float dx3 = x0 - x1 + x2 - x3;
|
|
|
+ float dy1 = y1 - y2;
|
|
|
+ float denominator = dx1 * dy2 - dx2 * dy1;
|
|
|
+ float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
|
|
|
+ float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
|
|
|
+ Ref<PerspectiveTransform> result(new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0
|
|
|
+ + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToSquare(float x0, float y0, float x1, float y1, float x2,
|
|
|
+ float y2, float x3, float y3) {
|
|
|
+ // Here, the adjoint serves as the inverse:
|
|
|
+ return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3)->buildAdjoint();
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> PerspectiveTransform::buildAdjoint() {
|
|
|
+ // Adjoint is the transpose of the cofactor matrix:
|
|
|
+ Ref<PerspectiveTransform> result(new PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32
|
|
|
+ - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22,
|
|
|
+ a13 * a21 - a11 * a23, a11 * a22 - a12 * a21));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> PerspectiveTransform::times(Ref<PerspectiveTransform> other) {
|
|
|
+ Ref<PerspectiveTransform> result(new PerspectiveTransform(a11 * other->a11 + a21 * other->a12 + a31 * other->a13,
|
|
|
+ a11 * other->a21 + a21 * other->a22 + a31 * other->a23, a11 * other->a31 + a21 * other->a32 + a31
|
|
|
+ * other->a33, a12 * other->a11 + a22 * other->a12 + a32 * other->a13, a12 * other->a21 + a22
|
|
|
+ * other->a22 + a32 * other->a23, a12 * other->a31 + a22 * other->a32 + a32 * other->a33, a13
|
|
|
+ * other->a11 + a23 * other->a12 + a33 * other->a13, a13 * other->a21 + a23 * other->a22 + a33
|
|
|
+ * other->a23, a13 * other->a31 + a23 * other->a32 + a33 * other->a33));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+void PerspectiveTransform::transformPoints(vector<float> &points) {
|
|
|
+ int max = points.size();
|
|
|
+ for (int i = 0; i < max; i += 2) {
|
|
|
+ float x = points[i];
|
|
|
+ float y = points[i + 1];
|
|
|
+ float denominator = a13 * x + a23 * y + a33;
|
|
|
+ points[i] = (a11 * x + a21 * y + a31) / denominator;
|
|
|
+ points[i + 1] = (a12 * x + a22 * y + a32) / denominator;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+ostream& operator<<(ostream& out, const PerspectiveTransform &pt) {
|
|
|
+ out << pt.a11 << ", " << pt.a12 << ", " << pt.a13 << ", \n";
|
|
|
+ out << pt.a21 << ", " << pt.a22 << ", " << pt.a23 << ", \n";
|
|
|
+ out << pt.a31 << ", " << pt.a32 << ", " << pt.a33 << "\n";
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/Str.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * String.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/common/Str.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+String::String(const std::string &text) :
|
|
|
+ text_(text) {
|
|
|
+}
|
|
|
+const std::string& String::getText() const {
|
|
|
+ return text_;
|
|
|
+}
|
|
|
+
|
|
|
+ostream &operator<<(ostream &out, const String &s) {
|
|
|
+ out << s.text_;
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/StringUtils.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright (C) 2010-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 <zxing/common/StringUtils.h>
|
|
|
+// #include <zxing/DecodeHints.h>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+using namespace zxing;
|
|
|
+using namespace zxing::common;
|
|
|
+
|
|
|
+// N.B.: these are the iconv strings for at least some versions of iconv
|
|
|
+
|
|
|
+char const* const StringUtils::PLATFORM_DEFAULT_ENCODING = "UTF-8";
|
|
|
+char const* const StringUtils::ASCII = "ASCII";
|
|
|
+char const* const StringUtils::SHIFT_JIS = "SHIFT_JIS";
|
|
|
+char const* const StringUtils::GB2312 = "GBK";
|
|
|
+char const* const StringUtils::EUC_JP = "EUC-JP";
|
|
|
+char const* const StringUtils::UTF8 = "UTF-8";
|
|
|
+char const* const StringUtils::ISO88591 = "ISO8859-1";
|
|
|
+const bool StringUtils::ASSUME_SHIFT_JIS = false;
|
|
|
+
|
|
|
+string
|
|
|
+StringUtils::guessEncoding(unsigned char* bytes, int length, Hashtable const& hints) {
|
|
|
+ Hashtable::const_iterator i = hints.find(DecodeHints::CHARACTER_SET);
|
|
|
+ if (i != hints.end()) {
|
|
|
+ return i->second;
|
|
|
+ }
|
|
|
+ // Does it start with the UTF-8 byte order mark? then guess it's UTF-8
|
|
|
+ if (length > 3 &&
|
|
|
+ bytes[0] == (unsigned char) 0xEF &&
|
|
|
+ bytes[1] == (unsigned char) 0xBB &&
|
|
|
+ bytes[2] == (unsigned char) 0xBF) {
|
|
|
+ return UTF8;
|
|
|
+ }
|
|
|
+ // For now, merely tries to distinguish ISO-8859-1, UTF-8 and Shift_JIS,
|
|
|
+ // which should be by far the most common encodings. ISO-8859-1
|
|
|
+ // should not have bytes in the 0x80 - 0x9F range, while Shift_JIS
|
|
|
+ // uses this as a first byte of a two-byte character. If we see this
|
|
|
+ // followed by a valid second byte in Shift_JIS, assume it is Shift_JIS.
|
|
|
+ // If we see something else in that second byte, we'll make the risky guess
|
|
|
+ // that it's UTF-8.
|
|
|
+ bool canBeISO88591 = true;
|
|
|
+ bool canBeShiftJIS = true;
|
|
|
+ bool canBeUTF8 = true;
|
|
|
+ int utf8BytesLeft = 0;
|
|
|
+ int maybeDoubleByteCount = 0;
|
|
|
+ int maybeSingleByteKatakanaCount = 0;
|
|
|
+ bool sawLatin1Supplement = false;
|
|
|
+ bool sawUTF8Start = false;
|
|
|
+ bool lastWasPossibleDoubleByteStart = false;
|
|
|
+
|
|
|
+ for (int i = 0;
|
|
|
+ i < length && (canBeISO88591 || canBeShiftJIS || canBeUTF8);
|
|
|
+ i++) {
|
|
|
+
|
|
|
+ int value = bytes[i] & 0xFF;
|
|
|
+
|
|
|
+ // UTF-8 stuff
|
|
|
+ if (value >= 0x80 && value <= 0xBF) {
|
|
|
+ if (utf8BytesLeft > 0) {
|
|
|
+ utf8BytesLeft--;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (utf8BytesLeft > 0) {
|
|
|
+ canBeUTF8 = false;
|
|
|
+ }
|
|
|
+ if (value >= 0xC0 && value <= 0xFD) {
|
|
|
+ sawUTF8Start = true;
|
|
|
+ int valueCopy = value;
|
|
|
+ while ((valueCopy & 0x40) != 0) {
|
|
|
+ utf8BytesLeft++;
|
|
|
+ valueCopy <<= 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // ISO-8859-1 stuff
|
|
|
+
|
|
|
+ if ((value == 0xC2 || value == 0xC3) && i < length - 1) {
|
|
|
+ // This is really a poor hack. The slightly more exotic characters people might want to put in
|
|
|
+ // a QR Code, by which I mean the Latin-1 supplement characters (e.g. u-umlaut) have encodings
|
|
|
+ // that start with 0xC2 followed by [0xA0,0xBF], or start with 0xC3 followed by [0x80,0xBF].
|
|
|
+ int nextValue = bytes[i + 1] & 0xFF;
|
|
|
+ if (nextValue <= 0xBF &&
|
|
|
+ ((value == 0xC2 && nextValue >= 0xA0) || (value == 0xC3 && nextValue >= 0x80))) {
|
|
|
+ sawLatin1Supplement = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (value >= 0x7F && value <= 0x9F) {
|
|
|
+ canBeISO88591 = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Shift_JIS stuff
|
|
|
+
|
|
|
+ if (value >= 0xA1 && value <= 0xDF) {
|
|
|
+ // count the number of characters that might be a Shift_JIS single-byte Katakana character
|
|
|
+ if (!lastWasPossibleDoubleByteStart) {
|
|
|
+ maybeSingleByteKatakanaCount++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!lastWasPossibleDoubleByteStart &&
|
|
|
+ ((value >= 0xF0 && value <= 0xFF) || value == 0x80 || value == 0xA0)) {
|
|
|
+ canBeShiftJIS = false;
|
|
|
+ }
|
|
|
+ if ((value >= 0x81 && value <= 0x9F) || (value >= 0xE0 && value <= 0xEF)) {
|
|
|
+ // These start double-byte characters in Shift_JIS. Let's see if it's followed by a valid
|
|
|
+ // second byte.
|
|
|
+ if (lastWasPossibleDoubleByteStart) {
|
|
|
+ // If we just checked this and the last byte for being a valid double-byte
|
|
|
+ // char, don't check starting on this byte. If this and the last byte
|
|
|
+ // formed a valid pair, then this shouldn't be checked to see if it starts
|
|
|
+ // a double byte pair of course.
|
|
|
+ lastWasPossibleDoubleByteStart = false;
|
|
|
+ } else {
|
|
|
+ // ... otherwise do check to see if this plus the next byte form a valid
|
|
|
+ // double byte pair encoding a character.
|
|
|
+ lastWasPossibleDoubleByteStart = true;
|
|
|
+ if (i >= length - 1) {
|
|
|
+ canBeShiftJIS = false;
|
|
|
+ } else {
|
|
|
+ int nextValue = bytes[i + 1] & 0xFF;
|
|
|
+ if (nextValue < 0x40 || nextValue > 0xFC) {
|
|
|
+ canBeShiftJIS = false;
|
|
|
+ } else {
|
|
|
+ maybeDoubleByteCount++;
|
|
|
+ }
|
|
|
+ // There is some conflicting information out there about which bytes can follow which in
|
|
|
+ // double-byte Shift_JIS characters. The rule above seems to be the one that matches practice.
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ lastWasPossibleDoubleByteStart = false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (utf8BytesLeft > 0) {
|
|
|
+ canBeUTF8 = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Easy -- if assuming Shift_JIS and no evidence it can't be, done
|
|
|
+ if (canBeShiftJIS && ASSUME_SHIFT_JIS) {
|
|
|
+ return SHIFT_JIS;
|
|
|
+ }
|
|
|
+ if (canBeUTF8 && sawUTF8Start) {
|
|
|
+ return UTF8;
|
|
|
+ }
|
|
|
+ // Distinguishing Shift_JIS and ISO-8859-1 can be a little tough. The crude heuristic is:
|
|
|
+ // - If we saw
|
|
|
+ // - at least 3 bytes that starts a double-byte value (bytes that are rare in ISO-8859-1), or
|
|
|
+ // - over 5% of bytes could be single-byte Katakana (also rare in ISO-8859-1),
|
|
|
+ // - and, saw no sequences that are invalid in Shift_JIS, then we conclude Shift_JIS
|
|
|
+ if (canBeShiftJIS && (maybeDoubleByteCount >= 3 || 20 * maybeSingleByteKatakanaCount > length)) {
|
|
|
+ return SHIFT_JIS;
|
|
|
+ }
|
|
|
+ // Otherwise, we default to ISO-8859-1 unless we know it can't be
|
|
|
+ if (!sawLatin1Supplement && canBeISO88591) {
|
|
|
+ return ISO88591;
|
|
|
+ }
|
|
|
+ // Otherwise, we take a wild guess with platform encoding
|
|
|
+ return PLATFORM_DEFAULT_ENCODING;
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/detector/MonochromeRectangleDetector.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * MonochromeRectangleDetector.cpp
|
|
|
+ * y_wmk
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * Copyright 2010 y_wmk 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/NotFoundException.h>
|
|
|
+// #include <zxing/common/detector/MonochromeRectangleDetector.h>
|
|
|
+// #include <sstream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+std::vector<Ref<ResultPoint> > MonochromeRectangleDetector::detect() {
|
|
|
+ int height = image_->getHeight();
|
|
|
+ int width = image_->getWidth();
|
|
|
+ int halfHeight = height >> 1;
|
|
|
+ int halfWidth = width >> 1;
|
|
|
+ int deltaY = max(1, height / (MAX_MODULES << 3));
|
|
|
+ int deltaX = max(1, width / (MAX_MODULES << 3));
|
|
|
+
|
|
|
+ int top = 0;
|
|
|
+ int bottom = height;
|
|
|
+ int left = 0;
|
|
|
+ int right = width;
|
|
|
+ Ref<ResultPoint> pointA(findCornerFromCenter(halfWidth, 0, left, right,
|
|
|
+ halfHeight, -deltaY, top, bottom, halfWidth >> 1));
|
|
|
+ top = (int) pointA->getY() - 1;;
|
|
|
+ Ref<ResultPoint> pointB(findCornerFromCenter(halfWidth, -deltaX, left, right,
|
|
|
+ halfHeight, 0, top, bottom, halfHeight >> 1));
|
|
|
+ left = (int) pointB->getX() - 1;
|
|
|
+ Ref<ResultPoint> pointC(findCornerFromCenter(halfWidth, deltaX, left, right,
|
|
|
+ halfHeight, 0, top, bottom, halfHeight >> 1));
|
|
|
+ right = (int) pointC->getX() + 1;
|
|
|
+ Ref<ResultPoint> pointD(findCornerFromCenter(halfWidth, 0, left, right,
|
|
|
+ halfHeight, deltaY, top, bottom, halfWidth >> 1));
|
|
|
+ bottom = (int) pointD->getY() + 1;
|
|
|
+
|
|
|
+ // Go try to find point A again with better information -- might have been off at first.
|
|
|
+ pointA.reset(findCornerFromCenter(halfWidth, 0, left, right,
|
|
|
+ halfHeight, -deltaY, top, bottom, halfWidth >> 2));
|
|
|
+
|
|
|
+ std::vector<Ref<ResultPoint> > corners(4);
|
|
|
+ corners[0].reset(pointA);
|
|
|
+ corners[1].reset(pointB);
|
|
|
+ corners[2].reset(pointC);
|
|
|
+ corners[3].reset(pointD);
|
|
|
+ return corners;
|
|
|
+ }
|
|
|
+
|
|
|
+Ref<ResultPoint> MonochromeRectangleDetector::findCornerFromCenter(int centerX, int deltaX, int left, int right,
|
|
|
+ int centerY, int deltaY, int top, int bottom, int maxWhiteRun) {
|
|
|
+ Ref<TwoInts> lastRange(NULL);
|
|
|
+ for (int y = centerY, x = centerX;
|
|
|
+ y < bottom && y >= top && x < right && x >= left;
|
|
|
+ y += deltaY, x += deltaX) {
|
|
|
+ Ref<TwoInts> range(NULL);
|
|
|
+ if (deltaX == 0) {
|
|
|
+ // horizontal slices, up and down
|
|
|
+ range = blackWhiteRange(y, maxWhiteRun, left, right, true);
|
|
|
+ } else {
|
|
|
+ // vertical slices, left and right
|
|
|
+ range = blackWhiteRange(x, maxWhiteRun, top, bottom, false);
|
|
|
+ }
|
|
|
+ if (range == NULL) {
|
|
|
+ if (lastRange == NULL) {
|
|
|
+ throw NotFoundException("Couldn't find corners (lastRange = NULL) ");
|
|
|
+ } else {
|
|
|
+ // lastRange was found
|
|
|
+ if (deltaX == 0) {
|
|
|
+ int lastY = y - deltaY;
|
|
|
+ if (lastRange->start < centerX) {
|
|
|
+ if (lastRange->end > centerX) {
|
|
|
+ // straddle, choose one or the other based on direction
|
|
|
+ Ref<ResultPoint> result(new ResultPoint(deltaY > 0 ? lastRange->start : lastRange->end, lastY));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ Ref<ResultPoint> result(new ResultPoint(lastRange->start, lastY));
|
|
|
+ return result;
|
|
|
+ } else {
|
|
|
+ Ref<ResultPoint> result(new ResultPoint(lastRange->end, lastY));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ int lastX = x - deltaX;
|
|
|
+ if (lastRange->start < centerY) {
|
|
|
+ if (lastRange->end > centerY) {
|
|
|
+ Ref<ResultPoint> result(new ResultPoint(lastX, deltaX < 0 ? lastRange->start : lastRange->end));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ Ref<ResultPoint> result(new ResultPoint(lastX, lastRange->start));
|
|
|
+ return result;
|
|
|
+ } else {
|
|
|
+ Ref<ResultPoint> result(new ResultPoint(lastX, lastRange->end));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ lastRange = range;
|
|
|
+ }
|
|
|
+ throw NotFoundException("Couldn't find corners");
|
|
|
+ }
|
|
|
+
|
|
|
+Ref<TwoInts> MonochromeRectangleDetector::blackWhiteRange(int fixedDimension, int maxWhiteRun, int minDim, int maxDim,
|
|
|
+ bool horizontal) {
|
|
|
+
|
|
|
+ int center = (minDim + maxDim) >> 1;
|
|
|
+
|
|
|
+ // Scan left/up first
|
|
|
+ int start = center;
|
|
|
+ while (start >= minDim) {
|
|
|
+ if (horizontal ? image_->get(start, fixedDimension) : image_->get(fixedDimension, start)) {
|
|
|
+ start--;
|
|
|
+ } else {
|
|
|
+ int whiteRunStart = start;
|
|
|
+ do {
|
|
|
+ start--;
|
|
|
+ } while (start >= minDim && !(horizontal ? image_->get(start, fixedDimension) :
|
|
|
+ image_->get(fixedDimension, start)));
|
|
|
+ int whiteRunSize = whiteRunStart - start;
|
|
|
+ if (start < minDim || whiteRunSize > maxWhiteRun) {
|
|
|
+ start = whiteRunStart;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ start++;
|
|
|
+
|
|
|
+ // Then try right/down
|
|
|
+ int end = center;
|
|
|
+ while (end < maxDim) {
|
|
|
+ if (horizontal ? image_->get(end, fixedDimension) : image_->get(fixedDimension, end)) {
|
|
|
+ end++;
|
|
|
+ } else {
|
|
|
+ int whiteRunStart = end;
|
|
|
+ do {
|
|
|
+ end++;
|
|
|
+ } while (end < maxDim && !(horizontal ? image_->get(end, fixedDimension) :
|
|
|
+ image_->get(fixedDimension, end)));
|
|
|
+ int whiteRunSize = end - whiteRunStart;
|
|
|
+ if (end >= maxDim || whiteRunSize > maxWhiteRun) {
|
|
|
+ end = whiteRunStart;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ end--;
|
|
|
+ Ref<TwoInts> result(NULL);
|
|
|
+ if (end > start) {
|
|
|
+ result = new TwoInts;
|
|
|
+ result->start = start;
|
|
|
+ result->end = end;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/detector/WhiteRectangleDetector.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * WhiteRectangleDetector.cpp
|
|
|
+ * y_wmk
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * Copyright 2010 y_wmk 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/NotFoundException.h>
|
|
|
+// #include <zxing/common/detector/WhiteRectangleDetector.h>
|
|
|
+// #include <math.h>
|
|
|
+// #include <sstream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+int WhiteRectangleDetector::INIT_SIZE = 30;
|
|
|
+int WhiteRectangleDetector::CORR = 1;
|
|
|
+
|
|
|
+
|
|
|
+WhiteRectangleDetector::WhiteRectangleDetector(Ref<BitMatrix> image) : image_(image) {
|
|
|
+ width_ = image->getWidth();
|
|
|
+ height_ = image->getHeight();
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * <p>
|
|
|
+ * Detects a candidate barcode-like rectangular region within an image. It
|
|
|
+ * starts around the center of the image, increases the size of the candidate
|
|
|
+ * region until it finds a white rectangular region.
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @return {@link vector<Ref<ResultPoint> >} describing the corners of the rectangular
|
|
|
+ * region. The first and last points are opposed on the diagonal, as
|
|
|
+ * are the second and third. The first point will be the topmost
|
|
|
+ * point and the last, the bottommost. The second point will be
|
|
|
+ * leftmost and the third, the rightmost
|
|
|
+ * @throws NotFoundException if no Data Matrix Code can be found
|
|
|
+*/
|
|
|
+std::vector<Ref<ResultPoint> > WhiteRectangleDetector::detect() {
|
|
|
+ int left = (width_ - INIT_SIZE) >> 1;
|
|
|
+ int right = (width_ + INIT_SIZE) >> 1;
|
|
|
+ int up = (height_ - INIT_SIZE) >> 1;
|
|
|
+ int down = (height_ + INIT_SIZE) >> 1;
|
|
|
+ if (up < 0 || left < 0 || down >= height_ || right >= width_) {
|
|
|
+ throw NotFoundException("Invalid dimensions WhiteRectangleDetector");
|
|
|
+ }
|
|
|
+
|
|
|
+ bool sizeExceeded = false;
|
|
|
+ bool aBlackPointFoundOnBorder = true;
|
|
|
+ bool atLeastOneBlackPointFoundOnBorder = false;
|
|
|
+
|
|
|
+ while (aBlackPointFoundOnBorder) {
|
|
|
+ aBlackPointFoundOnBorder = false;
|
|
|
+
|
|
|
+ // .....
|
|
|
+ // . |
|
|
|
+ // .....
|
|
|
+ bool rightBorderNotWhite = true;
|
|
|
+ while (rightBorderNotWhite && right < width_) {
|
|
|
+ rightBorderNotWhite = containsBlackPoint(up, down, right, false);
|
|
|
+ if (rightBorderNotWhite) {
|
|
|
+ right++;
|
|
|
+ aBlackPointFoundOnBorder = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (right >= width_) {
|
|
|
+ sizeExceeded = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // .....
|
|
|
+ // . .
|
|
|
+ // .___.
|
|
|
+ bool bottomBorderNotWhite = true;
|
|
|
+ while (bottomBorderNotWhite && down < height_) {
|
|
|
+ bottomBorderNotWhite = containsBlackPoint(left, right, down, true);
|
|
|
+ if (bottomBorderNotWhite) {
|
|
|
+ down++;
|
|
|
+ aBlackPointFoundOnBorder = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (down >= height_) {
|
|
|
+ sizeExceeded = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // .....
|
|
|
+ // | .
|
|
|
+ // .....
|
|
|
+ bool leftBorderNotWhite = true;
|
|
|
+ while (leftBorderNotWhite && left >= 0) {
|
|
|
+ leftBorderNotWhite = containsBlackPoint(up, down, left, false);
|
|
|
+ if (leftBorderNotWhite) {
|
|
|
+ left--;
|
|
|
+ aBlackPointFoundOnBorder = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (left < 0) {
|
|
|
+ sizeExceeded = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // .___.
|
|
|
+ // . .
|
|
|
+ // .....
|
|
|
+ bool topBorderNotWhite = true;
|
|
|
+ while (topBorderNotWhite && up >= 0) {
|
|
|
+ topBorderNotWhite = containsBlackPoint(left, right, up, true);
|
|
|
+ if (topBorderNotWhite) {
|
|
|
+ up--;
|
|
|
+ aBlackPointFoundOnBorder = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (up < 0) {
|
|
|
+ sizeExceeded = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (aBlackPointFoundOnBorder) {
|
|
|
+ atLeastOneBlackPointFoundOnBorder = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ if (!sizeExceeded && atLeastOneBlackPointFoundOnBorder) {
|
|
|
+
|
|
|
+ int maxSize = right - left;
|
|
|
+
|
|
|
+ Ref<ResultPoint> z(NULL);
|
|
|
+ //go up right
|
|
|
+ for (int i = 1; i < maxSize; i++) {
|
|
|
+ z = getBlackPointOnSegment(left, down - i, left + i, down);
|
|
|
+ if (z != NULL) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (z == NULL) {
|
|
|
+ throw NotFoundException("z == NULL");
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<ResultPoint> t(NULL);
|
|
|
+ //go down right
|
|
|
+ for (int i = 1; i < maxSize; i++) {
|
|
|
+ t = getBlackPointOnSegment(left, up + i, left + i, up);
|
|
|
+ if (t != NULL) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (t == NULL) {
|
|
|
+ throw NotFoundException("t == NULL");
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<ResultPoint> x(NULL);
|
|
|
+ //go down left
|
|
|
+ for (int i = 1; i < maxSize; i++) {
|
|
|
+ x = getBlackPointOnSegment(right, up + i, right - i, up);
|
|
|
+ if (x != NULL) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (x == NULL) {
|
|
|
+ throw NotFoundException("x == NULL");
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<ResultPoint> y(NULL);
|
|
|
+ //go up left
|
|
|
+ for (int i = 1; i < maxSize; i++) {
|
|
|
+ y = getBlackPointOnSegment(right, down - i, right - i, down);
|
|
|
+ if (y != NULL) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (y == NULL) {
|
|
|
+ throw NotFoundException("y == NULL");
|
|
|
+ }
|
|
|
+
|
|
|
+ return centerEdges(y, z, x, t);
|
|
|
+
|
|
|
+ } else {
|
|
|
+ throw NotFoundException("No black point found on border");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Ends up being a bit faster than Math.round(). This merely rounds its
|
|
|
+ * argument to the nearest int, where x.5 rounds up.
|
|
|
+ */
|
|
|
+int WhiteRectangleDetector::round(float d) {
|
|
|
+ return (int) (d + 0.5f);
|
|
|
+}
|
|
|
+
|
|
|
+Ref<ResultPoint> WhiteRectangleDetector::getBlackPointOnSegment(float aX, float aY, float bX, float bY) {
|
|
|
+ int dist = distanceL2(aX, aY, bX, bY);
|
|
|
+ float xStep = (bX - aX) / dist;
|
|
|
+ float yStep = (bY - aY) / dist;
|
|
|
+ for (int i = 0; i < dist; i++) {
|
|
|
+ int x = round(aX + i * xStep);
|
|
|
+ int y = round(aY + i * yStep);
|
|
|
+ if (image_->get(x, y)) {
|
|
|
+ Ref<ResultPoint> point(new ResultPoint(x, y));
|
|
|
+ return point;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ref<ResultPoint> point(NULL);
|
|
|
+ return point;
|
|
|
+}
|
|
|
+
|
|
|
+int WhiteRectangleDetector::distanceL2(float aX, float aY, float bX, float bY) {
|
|
|
+ float xDiff = aX - bX;
|
|
|
+ float yDiff = aY - bY;
|
|
|
+ return round((float)sqrt(xDiff * xDiff + yDiff * yDiff));
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * recenters the points of a constant distance towards the center
|
|
|
+ *
|
|
|
+ * @param y bottom most point
|
|
|
+ * @param z left most point
|
|
|
+ * @param x right most point
|
|
|
+ * @param t top most point
|
|
|
+ * @return {@link vector<Ref<ResultPoint> >} describing the corners of the rectangular
|
|
|
+ * region. The first and last points are opposed on the diagonal, as
|
|
|
+ * are the second and third. The first point will be the topmost
|
|
|
+ * point and the last, the bottommost. The second point will be
|
|
|
+ * leftmost and the third, the rightmost
|
|
|
+ */
|
|
|
+vector<Ref<ResultPoint> > WhiteRectangleDetector::centerEdges(Ref<ResultPoint> y, Ref<ResultPoint> z,
|
|
|
+ Ref<ResultPoint> x, Ref<ResultPoint> t) {
|
|
|
+
|
|
|
+ //
|
|
|
+ // t t
|
|
|
+ // z x
|
|
|
+ // x OR z
|
|
|
+ // y y
|
|
|
+ //
|
|
|
+
|
|
|
+ float yi = y->getX();
|
|
|
+ float yj = y->getY();
|
|
|
+ float zi = z->getX();
|
|
|
+ float zj = z->getY();
|
|
|
+ float xi = x->getX();
|
|
|
+ float xj = x->getY();
|
|
|
+ float ti = t->getX();
|
|
|
+ float tj = t->getY();
|
|
|
+
|
|
|
+ std::vector<Ref<ResultPoint> > corners(4);
|
|
|
+ if (yi < (float)width_/2) {
|
|
|
+ Ref<ResultPoint> pointA(new ResultPoint(ti - CORR, tj + CORR));
|
|
|
+ Ref<ResultPoint> pointB(new ResultPoint(zi + CORR, zj + CORR));
|
|
|
+ Ref<ResultPoint> pointC(new ResultPoint(xi - CORR, xj - CORR));
|
|
|
+ Ref<ResultPoint> pointD(new ResultPoint(yi + CORR, yj - CORR));
|
|
|
+ corners[0].reset(pointA);
|
|
|
+ corners[1].reset(pointB);
|
|
|
+ corners[2].reset(pointC);
|
|
|
+ corners[3].reset(pointD);
|
|
|
+ } else {
|
|
|
+ Ref<ResultPoint> pointA(new ResultPoint(ti + CORR, tj + CORR));
|
|
|
+ Ref<ResultPoint> pointB(new ResultPoint(zi + CORR, zj - CORR));
|
|
|
+ Ref<ResultPoint> pointC(new ResultPoint(xi - CORR, xj + CORR));
|
|
|
+ Ref<ResultPoint> pointD(new ResultPoint(yi - CORR, yj - CORR));
|
|
|
+ corners[0].reset(pointA);
|
|
|
+ corners[1].reset(pointB);
|
|
|
+ corners[2].reset(pointC);
|
|
|
+ corners[3].reset(pointD);
|
|
|
+ }
|
|
|
+ return corners;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Determines whether a segment contains a black point
|
|
|
+ *
|
|
|
+ * @param a min value of the scanned coordinate
|
|
|
+ * @param b max value of the scanned coordinate
|
|
|
+ * @param fixed value of fixed coordinate
|
|
|
+ * @param horizontal set to true if scan must be horizontal, false if vertical
|
|
|
+ * @return true if a black point has been found, else false.
|
|
|
+ */
|
|
|
+bool WhiteRectangleDetector::containsBlackPoint(int a, int b, int fixed, bool horizontal) {
|
|
|
+ if (horizontal) {
|
|
|
+ for (int x = a; x <= b; x++) {
|
|
|
+ if (image_->get(x, fixed)) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ for (int y = a; y <= b; y++) {
|
|
|
+ if (image_->get(fixed, y)) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/reedsolomon/GF256.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * GF256.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 05/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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 <vector>
|
|
|
+// #include <iostream>
|
|
|
+// #include <zxing/common/reedsolomon/GF256.h>
|
|
|
+// #include <zxing/common/reedsolomon/GF256Poly.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+// #include <zxing/common/Array.h>
|
|
|
+// #include <zxing/common/Counted.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+static inline ArrayRef<int> makeArray(int value) {
|
|
|
+ ArrayRef<int> valuesRef(new Array<int> (value, 1));
|
|
|
+ return valuesRef;
|
|
|
+}
|
|
|
+
|
|
|
+static inline Ref<GF256Poly> refPoly(GF256 &field, int value) {
|
|
|
+ ArrayRef<int> values(makeArray(value));
|
|
|
+ Ref<GF256Poly> result(new GF256Poly(field, values));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+GF256::GF256(int primitive) :
|
|
|
+ exp_(256, (const int)0), log_(256, (const int)0), zero_(refPoly(*this, 0)), one_(refPoly(*this, 1)) {
|
|
|
+ int x = 1;
|
|
|
+ for (int i = 0; i < 256; i++) {
|
|
|
+ exp_[i] = x;
|
|
|
+ x <<= 1;
|
|
|
+ if (x >= 0x100) {
|
|
|
+ x ^= primitive;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // log(0) == 0, but should never be used
|
|
|
+ log_[0] = 0;
|
|
|
+ for (int i = 0; i < 255; i++) {
|
|
|
+ log_[exp_[i]] = i;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256::getZero() {
|
|
|
+ return zero_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256::getOne() {
|
|
|
+ return one_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256::buildMonomial(int degree, int coefficient) {
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << __FUNCTION__ << "\n";
|
|
|
+#endif
|
|
|
+ if (degree < 0) {
|
|
|
+ throw IllegalArgumentException("Degree must be non-negative");
|
|
|
+ }
|
|
|
+ if (coefficient == 0) {
|
|
|
+ return zero_;
|
|
|
+ }
|
|
|
+ int nCoefficients = degree + 1;
|
|
|
+ ArrayRef<int> coefficients(new Array<int> (nCoefficients));
|
|
|
+ coefficients[0] = coefficient;
|
|
|
+ Ref<GF256Poly> result(new GF256Poly(*this, coefficients));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+int GF256::addOrSubtract(int a, int b) {
|
|
|
+ return a ^ b;
|
|
|
+}
|
|
|
+
|
|
|
+int GF256::exp(int a) {
|
|
|
+ return exp_[a];
|
|
|
+}
|
|
|
+
|
|
|
+int GF256::log(int a) {
|
|
|
+ if (a == 0) {
|
|
|
+ throw IllegalArgumentException("Cannot take the logarithm of 0");
|
|
|
+ }
|
|
|
+ return log_[a];
|
|
|
+}
|
|
|
+
|
|
|
+int GF256::inverse(int a) {
|
|
|
+ if (a == 0) {
|
|
|
+ throw IllegalArgumentException("Cannot calculate the inverse of 0");
|
|
|
+ }
|
|
|
+ return exp_[255 - log_[a]];
|
|
|
+}
|
|
|
+
|
|
|
+int GF256::multiply(int a, int b) {
|
|
|
+ if (a == 0 || b == 0) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ int logSum = log_[a] + log_[b];
|
|
|
+ // index is a sped-up alternative to logSum % 255 since sum
|
|
|
+ // is in [0,510]. Thanks to jmsachs for the idea
|
|
|
+ return exp_[(logSum & 0xFF) + (logSum >> 8)];
|
|
|
+}
|
|
|
+
|
|
|
+GF256 GF256::QR_CODE_FIELD(0x011D); // x^8 + x^4 + x^3 + x^2 + 1
|
|
|
+GF256 GF256::DATA_MATRIX_FIELD(0x012D); // x^8 + x^5 + x^3 + x^2 + 1
|
|
|
+
|
|
|
+ostream& operator<<(ostream& out, const GF256& field) {
|
|
|
+ out << "Field[\nexp=(";
|
|
|
+ out << field.exp_[0];
|
|
|
+ for (int i = 1; i < 256; i++) {
|
|
|
+ out << "," << field.exp_[i];
|
|
|
+ }
|
|
|
+ out << "),\nlog=(";
|
|
|
+ out << field.log_[0];
|
|
|
+ for (int i = 1; i < 256; i++) {
|
|
|
+ out << "," << field.log_[i];
|
|
|
+ }
|
|
|
+ out << ")\n]";
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/reedsolomon/GF256Poly.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * GF256Poly.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 05/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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>
|
|
|
+// #include <sstream>
|
|
|
+// #include <zxing/common/reedsolomon/GF256Poly.h>
|
|
|
+// #include <zxing/common/reedsolomon/GF256.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+void GF256Poly::fixCoefficients() {
|
|
|
+ int coefficientsLength = coefficients.size();
|
|
|
+ if (coefficientsLength > 1 && coefficients[0] == 0) {
|
|
|
+ // Leading term must be non-zero for anything except
|
|
|
+ // the constant polynomial "0"
|
|
|
+ int firstNonZero = 1;
|
|
|
+ while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
|
|
|
+ firstNonZero++;
|
|
|
+ }
|
|
|
+ if (firstNonZero == coefficientsLength) {
|
|
|
+ coefficientsLength = field.getZero()->coefficients.size();
|
|
|
+ coefficients.reset(new Array<int> (coefficientsLength));
|
|
|
+ *coefficients = *(field.getZero()->coefficients);
|
|
|
+ } else {
|
|
|
+ ArrayRef<int> c(coefficients);
|
|
|
+ coefficientsLength -= firstNonZero;
|
|
|
+ coefficients.reset(new Array<int> (coefficientsLength));
|
|
|
+ for (int i = 0; i < coefficientsLength; i++) {
|
|
|
+ coefficients[i] = c[i + firstNonZero];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+GF256Poly::GF256Poly(GF256 &f, ArrayRef<int> c) :
|
|
|
+ Counted(), field(f), coefficients(c) {
|
|
|
+ fixCoefficients();
|
|
|
+}
|
|
|
+
|
|
|
+GF256Poly::~GF256Poly() {
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+int GF256Poly::getDegree() {
|
|
|
+ return coefficients.size() - 1;
|
|
|
+}
|
|
|
+
|
|
|
+bool GF256Poly::isZero() {
|
|
|
+ return coefficients[0] == 0;
|
|
|
+}
|
|
|
+
|
|
|
+int GF256Poly::getCoefficient(int degree) {
|
|
|
+ return coefficients[coefficients.size() - 1 - degree];
|
|
|
+}
|
|
|
+
|
|
|
+int GF256Poly::evaluateAt(int a) {
|
|
|
+ if (a == 0) {
|
|
|
+ return getCoefficient(0);
|
|
|
+ }
|
|
|
+ int size = coefficients.size();
|
|
|
+ if (a == 1) {
|
|
|
+ // Just the sum of the coefficients
|
|
|
+ int result = 0;
|
|
|
+ for (int i = 0; i < size; i++) {
|
|
|
+ result = GF256::addOrSubtract(result, coefficients[i]);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ int result = coefficients[0];
|
|
|
+ for (int i = 1; i < size; i++) {
|
|
|
+ result = GF256::addOrSubtract(field.multiply(a, result), coefficients[i]);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256Poly::addOrSubtract(Ref<GF256Poly> b) {
|
|
|
+ if (&field != &b->field) {
|
|
|
+ throw IllegalArgumentException("Fields must be the same");
|
|
|
+ }
|
|
|
+ if (isZero()) {
|
|
|
+ return b;
|
|
|
+ }
|
|
|
+ if (b->isZero()) {
|
|
|
+ return Ref<GF256Poly>(this);
|
|
|
+ }
|
|
|
+
|
|
|
+ ArrayRef<int> largerCoefficients = coefficients;
|
|
|
+ ArrayRef<int> smallerCoefficients = b->coefficients;
|
|
|
+ if (smallerCoefficients.size() > largerCoefficients.size()) {
|
|
|
+ ArrayRef<int> tmp(smallerCoefficients);
|
|
|
+ smallerCoefficients = largerCoefficients;
|
|
|
+ largerCoefficients = tmp;
|
|
|
+ }
|
|
|
+
|
|
|
+ ArrayRef<int> sumDiff(new Array<int> (largerCoefficients.size()));
|
|
|
+
|
|
|
+ unsigned lengthDiff = largerCoefficients.size() - smallerCoefficients.size();
|
|
|
+ for (unsigned i = 0; i < lengthDiff; i++) {
|
|
|
+ sumDiff[i] = largerCoefficients[i];
|
|
|
+ }
|
|
|
+ for (unsigned i = lengthDiff; i < largerCoefficients.size(); i++) {
|
|
|
+ sumDiff[i] = GF256::addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
|
|
|
+ }
|
|
|
+ return Ref<GF256Poly>(new GF256Poly(field, sumDiff));
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256Poly::multiply(Ref<GF256Poly> b) {
|
|
|
+ if (&field != &b->field) {
|
|
|
+ throw IllegalArgumentException("Fields must be the same");
|
|
|
+ }
|
|
|
+ if (isZero() || b->isZero()) {
|
|
|
+ return field.getZero();
|
|
|
+ }
|
|
|
+ ArrayRef<int> aCoefficients = coefficients;
|
|
|
+ int aLength = aCoefficients.size();
|
|
|
+ ArrayRef<int> bCoefficients = b->coefficients;
|
|
|
+ int bLength = bCoefficients.size();
|
|
|
+ int productLength = aLength + bLength - 1;
|
|
|
+ ArrayRef<int> product(new Array<int> (productLength));
|
|
|
+ for (int i = 0; i < aLength; i++) {
|
|
|
+ int aCoeff = aCoefficients[i];
|
|
|
+ for (int j = 0; j < bLength; j++) {
|
|
|
+ product[i + j] = GF256::addOrSubtract(product[i + j], field.multiply(aCoeff, bCoefficients[j]));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return Ref<GF256Poly>(new GF256Poly(field, product));
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256Poly::multiply(int scalar) {
|
|
|
+ if (scalar == 0) {
|
|
|
+ return field.getZero();
|
|
|
+ }
|
|
|
+ if (scalar == 1) {
|
|
|
+ return Ref<GF256Poly>(this);
|
|
|
+ }
|
|
|
+ int size = coefficients.size();
|
|
|
+ ArrayRef<int> product(new Array<int> (size));
|
|
|
+ for (int i = 0; i < size; i++) {
|
|
|
+ product[i] = field.multiply(coefficients[i], scalar);
|
|
|
+ }
|
|
|
+ return Ref<GF256Poly>(new GF256Poly(field, product));
|
|
|
+}
|
|
|
+
|
|
|
+Ref<GF256Poly> GF256Poly::multiplyByMonomial(int degree, int coefficient) {
|
|
|
+ if (degree < 0) {
|
|
|
+ throw IllegalArgumentException("Degree must be non-negative");
|
|
|
+ }
|
|
|
+ if (coefficient == 0) {
|
|
|
+ return field.getZero();
|
|
|
+ }
|
|
|
+ int size = coefficients.size();
|
|
|
+ ArrayRef<int> product(new Array<int> (size + degree));
|
|
|
+ for (int i = 0; i < size; i++) {
|
|
|
+ product[i] = field.multiply(coefficients[i], coefficient);
|
|
|
+ }
|
|
|
+ return Ref<GF256Poly>(new GF256Poly(field, product));
|
|
|
+}
|
|
|
+
|
|
|
+const char *GF256Poly::description() const {
|
|
|
+ ostringstream result;
|
|
|
+ result << *this;
|
|
|
+ return result.str().c_str();
|
|
|
+}
|
|
|
+
|
|
|
+ostream& operator<<(ostream& out, const GF256Poly& p) {
|
|
|
+ GF256Poly &poly = const_cast<GF256Poly&>(p);
|
|
|
+ out << "Poly[" << poly.coefficients.size() << "]";
|
|
|
+ if (poly.coefficients.size() > 0) {
|
|
|
+ out << "(" << poly.coefficients[0];
|
|
|
+ for (unsigned i = 1; i < poly.coefficients.size(); i++) {
|
|
|
+ out << "," << poly.coefficients[i];
|
|
|
+ }
|
|
|
+ out << ")";
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/reedsolomon/ReedSolomonDecoder.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * ReedSolomonDecoder.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 05/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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>
|
|
|
+
|
|
|
+// #include <memory>
|
|
|
+// #include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
|
|
|
+// #include <zxing/common/reedsolomon/GF256.h>
|
|
|
+// #include <zxing/common/reedsolomon/GF256Poly.h>
|
|
|
+// #include <zxing/common/reedsolomon/ReedSolomonException.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+
|
|
|
+ReedSolomonDecoder::ReedSolomonDecoder(GF256 &fld) :
|
|
|
+ field(fld) {
|
|
|
+}
|
|
|
+
|
|
|
+ReedSolomonDecoder::~ReedSolomonDecoder() {
|
|
|
+}
|
|
|
+
|
|
|
+void ReedSolomonDecoder::decode(ArrayRef<int> received, int twoS) {
|
|
|
+
|
|
|
+ Ref<GF256Poly> poly(new GF256Poly(field, received));
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "decoding with poly " << *poly << "\n";
|
|
|
+#endif
|
|
|
+
|
|
|
+ ArrayRef<int> syndromeCoefficients(new Array<int> (twoS));
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "syndromeCoefficients array = " <<
|
|
|
+ syndromeCoefficients.array_ << "\n";
|
|
|
+#endif
|
|
|
+
|
|
|
+ bool dataMatrix = (&field == &GF256::DATA_MATRIX_FIELD);
|
|
|
+ bool noError = true;
|
|
|
+ for (int i = 0; i < twoS; i++) {
|
|
|
+ int eval = poly->evaluateAt(field.exp(dataMatrix ? i + 1 : i));
|
|
|
+ syndromeCoefficients[syndromeCoefficients->size() - 1 - i] = eval;
|
|
|
+ if (eval != 0) {
|
|
|
+ noError = false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (noError) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<GF256Poly> syndrome(new GF256Poly(field, syndromeCoefficients));
|
|
|
+ Ref<GF256Poly> monomial(field.buildMonomial(twoS, 1));
|
|
|
+ vector<Ref<GF256Poly> > sigmaOmega(runEuclideanAlgorithm(monomial, syndrome, twoS));
|
|
|
+ ArrayRef<int> errorLocations = findErrorLocations(sigmaOmega[0]);
|
|
|
+ ArrayRef<int> errorMagitudes = findErrorMagnitudes(sigmaOmega[1], errorLocations, dataMatrix);
|
|
|
+ for (unsigned i = 0; i < errorLocations->size(); i++) {
|
|
|
+ int position = received->size() - 1 - field.log(errorLocations[i]);
|
|
|
+ //TODO: check why the position would be invalid
|
|
|
+ if (position < 0 || (size_t)position >= received.size())
|
|
|
+ throw IllegalArgumentException("Invalid position (ReedSolomonDecoder)");
|
|
|
+ received[position] = GF256::addOrSubtract(received[position], errorMagitudes[i]);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+vector<Ref<GF256Poly> > ReedSolomonDecoder::runEuclideanAlgorithm(Ref<GF256Poly> a, Ref<GF256Poly> b, int R) {
|
|
|
+ // Assume a's degree is >= b's
|
|
|
+ if (a->getDegree() < b->getDegree()) {
|
|
|
+ Ref<GF256Poly> tmp = a;
|
|
|
+ a = b;
|
|
|
+ b = tmp;
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<GF256Poly> rLast(a);
|
|
|
+ Ref<GF256Poly> r(b);
|
|
|
+ Ref<GF256Poly> sLast(field.getOne());
|
|
|
+ Ref<GF256Poly> s(field.getZero());
|
|
|
+ Ref<GF256Poly> tLast(field.getZero());
|
|
|
+ Ref<GF256Poly> t(field.getOne());
|
|
|
+
|
|
|
+
|
|
|
+ // Run Euclidean algorithm until r's degree is less than R/2
|
|
|
+ while (r->getDegree() >= R / 2) {
|
|
|
+ Ref<GF256Poly> rLastLast(rLast);
|
|
|
+ Ref<GF256Poly> sLastLast(sLast);
|
|
|
+ Ref<GF256Poly> tLastLast(tLast);
|
|
|
+ rLast = r;
|
|
|
+ sLast = s;
|
|
|
+ tLast = t;
|
|
|
+
|
|
|
+
|
|
|
+ // Divide rLastLast by rLast, with quotient q and remainder r
|
|
|
+ if (rLast->isZero()) {
|
|
|
+ // Oops, Euclidean algorithm already terminated?
|
|
|
+ throw ReedSolomonException("r_{i-1} was zero");
|
|
|
+ }
|
|
|
+ r = rLastLast;
|
|
|
+ Ref<GF256Poly> q(field.getZero());
|
|
|
+ int denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree());
|
|
|
+ int dltInverse = field.inverse(denominatorLeadingTerm);
|
|
|
+ while (r->getDegree() >= rLast->getDegree() && !r->isZero()) {
|
|
|
+ int degreeDiff = r->getDegree() - rLast->getDegree();
|
|
|
+ int scale = field.multiply(r->getCoefficient(r->getDegree()), dltInverse);
|
|
|
+ q = q->addOrSubtract(field.buildMonomial(degreeDiff, scale));
|
|
|
+ r = r->addOrSubtract(rLast->multiplyByMonomial(degreeDiff, scale));
|
|
|
+ }
|
|
|
+
|
|
|
+ s = q->multiply(sLast)->addOrSubtract(sLastLast);
|
|
|
+ t = q->multiply(tLast)->addOrSubtract(tLastLast);
|
|
|
+ }
|
|
|
+
|
|
|
+ int sigmaTildeAtZero = t->getCoefficient(0);
|
|
|
+ if (sigmaTildeAtZero == 0) {
|
|
|
+ throw ReedSolomonException("sigmaTilde(0) was zero");
|
|
|
+ }
|
|
|
+
|
|
|
+ int inverse = field.inverse(sigmaTildeAtZero);
|
|
|
+ Ref<GF256Poly> sigma(t->multiply(inverse));
|
|
|
+ Ref<GF256Poly> omega(r->multiply(inverse));
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "t = " << *t << "\n";
|
|
|
+ cout << "r = " << *r << "\n";
|
|
|
+ cout << "sigma = " << *sigma << "\n";
|
|
|
+ cout << "omega = " << *omega << "\n";
|
|
|
+#endif
|
|
|
+
|
|
|
+ vector<Ref<GF256Poly> > result(2);
|
|
|
+ result[0] = sigma;
|
|
|
+ result[1] = omega;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<int> ReedSolomonDecoder::findErrorLocations(Ref<GF256Poly> errorLocator) {
|
|
|
+ // This is a direct application of Chien's search
|
|
|
+ int numErrors = errorLocator->getDegree();
|
|
|
+ if (numErrors == 1) { // shortcut
|
|
|
+ ArrayRef<int> result(1);
|
|
|
+ result[0] = errorLocator->getCoefficient(1);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ ArrayRef<int> result(numErrors);
|
|
|
+ int e = 0;
|
|
|
+ for (int i = 1; i < 256 && e < numErrors; i++) {
|
|
|
+ // cout << "errorLocator(" << i << ") == " << errorLocator->evaluateAt(i) << "\n";
|
|
|
+ if (errorLocator->evaluateAt(i) == 0) {
|
|
|
+ result[e] = field.inverse(i);
|
|
|
+ e++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (e != numErrors) {
|
|
|
+ throw ReedSolomonException("Error locator degree does not match number of roots");
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<int> ReedSolomonDecoder::findErrorMagnitudes(Ref<GF256Poly> errorEvaluator, ArrayRef<int> errorLocations, bool dataMatrix) {
|
|
|
+ // This is directly applying Forney's Formula
|
|
|
+ int s = errorLocations.size();
|
|
|
+ ArrayRef<int> result(s);
|
|
|
+ for (int i = 0; i < s; i++) {
|
|
|
+ int xiInverse = field.inverse(errorLocations[i]);
|
|
|
+ int denominator = 1;
|
|
|
+ for (int j = 0; j < s; j++) {
|
|
|
+ if (i != j) {
|
|
|
+ denominator = field.multiply(denominator, GF256::addOrSubtract(1, field.multiply(errorLocations[j],
|
|
|
+ xiInverse)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ result[i] = field.multiply(errorEvaluator->evaluateAt(xiInverse), field.inverse(denominator));
|
|
|
+
|
|
|
+ if (dataMatrix) {
|
|
|
+ result[i] = field.multiply(result[i], xiInverse);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/common/reedsolomon/ReedSolomonException.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * ReedSolomonException.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 06/05/2008.
|
|
|
+ * Copyright 2008 Google UK. 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/reedsolomon/ReedSolomonException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ReedSolomonException::ReedSolomonException(const char *msg) throw() :
|
|
|
+ Exception(msg) {
|
|
|
+}
|
|
|
+ReedSolomonException::~ReedSolomonException() throw() {
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/DataMatrixReader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * DataMatrixReader.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/datamatrix/DataMatrixReader.h>
|
|
|
+// #include <zxing/datamatrix/detector/Detector.h>
|
|
|
+// #include <iostream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+DataMatrixReader::DataMatrixReader() :
|
|
|
+ decoder_() {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<Result> DataMatrixReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
|
|
|
+ (void)hints;
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "decoding image " << image.object_ << ":\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ Detector detector(image->getBlackMatrix());
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(1) created detector " << &detector << "\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ Ref<DetectorResult> detectorResult(detector.detect());
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(2) detected, have detectorResult " << detectorResult.object_ << "\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ std::vector<Ref<ResultPoint> > points(detectorResult->getPoints());
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(3) extracted points " << &points << "\n" << flush;
|
|
|
+ cout << "found " << points.size() << " points:\n";
|
|
|
+ for (size_t i = 0; i < points.size(); i++) {
|
|
|
+ cout << " " << points[i]->getX() << "," << points[i]->getY() << "\n";
|
|
|
+ }
|
|
|
+ cout << "bits:\n";
|
|
|
+ cout << *(detectorResult->getBits()) << "\n";
|
|
|
+#endif
|
|
|
+
|
|
|
+ Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult->getBits()));
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(4) decoded, have decoderResult " << decoderResult.object_ << "\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ Ref<Result> result(
|
|
|
+ new Result(decoderResult->getText(), decoderResult->getRawBytes(), points, BarcodeFormat_DATA_MATRIX));
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(5) created result " << result.object_ << ", returning\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+DataMatrixReader::~DataMatrixReader() {
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/Version.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Version.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/datamatrix/Version.h>
|
|
|
+// #include <limits>
|
|
|
+// #include <iostream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+ECB::ECB(int count, int dataCodewords) :
|
|
|
+ count_(count), dataCodewords_(dataCodewords) {
|
|
|
+}
|
|
|
+
|
|
|
+int ECB::getCount() {
|
|
|
+ return count_;
|
|
|
+}
|
|
|
+
|
|
|
+int ECB::getDataCodewords() {
|
|
|
+ return dataCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks) :
|
|
|
+ ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks) {
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2) :
|
|
|
+ ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks1) {
|
|
|
+ ecBlocks_.push_back(ecBlocks2);
|
|
|
+}
|
|
|
+
|
|
|
+int ECBlocks::getECCodewords() {
|
|
|
+ return ecCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<ECB*>& ECBlocks::getECBlocks() {
|
|
|
+ return ecBlocks_;
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks::~ECBlocks() {
|
|
|
+ for (size_t i = 0; i < ecBlocks_.size(); i++) {
|
|
|
+ delete ecBlocks_[i];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+vector<Ref<Version> > Version::VERSIONS;
|
|
|
+static int N_VERSIONS = Version::buildVersions();
|
|
|
+
|
|
|
+Version::Version(int versionNumber, int symbolSizeRows, int symbolSizeColumns, int dataRegionSizeRows,
|
|
|
+ int dataRegionSizeColumns, ECBlocks* ecBlocks) : versionNumber_(versionNumber),
|
|
|
+ symbolSizeRows_(symbolSizeRows), symbolSizeColumns_(symbolSizeColumns),
|
|
|
+ dataRegionSizeRows_(dataRegionSizeRows), dataRegionSizeColumns_(dataRegionSizeColumns),
|
|
|
+ ecBlocks_(ecBlocks), totalCodewords_(0) {
|
|
|
+ // Calculate the total number of codewords
|
|
|
+ int total = 0;
|
|
|
+ int ecCodewords = ecBlocks_->getECCodewords();
|
|
|
+ vector<ECB*> &ecbArray = ecBlocks_->getECBlocks();
|
|
|
+ for (unsigned int i = 0; i < ecbArray.size(); i++) {
|
|
|
+ ECB *ecBlock = ecbArray[i];
|
|
|
+ total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
|
|
|
+ }
|
|
|
+ totalCodewords_ = total;
|
|
|
+}
|
|
|
+
|
|
|
+Version::~Version() {
|
|
|
+ delete ecBlocks_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getVersionNumber() {
|
|
|
+ return versionNumber_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getSymbolSizeRows() {
|
|
|
+ return symbolSizeRows_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getSymbolSizeColumns() {
|
|
|
+ return symbolSizeColumns_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getDataRegionSizeRows() {
|
|
|
+ return dataRegionSizeRows_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getDataRegionSizeColumns() {
|
|
|
+ return dataRegionSizeColumns_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getTotalCodewords() {
|
|
|
+ return totalCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks* Version::getECBlocks() {
|
|
|
+ return ecBlocks_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<Version> Version::getVersionForDimensions(int numRows, int numColumns) {
|
|
|
+ if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {
|
|
|
+ throw ReaderException("Number of rows and columns must be even");
|
|
|
+ }
|
|
|
+
|
|
|
+ // TODO(bbrown): This is doing a linear search through the array of versions.
|
|
|
+ // If we interleave the rectangular versions with the square versions we could
|
|
|
+ // do a binary search.
|
|
|
+ for (int i = 0; i < N_VERSIONS; ++i){
|
|
|
+ Ref<Version> version(VERSIONS[i]);
|
|
|
+ if (version->getSymbolSizeRows() == numRows && version->getSymbolSizeColumns() == numColumns) {
|
|
|
+ return version;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw ReaderException("Error version not found");
|
|
|
+ }
|
|
|
+
|
|
|
+/**
|
|
|
+ * See ISO 16022:2006 5.5.1 Table 7
|
|
|
+ */
|
|
|
+int Version::buildVersions() {
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(1, 10, 10, 8, 8,
|
|
|
+ new ECBlocks(5, new ECB(1, 3)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(2, 12, 12, 10, 10,
|
|
|
+ new ECBlocks(7, new ECB(1, 5)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(3, 14, 14, 12, 12,
|
|
|
+ new ECBlocks(10, new ECB(1, 8)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(4, 16, 16, 14, 14,
|
|
|
+ new ECBlocks(12, new ECB(1, 12)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(5, 18, 18, 16, 16,
|
|
|
+ new ECBlocks(14, new ECB(1, 18)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(6, 20, 20, 18, 18,
|
|
|
+ new ECBlocks(18, new ECB(1, 22)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(7, 22, 22, 20, 20,
|
|
|
+ new ECBlocks(20, new ECB(1, 30)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(8, 24, 24, 22, 22,
|
|
|
+ new ECBlocks(24, new ECB(1, 36)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(9, 26, 26, 24, 24,
|
|
|
+ new ECBlocks(28, new ECB(1, 44)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(10, 32, 32, 14, 14,
|
|
|
+ new ECBlocks(36, new ECB(1, 62)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(11, 36, 36, 16, 16,
|
|
|
+ new ECBlocks(42, new ECB(1, 86)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(12, 40, 40, 18, 18,
|
|
|
+ new ECBlocks(48, new ECB(1, 114)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(13, 44, 44, 20, 20,
|
|
|
+ new ECBlocks(56, new ECB(1, 144)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(14, 48, 48, 22, 22,
|
|
|
+ new ECBlocks(68, new ECB(1, 174)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(15, 52, 52, 24, 24,
|
|
|
+ new ECBlocks(42, new ECB(2, 102)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(16, 64, 64, 14, 14,
|
|
|
+ new ECBlocks(56, new ECB(2, 140)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(17, 72, 72, 16, 16,
|
|
|
+ new ECBlocks(36, new ECB(4, 92)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(18, 80, 80, 18, 18,
|
|
|
+ new ECBlocks(48, new ECB(4, 114)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(19, 88, 88, 20, 20,
|
|
|
+ new ECBlocks(56, new ECB(4, 144)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(20, 96, 96, 22, 22,
|
|
|
+ new ECBlocks(68, new ECB(4, 174)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(21, 104, 104, 24, 24,
|
|
|
+ new ECBlocks(56, new ECB(6, 136)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(22, 120, 120, 18, 18,
|
|
|
+ new ECBlocks(68, new ECB(6, 175)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(23, 132, 132, 20, 20,
|
|
|
+ new ECBlocks(62, new ECB(8, 163)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(24, 144, 144, 22, 22,
|
|
|
+ new ECBlocks(62, new ECB(8, 156), new ECB(2, 155)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(25, 8, 18, 6, 16,
|
|
|
+ new ECBlocks(7, new ECB(1, 5)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(26, 8, 32, 6, 14,
|
|
|
+ new ECBlocks(11, new ECB(1, 10)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(27, 12, 26, 10, 24,
|
|
|
+ new ECBlocks(14, new ECB(1, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(28, 12, 36, 10, 16,
|
|
|
+ new ECBlocks(18, new ECB(1, 22)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(29, 16, 36, 14, 16,
|
|
|
+ new ECBlocks(24, new ECB(1, 32)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(30, 16, 48, 14, 22,
|
|
|
+ new ECBlocks(28, new ECB(1, 49)))));
|
|
|
+ return VERSIONS.size();
|
|
|
+}
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/decoder/BitMatrixParser.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * BitMatrixParser.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/datamatrix/decoder/BitMatrixParser.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+// #include <iostream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+int BitMatrixParser::copyBit(size_t x, size_t y, int versionBits) {
|
|
|
+ return bitMatrix_->get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1;
|
|
|
+}
|
|
|
+
|
|
|
+BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix) : bitMatrix_(NULL),
|
|
|
+ parsedVersion_(NULL),
|
|
|
+ readBitMatrix_(NULL) {
|
|
|
+ size_t dimension = bitMatrix->getDimension();
|
|
|
+ if (dimension < 8 || dimension > 144 || (dimension & 0x01) != 0)
|
|
|
+ throw ReaderException("Dimension must be even, > 8 < 144");
|
|
|
+
|
|
|
+ parsedVersion_ = readVersion(bitMatrix);
|
|
|
+ bitMatrix_ = extractDataRegion(bitMatrix);
|
|
|
+ readBitMatrix_ = new BitMatrix(bitMatrix_->getWidth(), bitMatrix_->getHeight());
|
|
|
+}
|
|
|
+
|
|
|
+Ref<Version> BitMatrixParser::readVersion(Ref<BitMatrix> bitMatrix) {
|
|
|
+ if (parsedVersion_ != 0) {
|
|
|
+ return parsedVersion_;
|
|
|
+ }
|
|
|
+
|
|
|
+ int numRows = bitMatrix->getHeight();//getDimension();
|
|
|
+ int numColumns = bitMatrix->getWidth();//numRows;
|
|
|
+
|
|
|
+ Ref<Version> version = parsedVersion_->getVersionForDimensions(numRows, numColumns);
|
|
|
+ if (version != 0) {
|
|
|
+ return version;
|
|
|
+ }
|
|
|
+ throw ReaderException("Couldn't decode version");
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<unsigned char> BitMatrixParser::readCodewords() {
|
|
|
+ ArrayRef<unsigned char> result(parsedVersion_->getTotalCodewords());
|
|
|
+ int resultOffset = 0;
|
|
|
+ int row = 4;
|
|
|
+ int column = 0;
|
|
|
+
|
|
|
+ int numRows = bitMatrix_->getHeight();
|
|
|
+ int numColumns = bitMatrix_->getWidth();
|
|
|
+
|
|
|
+ bool corner1Read = false;
|
|
|
+ bool corner2Read = false;
|
|
|
+ bool corner3Read = false;
|
|
|
+ bool corner4Read = false;
|
|
|
+
|
|
|
+ // Read all of the codewords
|
|
|
+ do {
|
|
|
+ // Check the four corner cases
|
|
|
+ if ((row == numRows) && (column == 0) && !corner1Read) {
|
|
|
+ result[resultOffset++] = (unsigned char) readCorner1(numRows, numColumns);
|
|
|
+ row -= 2;
|
|
|
+ column +=2;
|
|
|
+ corner1Read = true;
|
|
|
+ } else if ((row == numRows-2) && (column == 0) && ((numColumns & 0x03) != 0) && !corner2Read) {
|
|
|
+ result[resultOffset++] = (unsigned char) readCorner2(numRows, numColumns);
|
|
|
+ row -= 2;
|
|
|
+ column +=2;
|
|
|
+ corner2Read = true;
|
|
|
+ } else if ((row == numRows+4) && (column == 2) && ((numColumns & 0x07) == 0) && !corner3Read) {
|
|
|
+ result[resultOffset++] = (unsigned char) readCorner3(numRows, numColumns);
|
|
|
+ row -= 2;
|
|
|
+ column +=2;
|
|
|
+ corner3Read = true;
|
|
|
+ } else if ((row == numRows-2) && (column == 0) && ((numColumns & 0x07) == 4) && !corner4Read) {
|
|
|
+ result[resultOffset++] = (unsigned char) readCorner4(numRows, numColumns);
|
|
|
+ row -= 2;
|
|
|
+ column +=2;
|
|
|
+ corner4Read = true;
|
|
|
+ } else {
|
|
|
+ // Sweep upward diagonally to the right
|
|
|
+ do {
|
|
|
+ if ((row < numRows) && (column >= 0) && !readBitMatrix_->get(column, row)) {
|
|
|
+ result[resultOffset++] = (unsigned char) readUtah(row, column, numRows, numColumns);
|
|
|
+ }
|
|
|
+ row -= 2;
|
|
|
+ column +=2;
|
|
|
+ } while ((row >= 0) && (column < numColumns));
|
|
|
+ row += 1;
|
|
|
+ column +=3;
|
|
|
+
|
|
|
+ // Sweep downward diagonally to the left
|
|
|
+ do {
|
|
|
+ if ((row >= 0) && (column < numColumns) && !readBitMatrix_->get(column, row)) {
|
|
|
+ result[resultOffset++] = (unsigned char) readUtah(row, column, numRows, numColumns);
|
|
|
+ }
|
|
|
+ row += 2;
|
|
|
+ column -=2;
|
|
|
+ } while ((row < numRows) && (column >= 0));
|
|
|
+ row += 3;
|
|
|
+ column +=1;
|
|
|
+ }
|
|
|
+ } while ((row < numRows) || (column < numColumns));
|
|
|
+
|
|
|
+ if (resultOffset != parsedVersion_->getTotalCodewords()) {
|
|
|
+ throw ReaderException("Did not read all codewords");
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+bool BitMatrixParser::readModule(int row, int column, int numRows, int numColumns) {
|
|
|
+ // Adjust the row and column indices based on boundary wrapping
|
|
|
+ if (row < 0) {
|
|
|
+ row += numRows;
|
|
|
+ column += 4 - ((numRows + 4) & 0x07);
|
|
|
+ }
|
|
|
+ if (column < 0) {
|
|
|
+ column += numColumns;
|
|
|
+ row += 4 - ((numColumns + 4) & 0x07);
|
|
|
+ }
|
|
|
+ readBitMatrix_->set(column, row);
|
|
|
+ return bitMatrix_->get(column, row);
|
|
|
+ }
|
|
|
+
|
|
|
+int BitMatrixParser::readUtah(int row, int column, int numRows, int numColumns) {
|
|
|
+ int currentByte = 0;
|
|
|
+ if (readModule(row - 2, column - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row - 2, column - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row - 1, column - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row - 1, column - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row - 1, column, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row, column - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row, column - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(row, column, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ return currentByte;
|
|
|
+ }
|
|
|
+
|
|
|
+int BitMatrixParser::readCorner1(int numRows, int numColumns) {
|
|
|
+ int currentByte = 0;
|
|
|
+ if (readModule(numRows - 1, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 1, 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 1, 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(1, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(2, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(3, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ return currentByte;
|
|
|
+ }
|
|
|
+
|
|
|
+int BitMatrixParser::readCorner2(int numRows, int numColumns) {
|
|
|
+ int currentByte = 0;
|
|
|
+ if (readModule(numRows - 3, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 2, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 1, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 4, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 3, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(1, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ return currentByte;
|
|
|
+ }
|
|
|
+
|
|
|
+int BitMatrixParser::readCorner3(int numRows, int numColumns) {
|
|
|
+ int currentByte = 0;
|
|
|
+ if (readModule(numRows - 1, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 1, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 3, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(1, numColumns - 3, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(1, numColumns - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(1, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ return currentByte;
|
|
|
+ }
|
|
|
+
|
|
|
+int BitMatrixParser::readCorner4(int numRows, int numColumns) {
|
|
|
+ int currentByte = 0;
|
|
|
+ if (readModule(numRows - 3, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 2, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(numRows - 1, 0, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 2, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(0, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(1, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(2, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (readModule(3, numColumns - 1, numRows, numColumns)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ return currentByte;
|
|
|
+ }
|
|
|
+
|
|
|
+Ref<BitMatrix> BitMatrixParser::extractDataRegion(Ref<BitMatrix> bitMatrix) {
|
|
|
+ int symbolSizeRows = parsedVersion_->getSymbolSizeRows();
|
|
|
+ int symbolSizeColumns = parsedVersion_->getSymbolSizeColumns();
|
|
|
+
|
|
|
+ if ((int)bitMatrix->getHeight() != symbolSizeRows) {
|
|
|
+ throw IllegalArgumentException("Dimension of bitMatrix must match the version size");
|
|
|
+ }
|
|
|
+
|
|
|
+ int dataRegionSizeRows = parsedVersion_->getDataRegionSizeRows();
|
|
|
+ int dataRegionSizeColumns = parsedVersion_->getDataRegionSizeColumns();
|
|
|
+
|
|
|
+ int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;
|
|
|
+ int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;
|
|
|
+
|
|
|
+ int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;
|
|
|
+ int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;
|
|
|
+
|
|
|
+ Ref<BitMatrix> bitMatrixWithoutAlignment(new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow));
|
|
|
+ for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {
|
|
|
+ int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;
|
|
|
+ for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {
|
|
|
+ int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;
|
|
|
+ for (int i = 0; i < dataRegionSizeRows; ++i) {
|
|
|
+ int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;
|
|
|
+ int writeRowOffset = dataRegionRowOffset + i;
|
|
|
+ for (int j = 0; j < dataRegionSizeColumns; ++j) {
|
|
|
+ int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;
|
|
|
+ if (bitMatrix->get(readColumnOffset, readRowOffset)) {
|
|
|
+ int writeColumnOffset = dataRegionColumnOffset + j;
|
|
|
+ bitMatrixWithoutAlignment->set(writeColumnOffset, writeRowOffset);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return bitMatrixWithoutAlignment;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/decoder/DataBlock.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * DataBlock.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/datamatrix/decoder/DataBlock.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+DataBlock::DataBlock(int numDataCodewords, ArrayRef<unsigned char> codewords) :
|
|
|
+ numDataCodewords_(numDataCodewords), codewords_(codewords) {
|
|
|
+}
|
|
|
+
|
|
|
+int DataBlock::getNumDataCodewords() {
|
|
|
+ return numDataCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<unsigned char> DataBlock::getCodewords() {
|
|
|
+ return codewords_;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<unsigned char> rawCodewords, Version *version) {
|
|
|
+ // Figure out the number and size of data blocks used by this version and
|
|
|
+ // error correction level
|
|
|
+ ECBlocks* ecBlocks = version->getECBlocks();
|
|
|
+
|
|
|
+ // First count the total number of data blocks
|
|
|
+ int totalBlocks = 0;
|
|
|
+ vector<ECB*> ecBlockArray = ecBlocks->getECBlocks();
|
|
|
+ for (size_t i = 0; i < ecBlockArray.size(); i++) {
|
|
|
+ totalBlocks += ecBlockArray[i]->getCount();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Now establish DataBlocks of the appropriate size and number of data codewords
|
|
|
+ std::vector<Ref<DataBlock> > result(totalBlocks);
|
|
|
+ int numResultBlocks = 0;
|
|
|
+ for (size_t j = 0; j < ecBlockArray.size(); j++) {
|
|
|
+ ECB *ecBlock = ecBlockArray[j];
|
|
|
+ for (int i = 0; i < ecBlock->getCount(); i++) {
|
|
|
+ int numDataCodewords = ecBlock->getDataCodewords();
|
|
|
+ int numBlockCodewords = ecBlocks->getECCodewords() + numDataCodewords;
|
|
|
+ ArrayRef<unsigned char> buffer(numBlockCodewords);
|
|
|
+ Ref<DataBlock> blockRef(new DataBlock(numDataCodewords, buffer));
|
|
|
+ result[numResultBlocks++] = blockRef;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // All blocks have the same amount of data, except that the last n
|
|
|
+ // (where n may be 0) have 1 more byte. Figure out where these start.
|
|
|
+ int shorterBlocksTotalCodewords = result[0]->codewords_.size();
|
|
|
+ int longerBlocksStartAt = result.size() - 1;
|
|
|
+ while (longerBlocksStartAt >= 0) {
|
|
|
+ int numCodewords = result[longerBlocksStartAt]->codewords_.size();
|
|
|
+ if (numCodewords == shorterBlocksTotalCodewords) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (numCodewords != shorterBlocksTotalCodewords + 1) {
|
|
|
+ throw IllegalArgumentException("Data block sizes differ by more than 1");
|
|
|
+ }
|
|
|
+ longerBlocksStartAt--;
|
|
|
+ }
|
|
|
+ longerBlocksStartAt++;
|
|
|
+
|
|
|
+ int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks->getECCodewords();
|
|
|
+ // The last elements of result may be 1 element longer;
|
|
|
+ // first fill out as many elements as all of them have
|
|
|
+ int rawCodewordsOffset = 0;
|
|
|
+ for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
|
|
|
+ for (int j = 0; j < numResultBlocks; j++) {
|
|
|
+ result[j]->codewords_[i] = rawCodewords[rawCodewordsOffset++];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Fill out the last data block in the longer ones
|
|
|
+ for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
|
|
|
+ result[j]->codewords_[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
|
|
|
+ }
|
|
|
+ // Now add in error correction blocks
|
|
|
+ int max = result[0]->codewords_.size();
|
|
|
+ for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
|
|
|
+ for (int j = 0; j < numResultBlocks; j++) {
|
|
|
+ int iOffset = j < longerBlocksStartAt ? i : i + 1;
|
|
|
+ result[j]->codewords_[iOffset] = rawCodewords[rawCodewordsOffset++];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((size_t)rawCodewordsOffset != rawCodewords.size()) {
|
|
|
+ throw IllegalArgumentException("rawCodewordsOffset != rawCodewords.length");
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/decoder/DecodedBitStreamParser.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * DecodedBitStreamParser.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/FormatException.h>
|
|
|
+// #include <zxing/datamatrix/decoder/DecodedBitStreamParser.h>
|
|
|
+// #include <iostream>
|
|
|
+// #include <zxing/common/DecoderResult.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+const char DecodedBitStreamParser::C40_BASIC_SET_CHARS[] = {
|
|
|
+ '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
|
|
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
|
|
+ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
|
|
|
+};
|
|
|
+
|
|
|
+const char DecodedBitStreamParser::C40_SHIFT2_SET_CHARS[] = {
|
|
|
+ '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.',
|
|
|
+ '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_'
|
|
|
+};
|
|
|
+
|
|
|
+const char DecodedBitStreamParser::TEXT_BASIC_SET_CHARS[] = {
|
|
|
+ '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
|
|
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
|
|
|
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
|
|
|
+};
|
|
|
+
|
|
|
+const char DecodedBitStreamParser::TEXT_SHIFT3_SET_CHARS[] = {
|
|
|
+ '\'', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
|
|
+ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', (char) 127
|
|
|
+};
|
|
|
+
|
|
|
+Ref<DecoderResult> DecodedBitStreamParser::decode(ArrayRef<unsigned char> bytes) {
|
|
|
+ Ref<BitSource> bits(new BitSource(bytes));
|
|
|
+ ostringstream result;
|
|
|
+ ostringstream resultTrailer;
|
|
|
+ vector<unsigned char> byteSegments;
|
|
|
+ int mode = ASCII_ENCODE;
|
|
|
+ do {
|
|
|
+ if (mode == ASCII_ENCODE) {
|
|
|
+ mode = decodeAsciiSegment(bits, result, resultTrailer);
|
|
|
+ } else {
|
|
|
+ switch (mode) {
|
|
|
+ case C40_ENCODE:
|
|
|
+ decodeC40Segment(bits, result);
|
|
|
+ break;
|
|
|
+ case TEXT_ENCODE:
|
|
|
+ decodeTextSegment(bits, result);
|
|
|
+ break;
|
|
|
+ case ANSIX12_ENCODE:
|
|
|
+ decodeAnsiX12Segment(bits, result);
|
|
|
+ break;
|
|
|
+ case EDIFACT_ENCODE:
|
|
|
+ decodeEdifactSegment(bits, result);
|
|
|
+ break;
|
|
|
+ case BASE256_ENCODE:
|
|
|
+ decodeBase256Segment(bits, result, byteSegments);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw FormatException("Unsupported mode indicator");
|
|
|
+ }
|
|
|
+ mode = ASCII_ENCODE;
|
|
|
+ }
|
|
|
+ } while (mode != PAD_ENCODE && bits->available() > 0);
|
|
|
+
|
|
|
+ if (resultTrailer.str().size() > 0) {
|
|
|
+ result << resultTrailer.str();
|
|
|
+ }
|
|
|
+ ArrayRef<unsigned char> rawBytes(bytes);
|
|
|
+ Ref<String> text(new String(result.str()));
|
|
|
+ return Ref<DecoderResult>(new DecoderResult(rawBytes, text));
|
|
|
+}
|
|
|
+
|
|
|
+int DecodedBitStreamParser::decodeAsciiSegment(Ref<BitSource> bits, ostringstream & result,
|
|
|
+ ostringstream & resultTrailer) {
|
|
|
+ bool upperShift = false;
|
|
|
+ do {
|
|
|
+ int oneByte = bits->readBits(8);
|
|
|
+ if (oneByte == 0) {
|
|
|
+ throw FormatException("Not enough bits to decode");
|
|
|
+ } else if (oneByte <= 128) { // ASCII data (ASCII value + 1)
|
|
|
+ oneByte = upperShift ? (oneByte + 128) : oneByte;
|
|
|
+ // upperShift = false;
|
|
|
+ result << (char) (oneByte - 1);
|
|
|
+ return ASCII_ENCODE;
|
|
|
+ } else if (oneByte == 129) { // Pad
|
|
|
+ return PAD_ENCODE;
|
|
|
+ } else if (oneByte <= 229) { // 2-digit data 00-99 (Numeric Value + 130)
|
|
|
+ int value = oneByte - 130;
|
|
|
+ if (value < 10) { // padd with '0' for single digit values
|
|
|
+ result << '0';
|
|
|
+ }
|
|
|
+ result << value;
|
|
|
+ } else if (oneByte == 230) { // Latch to C40 encodation
|
|
|
+ return C40_ENCODE;
|
|
|
+ } else if (oneByte == 231) { // Latch to Base 256 encodation
|
|
|
+ return BASE256_ENCODE;
|
|
|
+ } else if (oneByte == 232) { // FNC1
|
|
|
+ result << ((char) 29); // translate as ASCII 29
|
|
|
+ } else if (oneByte == 233 || oneByte == 234) {
|
|
|
+ // Structured Append, Reader Programming
|
|
|
+ // Ignore these symbols for now
|
|
|
+ // throw FormatException.getInstance();
|
|
|
+ } else if (oneByte == 235) { // Upper Shift (shift to Extended ASCII)
|
|
|
+ upperShift = true;
|
|
|
+ } else if (oneByte == 236) { // 05 Macro
|
|
|
+ result << ("[)>RS05GS");
|
|
|
+ resultTrailer << ("RSEOT");
|
|
|
+ } else if (oneByte == 237) { // 06 Macro
|
|
|
+ result << ("[)>RS06GS");
|
|
|
+ resultTrailer << ("RSEOT");
|
|
|
+ } else if (oneByte == 238) { // Latch to ANSI X12 encodation
|
|
|
+ return ANSIX12_ENCODE;
|
|
|
+ } else if (oneByte == 239) { // Latch to Text encodation
|
|
|
+ return TEXT_ENCODE;
|
|
|
+ } else if (oneByte == 240) { // Latch to EDIFACT encodation
|
|
|
+ return EDIFACT_ENCODE;
|
|
|
+ } else if (oneByte == 241) { // ECI Character
|
|
|
+ // TODO(bbrown): I think we need to support ECI
|
|
|
+ // throw FormatException.getInstance();
|
|
|
+ // Ignore this symbol for now
|
|
|
+ } else if (oneByte >= 242) { // Not to be used in ASCII encodation
|
|
|
+ // ... but work around encoders that end with 254, latch back to ASCII
|
|
|
+ if (oneByte == 254 && bits->available() == 0) {
|
|
|
+ // Ignore
|
|
|
+ } else {
|
|
|
+ throw FormatException("Not to be used in ASCII encodation");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (bits->available() > 0);
|
|
|
+ return ASCII_ENCODE;
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeC40Segment(Ref<BitSource> bits, ostringstream & result) {
|
|
|
+ // Three C40 values are encoded in a 16-bit value as
|
|
|
+ // (1600 * C1) + (40 * C2) + C3 + 1
|
|
|
+ // TODO(bbrown): The Upper Shift with C40 doesn't work in the 4 value scenario all the time
|
|
|
+ bool upperShift = false;
|
|
|
+
|
|
|
+ int* cValues = new int[3];
|
|
|
+ int shift = 0;
|
|
|
+ do {
|
|
|
+ // If there is only one byte left then it will be encoded as ASCII
|
|
|
+ if (bits->available() == 8) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ int firstByte = bits->readBits(8);
|
|
|
+ if (firstByte == 254) { // Unlatch codeword
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ parseTwoBytes(firstByte, bits->readBits(8), cValues);
|
|
|
+
|
|
|
+ for (int i = 0; i < 3; i++) {
|
|
|
+ int cValue = cValues[i];
|
|
|
+ switch (shift) {
|
|
|
+ case 0:
|
|
|
+ if (cValue < 3) {
|
|
|
+ shift = cValue + 1;
|
|
|
+ } else {
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (C40_BASIC_SET_CHARS[cValue] + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << C40_BASIC_SET_CHARS[cValue];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (cValue + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << (char) cValue;
|
|
|
+ }
|
|
|
+ shift = 0;
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ if (cValue < 27) {
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (C40_SHIFT2_SET_CHARS[cValue] + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << C40_SHIFT2_SET_CHARS[cValue];
|
|
|
+ }
|
|
|
+ } else if (cValue == 27) { // FNC1
|
|
|
+ result << ((char) 29); // translate as ASCII 29
|
|
|
+ } else if (cValue == 30) { // Upper Shift
|
|
|
+ upperShift = true;
|
|
|
+ } else {
|
|
|
+ throw FormatException("decodeC40Segment: Upper Shift");
|
|
|
+ }
|
|
|
+ shift = 0;
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (cValue + 224);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << (char) (cValue + 96);
|
|
|
+ }
|
|
|
+ shift = 0;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw FormatException("decodeC40Segment: no case");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (bits->available() > 0);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeTextSegment(Ref<BitSource> bits, ostringstream & result) {
|
|
|
+ // Three Text values are encoded in a 16-bit value as
|
|
|
+ // (1600 * C1) + (40 * C2) + C3 + 1
|
|
|
+ // TODO(bbrown): The Upper Shift with Text doesn't work in the 4 value scenario all the time
|
|
|
+ bool upperShift = false;
|
|
|
+
|
|
|
+ int* cValues = new int[3];
|
|
|
+ int shift = 0;
|
|
|
+ do {
|
|
|
+ // If there is only one byte left then it will be encoded as ASCII
|
|
|
+ if (bits->available() == 8) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ int firstByte = bits->readBits(8);
|
|
|
+ if (firstByte == 254) { // Unlatch codeword
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ parseTwoBytes(firstByte, bits->readBits(8), cValues);
|
|
|
+
|
|
|
+ for (int i = 0; i < 3; i++) {
|
|
|
+ int cValue = cValues[i];
|
|
|
+ switch (shift) {
|
|
|
+ case 0:
|
|
|
+ if (cValue < 3) {
|
|
|
+ shift = cValue + 1;
|
|
|
+ } else {
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (TEXT_BASIC_SET_CHARS[cValue] + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << (TEXT_BASIC_SET_CHARS[cValue]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (cValue + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << (char) (cValue);
|
|
|
+ }
|
|
|
+ shift = 0;
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ // Shift 2 for Text is the same encoding as C40
|
|
|
+ if (cValue < 27) {
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (C40_SHIFT2_SET_CHARS[cValue] + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << (C40_SHIFT2_SET_CHARS[cValue]);
|
|
|
+ }
|
|
|
+ } else if (cValue == 27) { // FNC1
|
|
|
+ result << ((char) 29); // translate as ASCII 29
|
|
|
+ } else if (cValue == 30) { // Upper Shift
|
|
|
+ upperShift = true;
|
|
|
+ } else {
|
|
|
+ throw FormatException("decodeTextSegment: Upper Shift");
|
|
|
+ }
|
|
|
+ shift = 0;
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ if (upperShift) {
|
|
|
+ result << (char) (TEXT_SHIFT3_SET_CHARS[cValue] + 128);
|
|
|
+ upperShift = false;
|
|
|
+ } else {
|
|
|
+ result << (TEXT_SHIFT3_SET_CHARS[cValue]);
|
|
|
+ }
|
|
|
+ shift = 0;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw FormatException("decodeTextSegment: no case");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (bits->available() > 0);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeAnsiX12Segment(Ref<BitSource> bits, ostringstream & result) {
|
|
|
+ // Three ANSI X12 values are encoded in a 16-bit value as
|
|
|
+ // (1600 * C1) + (40 * C2) + C3 + 1
|
|
|
+
|
|
|
+ int* cValues = new int[3];
|
|
|
+ do {
|
|
|
+ // If there is only one byte left then it will be encoded as ASCII
|
|
|
+ if (bits->available() == 8) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ int firstByte = bits->readBits(8);
|
|
|
+ if (firstByte == 254) { // Unlatch codeword
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ parseTwoBytes(firstByte, bits->readBits(8), cValues);
|
|
|
+
|
|
|
+ for (int i = 0; i < 3; i++) {
|
|
|
+ int cValue = cValues[i];
|
|
|
+ if (cValue == 0) { // X12 segment terminator <CR>
|
|
|
+ result << '\r';
|
|
|
+ } else if (cValue == 1) { // X12 segment separator *
|
|
|
+ result << '*';
|
|
|
+ } else if (cValue == 2) { // X12 sub-element separator >
|
|
|
+ result << '>';
|
|
|
+ } else if (cValue == 3) { // space
|
|
|
+ result << ' ';
|
|
|
+ } else if (cValue < 14) { // 0 - 9
|
|
|
+ result << (char) (cValue + 44);
|
|
|
+ } else if (cValue < 40) { // A - Z
|
|
|
+ result << (char) (cValue + 51);
|
|
|
+ } else {
|
|
|
+ throw FormatException("decodeAnsiX12Segment: no case");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (bits->available() > 0);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::parseTwoBytes(int firstByte, int secondByte, int*& result) {
|
|
|
+ int fullBitValue = (firstByte << 8) + secondByte - 1;
|
|
|
+ int temp = fullBitValue / 1600;
|
|
|
+ result[0] = temp;
|
|
|
+ fullBitValue -= temp * 1600;
|
|
|
+ temp = fullBitValue / 40;
|
|
|
+ result[1] = temp;
|
|
|
+ result[2] = fullBitValue - temp * 40;
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeEdifactSegment(Ref<BitSource> bits, ostringstream & result) {
|
|
|
+ bool unlatch = false;
|
|
|
+ do {
|
|
|
+ // If there is only two or less bytes left then it will be encoded as ASCII
|
|
|
+ if (bits->available() <= 16) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < 4; i++) {
|
|
|
+ int edifactValue = bits->readBits(6);
|
|
|
+
|
|
|
+ // Check for the unlatch character
|
|
|
+ if (edifactValue == 0x2B67) { // 011111
|
|
|
+ unlatch = true;
|
|
|
+ // If we encounter the unlatch code then continue reading because the Codeword triple
|
|
|
+ // is padded with 0's
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!unlatch) {
|
|
|
+ if ((edifactValue & 0x20) == 0) { // no 1 in the leading (6th) bit
|
|
|
+ edifactValue |= 0x40; // Add a leading 01 to the 6 bit binary value
|
|
|
+ }
|
|
|
+ result << (char)(edifactValue);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (!unlatch && bits->available() > 0);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeBase256Segment(Ref<BitSource> bits, ostringstream& result, vector<unsigned char> byteSegments) {
|
|
|
+ // Figure out how long the Base 256 Segment is.
|
|
|
+ int codewordPosition = 1 + bits->getByteOffset(); // position is 1-indexed
|
|
|
+ int d1 = unrandomize255State(bits->readBits(8), codewordPosition++);
|
|
|
+ int count;
|
|
|
+ if (d1 == 0) { // Read the remainder of the symbol
|
|
|
+ count = bits->available() / 8;
|
|
|
+ } else if (d1 < 250) {
|
|
|
+ count = d1;
|
|
|
+ } else {
|
|
|
+ count = 250 * (d1 - 249) + unrandomize255State(bits->readBits(8), codewordPosition++);
|
|
|
+ }
|
|
|
+
|
|
|
+ // We're seeing NegativeArraySizeException errors from users.
|
|
|
+ if (count < 0) {
|
|
|
+ throw FormatException("NegativeArraySizeException");
|
|
|
+ }
|
|
|
+
|
|
|
+ unsigned char* bytes = new unsigned char[count];
|
|
|
+ for (int i = 0; i < count; i++) {
|
|
|
+ // Have seen this particular error in the wild, such as at
|
|
|
+ // http://www.bcgen.com/demo/IDAutomationStreamingDataMatrix.aspx?MODE=3&D=Fred&PFMT=3&PT=F&X=0.3&O=0&LM=0.2
|
|
|
+ if (bits->available() < 8) {
|
|
|
+ throw FormatException("byteSegments");
|
|
|
+ }
|
|
|
+ bytes[i] = unrandomize255State(bits->readBits(8), codewordPosition++);
|
|
|
+ byteSegments.push_back(bytes[i]);
|
|
|
+ result << (char)bytes[i];
|
|
|
+ }
|
|
|
+}
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// file: zxing/datamatrix/decoder/Decoder.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Decoder.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/datamatrix/decoder/Decoder.h>
|
|
|
+// #include <zxing/datamatrix/decoder/BitMatrixParser.h>
|
|
|
+// #include <zxing/datamatrix/decoder/DataBlock.h>
|
|
|
+// #include <zxing/datamatrix/decoder/DecodedBitStreamParser.h>
|
|
|
+// #include <zxing/datamatrix/Version.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <zxing/common/reedsolomon/ReedSolomonException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+Decoder::Decoder() :
|
|
|
+ rsDecoder_(GF256::DATA_MATRIX_FIELD) {
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+void Decoder::correctErrors(ArrayRef<unsigned 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& ex) {
|
|
|
+ ReaderException rex(ex.what());
|
|
|
+ throw rex;
|
|
|
+ }
|
|
|
+ // Copy back into array of bytes -- only need to worry about the bytes that were data
|
|
|
+ // We don't care about errors in the error-correction codewords
|
|
|
+ for (int i = 0; i < numDataCodewords; i++) {
|
|
|
+ codewordBytes[i] = (unsigned char)codewordInts[i];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
|
|
|
+ // Construct a parser and read version, error-correction level
|
|
|
+ BitMatrixParser parser(bits);
|
|
|
+ Version *version = parser.readVersion(bits);
|
|
|
+
|
|
|
+ // Read codewords
|
|
|
+ ArrayRef<unsigned char> codewords(parser.readCodewords());
|
|
|
+ // Separate into data blocks
|
|
|
+ std::vector<Ref<DataBlock> > dataBlocks = DataBlock::getDataBlocks(codewords, version);
|
|
|
+
|
|
|
+ int dataBlocksCount = dataBlocks.size();
|
|
|
+
|
|
|
+ // Count total number of data bytes
|
|
|
+ int totalBytes = 0;
|
|
|
+ for (int i = 0; i < dataBlocksCount; i++) {
|
|
|
+ totalBytes += dataBlocks[i]->getNumDataCodewords();
|
|
|
+ }
|
|
|
+ ArrayRef<unsigned char> resultBytes(totalBytes);
|
|
|
+
|
|
|
+ // Error-correct and copy data blocks together into a stream of bytes
|
|
|
+ for (int j = 0; j < dataBlocksCount; j++) {
|
|
|
+ Ref<DataBlock> dataBlock(dataBlocks[j]);
|
|
|
+ ArrayRef<unsigned char> codewordBytes = dataBlock->getCodewords();
|
|
|
+ int numDataCodewords = dataBlock->getNumDataCodewords();
|
|
|
+ correctErrors(codewordBytes, numDataCodewords);
|
|
|
+ for (int i = 0; i < numDataCodewords; i++) {
|
|
|
+ // De-interlace data blocks.
|
|
|
+ resultBytes[i * dataBlocksCount + j] = codewordBytes[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Decode the contents of that stream of bytes
|
|
|
+ DecodedBitStreamParser decodedBSParser;
|
|
|
+ return Ref<DecoderResult> (decodedBSParser.decode(resultBytes));
|
|
|
+}
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/detector/CornerPoint.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * CornerPoint.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/datamatrix/detector/CornerPoint.h>
|
|
|
+
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace datamatrix {
|
|
|
+
|
|
|
+ using namespace std;
|
|
|
+
|
|
|
+ CornerPoint::CornerPoint(float posX, float posY) :
|
|
|
+ ResultPoint(posX,posY), counter_(0) {
|
|
|
+ }
|
|
|
+
|
|
|
+ int CornerPoint::getCount() const {
|
|
|
+ return counter_;
|
|
|
+ }
|
|
|
+
|
|
|
+ void CornerPoint::incrementCount() {
|
|
|
+ counter_++;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool CornerPoint::equals(Ref<CornerPoint> other) const {
|
|
|
+ return posX_ == other->getX() && posY_ == other->getY();
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/detector/Detector.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Detector.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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 <zxing/common/GridSampler.h>
|
|
|
+// #include <zxing/datamatrix/detector/Detector.h>
|
|
|
+// #include <cmath>
|
|
|
+// #include <sstream>
|
|
|
+// #include <cstdlib>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+ResultPointsAndTransitions::ResultPointsAndTransitions() {
|
|
|
+ Ref<ResultPoint> ref(new ResultPoint(0, 0));
|
|
|
+ from_ = ref;
|
|
|
+ to_ = ref;
|
|
|
+ transitions_ = 0;
|
|
|
+}
|
|
|
+
|
|
|
+ResultPointsAndTransitions::ResultPointsAndTransitions(Ref<ResultPoint> from, Ref<ResultPoint> to,
|
|
|
+ int transitions)
|
|
|
+ : to_(to), from_(from), transitions_(transitions) {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<ResultPoint> ResultPointsAndTransitions::getFrom() {
|
|
|
+ return from_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<ResultPoint> ResultPointsAndTransitions::getTo() {
|
|
|
+ return to_;
|
|
|
+}
|
|
|
+
|
|
|
+int ResultPointsAndTransitions::getTransitions() {
|
|
|
+ return transitions_;
|
|
|
+}
|
|
|
+
|
|
|
+Detector::Detector(Ref<BitMatrix> image)
|
|
|
+ : image_(image) {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> Detector::getImage() {
|
|
|
+ return image_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<DetectorResult> Detector::detect() {
|
|
|
+ Ref<WhiteRectangleDetector> rectangleDetector_(new WhiteRectangleDetector(image_));
|
|
|
+ std::vector<Ref<ResultPoint> > ResultPoints = rectangleDetector_->detect();
|
|
|
+ Ref<ResultPoint> pointA = ResultPoints[0];
|
|
|
+ Ref<ResultPoint> pointB = ResultPoints[1];
|
|
|
+ Ref<ResultPoint> pointC = ResultPoints[2];
|
|
|
+ Ref<ResultPoint> pointD = ResultPoints[3];
|
|
|
+
|
|
|
+ // Point A and D are across the diagonal from one another,
|
|
|
+ // as are B and C. Figure out which are the solid black lines
|
|
|
+ // by counting transitions
|
|
|
+ std::vector<Ref<ResultPointsAndTransitions> > transitions(4);
|
|
|
+ transitions[0].reset(transitionsBetween(pointA, pointB));
|
|
|
+ transitions[1].reset(transitionsBetween(pointA, pointC));
|
|
|
+ transitions[2].reset(transitionsBetween(pointB, pointD));
|
|
|
+ transitions[3].reset(transitionsBetween(pointC, pointD));
|
|
|
+ insertionSort(transitions);
|
|
|
+
|
|
|
+ // Sort by number of transitions. First two will be the two solid sides; last two
|
|
|
+ // will be the two alternating black/white sides
|
|
|
+ Ref<ResultPointsAndTransitions> lSideOne(transitions[0]);
|
|
|
+ Ref<ResultPointsAndTransitions> lSideTwo(transitions[1]);
|
|
|
+
|
|
|
+ // Figure out which point is their intersection by tallying up the number of times we see the
|
|
|
+ // endpoints in the four endpoints. One will show up twice.
|
|
|
+ Ref<ResultPoint> maybeTopLeft;
|
|
|
+ Ref<ResultPoint> bottomLeft;
|
|
|
+ Ref<ResultPoint> maybeBottomRight;
|
|
|
+ if (lSideOne->getFrom()->equals(lSideOne->getTo())) {
|
|
|
+ bottomLeft = lSideOne->getFrom();
|
|
|
+ maybeTopLeft = lSideTwo->getFrom();
|
|
|
+ maybeBottomRight = lSideTwo->getTo();
|
|
|
+ } else if (lSideOne->getFrom()->equals(lSideTwo->getFrom())) {
|
|
|
+ bottomLeft = lSideOne->getFrom();
|
|
|
+ maybeTopLeft = lSideOne->getTo();
|
|
|
+ maybeBottomRight = lSideTwo->getTo();
|
|
|
+ } else if (lSideOne->getFrom()->equals(lSideTwo->getTo())) {
|
|
|
+ bottomLeft = lSideOne->getFrom();
|
|
|
+ maybeTopLeft = lSideOne->getTo();
|
|
|
+ maybeBottomRight = lSideTwo->getFrom();
|
|
|
+ } else if (lSideOne->getTo()->equals(lSideTwo->getFrom())) {
|
|
|
+ bottomLeft = lSideOne->getTo();
|
|
|
+ maybeTopLeft = lSideOne->getFrom();
|
|
|
+ maybeBottomRight = lSideTwo->getTo();
|
|
|
+ } else if (lSideOne->getTo()->equals(lSideTwo->getTo())) {
|
|
|
+ bottomLeft = lSideOne->getTo();
|
|
|
+ maybeTopLeft = lSideOne->getFrom();
|
|
|
+ maybeBottomRight = lSideTwo->getFrom();
|
|
|
+ } else {
|
|
|
+ bottomLeft = lSideTwo->getFrom();
|
|
|
+ maybeTopLeft = lSideOne->getTo();
|
|
|
+ maybeBottomRight = lSideOne->getFrom();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Bottom left is correct but top left and bottom right might be switched
|
|
|
+ std::vector<Ref<ResultPoint> > corners(3);
|
|
|
+ corners[0].reset(maybeTopLeft);
|
|
|
+ corners[1].reset(bottomLeft);
|
|
|
+ corners[2].reset(maybeBottomRight);
|
|
|
+
|
|
|
+ // Use the dot product trick to sort them out
|
|
|
+ ResultPoint::orderBestPatterns(corners);
|
|
|
+
|
|
|
+ // Now we know which is which:
|
|
|
+ Ref<ResultPoint> bottomRight(corners[0]);
|
|
|
+ bottomLeft = corners[1];
|
|
|
+ Ref<ResultPoint> topLeft(corners[2]);
|
|
|
+
|
|
|
+ // Which point didn't we find in relation to the "L" sides? that's the top right corner
|
|
|
+ Ref<ResultPoint> topRight;
|
|
|
+ if (!(pointA->equals(bottomRight) || pointA->equals(bottomLeft) || pointA->equals(topLeft))) {
|
|
|
+ topRight = pointA;
|
|
|
+ } else if (!(pointB->equals(bottomRight) || pointB->equals(bottomLeft)
|
|
|
+ || pointB->equals(topLeft))) {
|
|
|
+ topRight = pointB;
|
|
|
+ } else if (!(pointC->equals(bottomRight) || pointC->equals(bottomLeft)
|
|
|
+ || pointC->equals(topLeft))) {
|
|
|
+ topRight = pointC;
|
|
|
+ } else {
|
|
|
+ topRight = pointD;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Next determine the dimension by tracing along the top or right side and counting black/white
|
|
|
+ // transitions. Since we start inside a black module, we should see a number of transitions
|
|
|
+ // equal to 1 less than the code dimension. Well, actually 2 less, because we are going to
|
|
|
+ // end on a black module:
|
|
|
+
|
|
|
+ // The top right point is actually the corner of a module, which is one of the two black modules
|
|
|
+ // adjacent to the white module at the top right. Tracing to that corner from either the top left
|
|
|
+ // or bottom right should work here.
|
|
|
+
|
|
|
+ int dimensionTop = transitionsBetween(topLeft, topRight)->getTransitions();
|
|
|
+ int dimensionRight = transitionsBetween(bottomRight, topRight)->getTransitions();
|
|
|
+
|
|
|
+ //dimensionTop++;
|
|
|
+ if ((dimensionTop & 0x01) == 1) {
|
|
|
+ // it can't be odd, so, round... up?
|
|
|
+ dimensionTop++;
|
|
|
+ }
|
|
|
+ dimensionTop += 2;
|
|
|
+
|
|
|
+ //dimensionRight++;
|
|
|
+ if ((dimensionRight & 0x01) == 1) {
|
|
|
+ // it can't be odd, so, round... up?
|
|
|
+ dimensionRight++;
|
|
|
+ }
|
|
|
+ dimensionRight += 2;
|
|
|
+
|
|
|
+ Ref<BitMatrix> bits;
|
|
|
+ Ref<PerspectiveTransform> transform;
|
|
|
+ Ref<ResultPoint> correctedTopRight;
|
|
|
+
|
|
|
+
|
|
|
+ // Rectanguar symbols are 6x16, 6x28, 10x24, 10x32, 14x32, or 14x44. If one dimension is more
|
|
|
+ // than twice the other, it's certainly rectangular, but to cut a bit more slack we accept it as
|
|
|
+ // rectangular if the bigger side is at least 7/4 times the other:
|
|
|
+ if (4 * dimensionTop >= 7 * dimensionRight || 4 * dimensionRight >= 7 * dimensionTop) {
|
|
|
+ // The matrix is rectangular
|
|
|
+ correctedTopRight = correctTopRightRectangular(bottomLeft, bottomRight, topLeft, topRight,
|
|
|
+ dimensionTop, dimensionRight);
|
|
|
+ if (correctedTopRight == NULL) {
|
|
|
+ correctedTopRight = topRight;
|
|
|
+ }
|
|
|
+
|
|
|
+ dimensionTop = transitionsBetween(topLeft, correctedTopRight)->getTransitions();
|
|
|
+ dimensionRight = transitionsBetween(bottomRight, correctedTopRight)->getTransitions();
|
|
|
+
|
|
|
+ if ((dimensionTop & 0x01) == 1) {
|
|
|
+ // it can't be odd, so, round... up?
|
|
|
+ dimensionTop++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((dimensionRight & 0x01) == 1) {
|
|
|
+ // it can't be odd, so, round... up?
|
|
|
+ dimensionRight++;
|
|
|
+ }
|
|
|
+
|
|
|
+ transform = createTransform(topLeft, correctedTopRight, bottomLeft, bottomRight, dimensionTop,
|
|
|
+ dimensionRight);
|
|
|
+ bits = sampleGrid(image_, dimensionTop, dimensionRight, transform);
|
|
|
+
|
|
|
+ } else {
|
|
|
+ // The matrix is square
|
|
|
+ int dimension = min(dimensionRight, dimensionTop);
|
|
|
+
|
|
|
+ // correct top right point to match the white module
|
|
|
+ correctedTopRight = correctTopRight(bottomLeft, bottomRight, topLeft, topRight, dimension);
|
|
|
+ if (correctedTopRight == NULL) {
|
|
|
+ correctedTopRight = topRight;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Redetermine the dimension using the corrected top right point
|
|
|
+ int dimensionCorrected = max(transitionsBetween(topLeft, correctedTopRight)->getTransitions(),
|
|
|
+ transitionsBetween(bottomRight, correctedTopRight)->getTransitions());
|
|
|
+ dimensionCorrected++;
|
|
|
+ if ((dimensionCorrected & 0x01) == 1) {
|
|
|
+ dimensionCorrected++;
|
|
|
+ }
|
|
|
+
|
|
|
+ transform = createTransform(topLeft, correctedTopRight, bottomLeft, bottomRight,
|
|
|
+ dimensionCorrected, dimensionCorrected);
|
|
|
+ bits = sampleGrid(image_, dimensionCorrected, dimensionCorrected, transform);
|
|
|
+ }
|
|
|
+
|
|
|
+ std::vector<Ref<ResultPoint> > points(4);
|
|
|
+ points[0].reset(topLeft);
|
|
|
+ points[1].reset(bottomLeft);
|
|
|
+ points[2].reset(correctedTopRight);
|
|
|
+ points[3].reset(bottomRight);
|
|
|
+ Ref<DetectorResult> detectorResult(new DetectorResult(bits, points, transform));
|
|
|
+ return detectorResult;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Calculates the position of the white top right module using the output of the rectangle detector
|
|
|
+ * for a rectangular matrix
|
|
|
+ */
|
|
|
+Ref<ResultPoint> Detector::correctTopRightRectangular(Ref<ResultPoint> bottomLeft,
|
|
|
+ Ref<ResultPoint> bottomRight, Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
|
|
|
+ int dimensionTop, int dimensionRight) {
|
|
|
+
|
|
|
+ float corr = distance(bottomLeft, bottomRight) / (float) dimensionTop;
|
|
|
+ int norm = distance(topLeft, topRight);
|
|
|
+ float cos = (topRight->getX() - topLeft->getX()) / norm;
|
|
|
+ float sin = (topRight->getY() - topLeft->getY()) / norm;
|
|
|
+
|
|
|
+ Ref<ResultPoint> c1(
|
|
|
+ new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
|
|
|
+
|
|
|
+ corr = distance(bottomLeft, topLeft) / (float) dimensionRight;
|
|
|
+ norm = distance(bottomRight, topRight);
|
|
|
+ cos = (topRight->getX() - bottomRight->getX()) / norm;
|
|
|
+ sin = (topRight->getY() - bottomRight->getY()) / norm;
|
|
|
+
|
|
|
+ Ref<ResultPoint> c2(
|
|
|
+ new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
|
|
|
+
|
|
|
+ if (!isValid(c1)) {
|
|
|
+ if (isValid(c2)) {
|
|
|
+ return c2;
|
|
|
+ }
|
|
|
+ return Ref<ResultPoint>(NULL);
|
|
|
+ }
|
|
|
+ if (!isValid(c2)) {
|
|
|
+ return c1;
|
|
|
+ }
|
|
|
+
|
|
|
+ int l1 = abs(dimensionTop - transitionsBetween(topLeft, c1)->getTransitions())
|
|
|
+ + abs(dimensionRight - transitionsBetween(bottomRight, c1)->getTransitions());
|
|
|
+ int l2 = abs(dimensionTop - transitionsBetween(topLeft, c2)->getTransitions())
|
|
|
+ + abs(dimensionRight - transitionsBetween(bottomRight, c2)->getTransitions());
|
|
|
+
|
|
|
+ return l1 <= l2 ? c1 : c2;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * Calculates the position of the white top right module using the output of the rectangle detector
|
|
|
+ * for a square matrix
|
|
|
+ */
|
|
|
+Ref<ResultPoint> Detector::correctTopRight(Ref<ResultPoint> bottomLeft,
|
|
|
+ Ref<ResultPoint> bottomRight, Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight,
|
|
|
+ int dimension) {
|
|
|
+
|
|
|
+ float corr = distance(bottomLeft, bottomRight) / (float) dimension;
|
|
|
+ int norm = distance(topLeft, topRight);
|
|
|
+ float cos = (topRight->getX() - topLeft->getX()) / norm;
|
|
|
+ float sin = (topRight->getY() - topLeft->getY()) / norm;
|
|
|
+
|
|
|
+ Ref<ResultPoint> c1(
|
|
|
+ new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
|
|
|
+
|
|
|
+ corr = distance(bottomLeft, bottomRight) / (float) dimension;
|
|
|
+ norm = distance(bottomRight, topRight);
|
|
|
+ cos = (topRight->getX() - bottomRight->getX()) / norm;
|
|
|
+ sin = (topRight->getY() - bottomRight->getY()) / norm;
|
|
|
+
|
|
|
+ Ref<ResultPoint> c2(
|
|
|
+ new ResultPoint(topRight->getX() + corr * cos, topRight->getY() + corr * sin));
|
|
|
+
|
|
|
+ if (!isValid(c1)) {
|
|
|
+ if (isValid(c2)) {
|
|
|
+ return c2;
|
|
|
+ }
|
|
|
+ return Ref<ResultPoint>(NULL);
|
|
|
+ }
|
|
|
+ if (!isValid(c2)) {
|
|
|
+ return c1;
|
|
|
+ }
|
|
|
+
|
|
|
+ int l1 = abs(
|
|
|
+ transitionsBetween(topLeft, c1)->getTransitions()
|
|
|
+ - transitionsBetween(bottomRight, c1)->getTransitions());
|
|
|
+ int l2 = abs(
|
|
|
+ transitionsBetween(topLeft, c2)->getTransitions()
|
|
|
+ - transitionsBetween(bottomRight, c2)->getTransitions());
|
|
|
+
|
|
|
+ return l1 <= l2 ? c1 : c2;
|
|
|
+}
|
|
|
+
|
|
|
+bool Detector::isValid(Ref<ResultPoint> p) {
|
|
|
+ return p->getX() >= 0 && p->getX() < image_->getWidth() && p->getY() > 0
|
|
|
+ && p->getY() < image_->getHeight();
|
|
|
+}
|
|
|
+
|
|
|
+// L2 distance
|
|
|
+int Detector::distance(Ref<ResultPoint> a, Ref<ResultPoint> b) {
|
|
|
+ return round(
|
|
|
+ (float) sqrt(
|
|
|
+ (double) (a->getX() - b->getX()) * (a->getX() - b->getX())
|
|
|
+ + (a->getY() - b->getY()) * (a->getY() - b->getY())));
|
|
|
+}
|
|
|
+
|
|
|
+Ref<ResultPointsAndTransitions> Detector::transitionsBetween(Ref<ResultPoint> from,
|
|
|
+ Ref<ResultPoint> to) {
|
|
|
+ // See QR Code Detector, sizeOfBlackWhiteBlackRun()
|
|
|
+ int fromX = (int) from->getX();
|
|
|
+ int fromY = (int) from->getY();
|
|
|
+ int toX = (int) to->getX();
|
|
|
+ int toY = (int) to->getY();
|
|
|
+ bool steep = abs(toY - fromY) > abs(toX - fromX);
|
|
|
+ if (steep) {
|
|
|
+ int temp = fromX;
|
|
|
+ fromX = fromY;
|
|
|
+ fromY = temp;
|
|
|
+ temp = toX;
|
|
|
+ toX = toY;
|
|
|
+ toY = temp;
|
|
|
+ }
|
|
|
+
|
|
|
+ int dx = abs(toX - fromX);
|
|
|
+ int dy = abs(toY - fromY);
|
|
|
+ int error = -dx >> 1;
|
|
|
+ int ystep = fromY < toY ? 1 : -1;
|
|
|
+ int xstep = fromX < toX ? 1 : -1;
|
|
|
+ int transitions = 0;
|
|
|
+ bool inBlack = image_->get(steep ? fromY : fromX, steep ? fromX : fromY);
|
|
|
+ for (int x = fromX, y = fromY; x != toX; x += xstep) {
|
|
|
+ bool isBlack = image_->get(steep ? y : x, steep ? x : y);
|
|
|
+ if (isBlack != inBlack) {
|
|
|
+ transitions++;
|
|
|
+ inBlack = isBlack;
|
|
|
+ }
|
|
|
+ error += dy;
|
|
|
+ if (error > 0) {
|
|
|
+ if (y == toY) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ y += ystep;
|
|
|
+ error -= dx;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ref<ResultPointsAndTransitions> result(new ResultPointsAndTransitions(from, to, transitions));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> Detector::createTransform(Ref<ResultPoint> topLeft,
|
|
|
+ Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft, Ref<ResultPoint> bottomRight,
|
|
|
+ int dimensionX, int dimensionY) {
|
|
|
+
|
|
|
+ Ref<PerspectiveTransform> transform(
|
|
|
+ PerspectiveTransform::quadrilateralToQuadrilateral(
|
|
|
+ 0.5f,
|
|
|
+ 0.5f,
|
|
|
+ dimensionX - 0.5f,
|
|
|
+ 0.5f,
|
|
|
+ dimensionX - 0.5f,
|
|
|
+ dimensionY - 0.5f,
|
|
|
+ 0.5f,
|
|
|
+ dimensionY - 0.5f,
|
|
|
+ topLeft->getX(),
|
|
|
+ topLeft->getY(),
|
|
|
+ topRight->getX(),
|
|
|
+ topRight->getY(),
|
|
|
+ bottomRight->getX(),
|
|
|
+ bottomRight->getY(),
|
|
|
+ bottomLeft->getX(),
|
|
|
+ bottomLeft->getY()));
|
|
|
+ return transform;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> Detector::sampleGrid(Ref<BitMatrix> image, int dimensionX, int dimensionY,
|
|
|
+ Ref<PerspectiveTransform> transform) {
|
|
|
+ GridSampler &sampler = GridSampler::getInstance();
|
|
|
+ return sampler.sampleGrid(image, dimensionX, dimensionY, transform);
|
|
|
+}
|
|
|
+
|
|
|
+void Detector::insertionSort(std::vector<Ref<ResultPointsAndTransitions> > &vector) {
|
|
|
+ int max = vector.size();
|
|
|
+ bool swapped = true;
|
|
|
+ Ref<ResultPointsAndTransitions> value;
|
|
|
+ Ref<ResultPointsAndTransitions> valueB;
|
|
|
+ do {
|
|
|
+ swapped = false;
|
|
|
+ for (int i = 1; i < max; i++) {
|
|
|
+ value = vector[i - 1];
|
|
|
+ if (compare(value, (valueB = vector[i])) > 0){
|
|
|
+ swapped = true;
|
|
|
+ vector[i - 1].reset(valueB);
|
|
|
+ vector[i].reset(value);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (swapped);
|
|
|
+}
|
|
|
+
|
|
|
+int Detector::compare(Ref<ResultPointsAndTransitions> a, Ref<ResultPointsAndTransitions> b) {
|
|
|
+ return a->getTransitions() - b->getTransitions();
|
|
|
+}
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/datamatrix/detector/DetectorException.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * DetectorException.cpp
|
|
|
+ *
|
|
|
+ * Created on: Aug 26, 2011
|
|
|
+ * Author: luiz
|
|
|
+ */
|
|
|
+
|
|
|
+// #include "DetectorException.h"
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+DetectorException::DetectorException(const char *msg) :
|
|
|
+ Exception(msg) {
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+DetectorException::~DetectorException() throw () {
|
|
|
+ // TODO Auto-generated destructor stub
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+} /* namespace zxing */
|
|
|
+
|
|
|
+// file: zxing/datamatrix/detector/MonochromeRectangleDetector.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * MonochromeRectangleDetector.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Luiz Silva on 09/02/2010.
|
|
|
+ * 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/ReaderException.h>
|
|
|
+// #include <zxing/datamatrix/detector/MonochromeRectangleDetector.h>
|
|
|
+// #include <sstream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace datamatrix {
|
|
|
+
|
|
|
+std::vector<Ref<CornerPoint> > MonochromeRectangleDetector::detect() {
|
|
|
+ int height = image_->getHeight();
|
|
|
+ int width = image_->getWidth();
|
|
|
+ int halfHeight = height >> 1;
|
|
|
+ int halfWidth = width >> 1;
|
|
|
+ int deltaY = max(1, height / (MAX_MODULES << 3));
|
|
|
+ int deltaX = max(1, width / (MAX_MODULES << 3));
|
|
|
+
|
|
|
+ int top = 0;
|
|
|
+ int bottom = height;
|
|
|
+ int left = 0;
|
|
|
+ int right = width;
|
|
|
+ Ref<CornerPoint> pointA(findCornerFromCenter(halfWidth, 0, left, right,
|
|
|
+ halfHeight, -deltaY, top, bottom, halfWidth >> 1));
|
|
|
+ top = (int) pointA->getY() - 1;
|
|
|
+ Ref<CornerPoint> pointB(findCornerFromCenter(halfWidth, -deltaX, left, right,
|
|
|
+ halfHeight, 0, top, bottom, halfHeight >> 1));
|
|
|
+ left = (int) pointB->getX() - 1;
|
|
|
+ Ref<CornerPoint> pointC(findCornerFromCenter(halfWidth, deltaX, left, right,
|
|
|
+ halfHeight, 0, top, bottom, halfHeight >> 1));
|
|
|
+ right = (int) pointC->getX() + 1;
|
|
|
+ Ref<CornerPoint> pointD(findCornerFromCenter(halfWidth, 0, left, right,
|
|
|
+ halfHeight, deltaY, top, bottom, halfWidth >> 1));
|
|
|
+ bottom = (int) pointD->getY() + 1;
|
|
|
+
|
|
|
+ // Go try to find point A again with better information -- might have been off at first.
|
|
|
+ pointA.reset(findCornerFromCenter(halfWidth, 0, left, right,
|
|
|
+ halfHeight, -deltaY, top, bottom, halfWidth >> 2));
|
|
|
+ std::vector<Ref<CornerPoint> > corners(4);
|
|
|
+
|
|
|
+ corners[0].reset(pointA);
|
|
|
+ corners[1].reset(pointB);
|
|
|
+ corners[2].reset(pointC);
|
|
|
+ corners[3].reset(pointD);
|
|
|
+ return corners;
|
|
|
+ }
|
|
|
+
|
|
|
+Ref<CornerPoint> MonochromeRectangleDetector::findCornerFromCenter(int centerX, int deltaX, int left, int right,
|
|
|
+ int centerY, int deltaY, int top, int bottom, int maxWhiteRun) {
|
|
|
+ Ref<TwoInts> lastRange(NULL);
|
|
|
+ for (int y = centerY, x = centerX;
|
|
|
+ y < bottom && y >= top && x < right && x >= left;
|
|
|
+ y += deltaY, x += deltaX) {
|
|
|
+ Ref<TwoInts> range(NULL);
|
|
|
+ if (deltaX == 0) {
|
|
|
+ // horizontal slices, up and down
|
|
|
+ range = blackWhiteRange(y, maxWhiteRun, left, right, true);
|
|
|
+ } else {
|
|
|
+ // vertical slices, left and right
|
|
|
+ range = blackWhiteRange(x, maxWhiteRun, top, bottom, false);
|
|
|
+ }
|
|
|
+ if (range == NULL) {
|
|
|
+ if (lastRange == NULL) {
|
|
|
+ throw ReaderException("Couldn't find corners (lastRange = NULL) ");
|
|
|
+ } else {
|
|
|
+ // lastRange was found
|
|
|
+ if (deltaX == 0) {
|
|
|
+ int lastY = y - deltaY;
|
|
|
+ if (lastRange->start < centerX) {
|
|
|
+ if (lastRange->end > centerX) {
|
|
|
+ // straddle, choose one or the other based on direction
|
|
|
+ Ref<CornerPoint> result(new CornerPoint(deltaY > 0 ? lastRange->start : lastRange->end, lastY));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ Ref<CornerPoint> result(new CornerPoint(lastRange->start, lastY));
|
|
|
+ return result;
|
|
|
+ } else {
|
|
|
+ Ref<CornerPoint> result(new CornerPoint(lastRange->end, lastY));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ int lastX = x - deltaX;
|
|
|
+ if (lastRange->start < centerY) {
|
|
|
+ if (lastRange->end > centerY) {
|
|
|
+ Ref<CornerPoint> result(new CornerPoint(lastX, deltaX < 0 ? lastRange->start : lastRange->end));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ Ref<CornerPoint> result(new CornerPoint(lastX, lastRange->start));
|
|
|
+ return result;
|
|
|
+ } else {
|
|
|
+ Ref<CornerPoint> result(new CornerPoint(lastX, lastRange->end));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ lastRange = range;
|
|
|
+ }
|
|
|
+ throw ReaderException("Couldn't find corners");
|
|
|
+ }
|
|
|
+
|
|
|
+Ref<TwoInts> MonochromeRectangleDetector::blackWhiteRange(int fixedDimension, int maxWhiteRun, int minDim, int maxDim,
|
|
|
+ bool horizontal) {
|
|
|
+
|
|
|
+ int center = (minDim + maxDim) >> 1;
|
|
|
+
|
|
|
+ // Scan left/up first
|
|
|
+ int start = center;
|
|
|
+ while (start >= minDim) {
|
|
|
+ if (horizontal ? image_->get(start, fixedDimension) : image_->get(fixedDimension, start)) {
|
|
|
+ start--;
|
|
|
+ } else {
|
|
|
+ int whiteRunStart = start;
|
|
|
+ do {
|
|
|
+ start--;
|
|
|
+ } while (start >= minDim && !(horizontal ? image_->get(start, fixedDimension) :
|
|
|
+ image_->get(fixedDimension, start)));
|
|
|
+ int whiteRunSize = whiteRunStart - start;
|
|
|
+ if (start < minDim || whiteRunSize > maxWhiteRun) {
|
|
|
+ start = whiteRunStart;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ start++;
|
|
|
+
|
|
|
+ // Then try right/down
|
|
|
+ int end = center;
|
|
|
+ while (end < maxDim) {
|
|
|
+ if (horizontal ? image_->get(end, fixedDimension) : image_->get(fixedDimension, end)) {
|
|
|
+ end++;
|
|
|
+ } else {
|
|
|
+ int whiteRunStart = end;
|
|
|
+ do {
|
|
|
+ end++;
|
|
|
+ } while (end < maxDim && !(horizontal ? image_->get(end, fixedDimension) :
|
|
|
+ image_->get(fixedDimension, end)));
|
|
|
+ int whiteRunSize = end - whiteRunStart;
|
|
|
+ if (end >= maxDim || whiteRunSize > maxWhiteRun) {
|
|
|
+ end = whiteRunStart;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ end--;
|
|
|
+ Ref<TwoInts> result(NULL);
|
|
|
+ if (end > start) {
|
|
|
+ result = new TwoInts;
|
|
|
+ result->start = start;
|
|
|
+ result->end = end;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/multi/ByQuadrantReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright 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/multi/ByQuadrantReader.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace multi {
|
|
|
+
|
|
|
+ByQuadrantReader::ByQuadrantReader(Reader& delegate) : delegate_(delegate) {}
|
|
|
+
|
|
|
+ByQuadrantReader::~ByQuadrantReader(){}
|
|
|
+
|
|
|
+Ref<Result> ByQuadrantReader::decode(Ref<BinaryBitmap> image){
|
|
|
+ return decode(image, DecodeHints::DEFAULT_HINT);
|
|
|
+}
|
|
|
+
|
|
|
+Ref<Result> ByQuadrantReader::decode(Ref<BinaryBitmap> image, DecodeHints hints){
|
|
|
+ int width = image->getWidth();
|
|
|
+ int height = image->getHeight();
|
|
|
+ int halfWidth = width / 2;
|
|
|
+ int halfHeight = height / 2;
|
|
|
+ Ref<BinaryBitmap> topLeft = image->crop(0, 0, halfWidth, halfHeight);
|
|
|
+ try {
|
|
|
+ return delegate_.decode(topLeft, hints);
|
|
|
+ } catch (ReaderException re) {
|
|
|
+ // continue
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BinaryBitmap> topRight = image->crop(halfWidth, 0, halfWidth, halfHeight);
|
|
|
+ try {
|
|
|
+ return delegate_.decode(topRight, hints);
|
|
|
+ } catch (ReaderException re) {
|
|
|
+ // continue
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BinaryBitmap> bottomLeft = image->crop(0, halfHeight, halfWidth, halfHeight);
|
|
|
+ try {
|
|
|
+ return delegate_.decode(bottomLeft, hints);
|
|
|
+ } catch (ReaderException re) {
|
|
|
+ // continue
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<BinaryBitmap> bottomRight = image->crop(halfWidth, halfHeight, halfWidth, halfHeight);
|
|
|
+ try {
|
|
|
+ return delegate_.decode(bottomRight, hints);
|
|
|
+ } catch (ReaderException re) {
|
|
|
+ // continue
|
|
|
+ }
|
|
|
+
|
|
|
+ int quarterWidth = halfWidth / 2;
|
|
|
+ int quarterHeight = halfHeight / 2;
|
|
|
+ Ref<BinaryBitmap> center = image->crop(quarterWidth, quarterHeight, halfWidth, halfHeight);
|
|
|
+ return delegate_.decode(center, hints);
|
|
|
+}
|
|
|
+
|
|
|
+} // End zxing::multi namespace
|
|
|
+} // End zxing namespace
|
|
|
+
|
|
|
+// file: zxing/multi/GenericMultipleBarcodeReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright 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/multi/GenericMultipleBarcodeReader.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <zxing/ResultPoint.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace multi {
|
|
|
+GenericMultipleBarcodeReader::GenericMultipleBarcodeReader(Reader& delegate) :
|
|
|
+ delegate_(delegate)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+GenericMultipleBarcodeReader::~GenericMultipleBarcodeReader(){}
|
|
|
+
|
|
|
+std::vector<Ref<Result> > GenericMultipleBarcodeReader::decodeMultiple(
|
|
|
+ Ref<BinaryBitmap> image, DecodeHints hints)
|
|
|
+{
|
|
|
+ std::vector<Ref<Result> > results;
|
|
|
+ doDecodeMultiple(image, hints, results, 0, 0);
|
|
|
+ if (results.empty()){
|
|
|
+ throw ReaderException("No code detected");
|
|
|
+ }
|
|
|
+ return results;
|
|
|
+}
|
|
|
+
|
|
|
+void GenericMultipleBarcodeReader::doDecodeMultiple(Ref<BinaryBitmap> image,
|
|
|
+ DecodeHints hints, std::vector<Ref<Result> >& results, int xOffset, int yOffset)
|
|
|
+{
|
|
|
+ Ref<Result> result;
|
|
|
+ try {
|
|
|
+ result = delegate_.decode(image, hints);
|
|
|
+ } catch (ReaderException re) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ bool alreadyFound = false;
|
|
|
+ for (unsigned int i = 0; i < results.size(); i++) {
|
|
|
+ Ref<Result> existingResult = results[i];
|
|
|
+ if (existingResult->getText()->getText() == result->getText()->getText()) {
|
|
|
+ alreadyFound = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (alreadyFound) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ results.push_back(translateResultPoints(result, xOffset, yOffset));
|
|
|
+ const std::vector<Ref<ResultPoint> > resultPoints = result->getResultPoints();
|
|
|
+ if (resultPoints.empty()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ int width = image->getWidth();
|
|
|
+ int height = image->getHeight();
|
|
|
+ float minX = width;
|
|
|
+ float minY = height;
|
|
|
+ float maxX = 0.0f;
|
|
|
+ float maxY = 0.0f;
|
|
|
+ for (unsigned int i = 0; i < resultPoints.size(); i++) {
|
|
|
+ Ref<ResultPoint> point = resultPoints[i];
|
|
|
+ float x = point->getX();
|
|
|
+ float y = point->getY();
|
|
|
+ if (x < minX) {
|
|
|
+ minX = x;
|
|
|
+ }
|
|
|
+ if (y < minY) {
|
|
|
+ minY = y;
|
|
|
+ }
|
|
|
+ if (x > maxX) {
|
|
|
+ maxX = x;
|
|
|
+ }
|
|
|
+ if (y > maxY) {
|
|
|
+ maxY = y;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Decode left of barcode
|
|
|
+ if (minX > MIN_DIMENSION_TO_RECUR) {
|
|
|
+ doDecodeMultiple(image->crop(0, 0, (int) minX, height),
|
|
|
+ hints, results, xOffset, yOffset);
|
|
|
+ }
|
|
|
+ // Decode above barcode
|
|
|
+ if (minY > MIN_DIMENSION_TO_RECUR) {
|
|
|
+ doDecodeMultiple(image->crop(0, 0, width, (int) minY),
|
|
|
+ hints, results, xOffset, yOffset);
|
|
|
+ }
|
|
|
+ // Decode right of barcode
|
|
|
+ if (maxX < width - MIN_DIMENSION_TO_RECUR) {
|
|
|
+ doDecodeMultiple(image->crop((int) maxX, 0, width - (int) maxX, height),
|
|
|
+ hints, results, xOffset + (int) maxX, yOffset);
|
|
|
+ }
|
|
|
+ // Decode below barcode
|
|
|
+ if (maxY < height - MIN_DIMENSION_TO_RECUR) {
|
|
|
+ doDecodeMultiple(image->crop(0, (int) maxY, width, height - (int) maxY),
|
|
|
+ hints, results, xOffset, yOffset + (int) maxY);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<Result> GenericMultipleBarcodeReader::translateResultPoints(Ref<Result> result, int xOffset, int yOffset){
|
|
|
+ const std::vector<Ref<ResultPoint> > oldResultPoints = result->getResultPoints();
|
|
|
+ if (oldResultPoints.empty()) {
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ std::vector<Ref<ResultPoint> > newResultPoints;
|
|
|
+ for (unsigned int i = 0; i < oldResultPoints.size(); i++) {
|
|
|
+ Ref<ResultPoint> oldPoint = oldResultPoints[i];
|
|
|
+ newResultPoints.push_back(Ref<ResultPoint>(new ResultPoint(oldPoint->getX() + xOffset, oldPoint->getY() + yOffset)));
|
|
|
+ }
|
|
|
+ return Ref<Result>(new Result(result->getText(), result->getRawBytes(), newResultPoints, result->getBarcodeFormat()));
|
|
|
+}
|
|
|
+
|
|
|
+} // End zxing::multi namespace
|
|
|
+} // End zxing namespace
|
|
|
+
|
|
|
+// file: zxing/multi/MultipleBarcodeReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright 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/multi/MultipleBarcodeReader.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace multi {
|
|
|
+
|
|
|
+MultipleBarcodeReader::~MultipleBarcodeReader() { }
|
|
|
+
|
|
|
+std::vector<Ref<Result> > MultipleBarcodeReader::decodeMultiple(Ref<BinaryBitmap> image) {
|
|
|
+ return decodeMultiple(image, DecodeHints::DEFAULT_HINT);
|
|
|
+}
|
|
|
+
|
|
|
+} // End zxing::multi namespace
|
|
|
+} // End zxing namespace
|
|
|
+
|
|
|
+// file: zxing/multi/qrcode/QRCodeMultiReader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Copyright 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/multi/qrcode/QRCodeMultiReader.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <zxing/multi/qrcode/detector/MultiDetector.h>
|
|
|
+// #include <zxing/BarcodeFormat.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace multi {
|
|
|
+QRCodeMultiReader::QRCodeMultiReader(){}
|
|
|
+
|
|
|
+QRCodeMultiReader::~QRCodeMultiReader(){}
|
|
|
+
|
|
|
+std::vector<Ref<Result> > QRCodeMultiReader::decodeMultiple(Ref<BinaryBitmap> image,
|
|
|
+ DecodeHints hints)
|
|
|
+{
|
|
|
+ std::vector<Ref<Result> > results;
|
|
|
+ MultiDetector detector(image->getBlackMatrix());
|
|
|
+
|
|
|
+ std::vector<Ref<DetectorResult> > detectorResult = detector.detectMulti(hints);
|
|
|
+ for (unsigned int i = 0; i < detectorResult.size(); i++) {
|
|
|
+ try {
|
|
|
+ Ref<DecoderResult> decoderResult = getDecoder().decode(detectorResult[i]->getBits());
|
|
|
+ std::vector<Ref<ResultPoint> > points = detectorResult[i]->getPoints();
|
|
|
+ Ref<Result> result = Ref<Result>(new Result(decoderResult->getText(),
|
|
|
+ decoderResult->getRawBytes(),
|
|
|
+ points, BarcodeFormat_QR_CODE));
|
|
|
+ // result->putMetadata(ResultMetadataType.BYTE_SEGMENTS, decoderResult->getByteSegments());
|
|
|
+ // result->putMetadata(ResultMetadataType.ERROR_CORRECTION_LEVEL, decoderResult->getECLevel().toString());
|
|
|
+ results.push_back(result);
|
|
|
+ } catch (ReaderException re) {
|
|
|
+ // ignore and continue
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (results.empty()){
|
|
|
+ throw ReaderException("No code detected");
|
|
|
+ }
|
|
|
+ return results;
|
|
|
+}
|
|
|
+
|
|
|
+} // End zxing::multi namespace
|
|
|
+} // End zxing namespace
|
|
|
+
|
|
|
+// file: zxing/multi/qrcode/detector/MultiDetector.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright 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 <zxing/multi/qrcode/detector/MultiDetector.h>
|
|
|
+// #include <zxing/multi/qrcode/detector/MultiFinderPatternFinder.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace multi {
|
|
|
+using namespace zxing::qrcode;
|
|
|
+
|
|
|
+MultiDetector::MultiDetector(Ref<BitMatrix> image) : Detector(image) {}
|
|
|
+
|
|
|
+MultiDetector::~MultiDetector(){}
|
|
|
+
|
|
|
+std::vector<Ref<DetectorResult> > MultiDetector::detectMulti(DecodeHints hints){
|
|
|
+ Ref<BitMatrix> image = getImage();
|
|
|
+ MultiFinderPatternFinder finder = MultiFinderPatternFinder(image, hints.getResultPointCallback());
|
|
|
+ std::vector<Ref<FinderPatternInfo> > info = finder.findMulti(hints);
|
|
|
+ std::vector<Ref<DetectorResult> > result;
|
|
|
+ for(unsigned int i = 0; i < info.size(); i++){
|
|
|
+ try{
|
|
|
+ result.push_back(processFinderPatternInfo(info[i]));
|
|
|
+ } catch (ReaderException e){
|
|
|
+ // ignore
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+} // End zxing::multi namespace
|
|
|
+} // End zxing namespace
|
|
|
+
|
|
|
+// file: zxing/multi/qrcode/detector/MultiFinderPatternFinder.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Copyright 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 <algorithm>
|
|
|
+// #include <math.h>
|
|
|
+// #include <stdlib.h>
|
|
|
+// #include <zxing/multi/qrcode/detector/MultiFinderPatternFinder.h>
|
|
|
+// #include <zxing/DecodeHints.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing{
|
|
|
+namespace multi {
|
|
|
+using namespace zxing::qrcode;
|
|
|
+
|
|
|
+const float MultiFinderPatternFinder::MAX_MODULE_COUNT_PER_EDGE = 180;
|
|
|
+const float MultiFinderPatternFinder::MIN_MODULE_COUNT_PER_EDGE = 9;
|
|
|
+const float MultiFinderPatternFinder::DIFF_MODSIZE_CUTOFF_PERCENT = 0.05f;
|
|
|
+const float MultiFinderPatternFinder::DIFF_MODSIZE_CUTOFF = 0.5f;
|
|
|
+
|
|
|
+bool compareModuleSize(Ref<FinderPattern> a, Ref<FinderPattern> b){
|
|
|
+ float value = a->getEstimatedModuleSize() - b->getEstimatedModuleSize();
|
|
|
+ return value < 0.0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+MultiFinderPatternFinder::MultiFinderPatternFinder(Ref<BitMatrix> image,
|
|
|
+ Ref<ResultPointCallback> resultPointCallback) :
|
|
|
+ FinderPatternFinder(image, resultPointCallback)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+MultiFinderPatternFinder::~MultiFinderPatternFinder(){}
|
|
|
+
|
|
|
+std::vector<Ref<FinderPatternInfo> > MultiFinderPatternFinder::findMulti(DecodeHints const& hints){
|
|
|
+ bool tryHarder = hints.getTryHarder();
|
|
|
+ Ref<BitMatrix> image = image_; // Protected member
|
|
|
+ int maxI = image->getHeight();
|
|
|
+ int maxJ = image->getWidth();
|
|
|
+ // We are looking for black/white/black/white/black modules in
|
|
|
+ // 1:1:3:1:1 ratio; this tracks the number of such modules seen so far
|
|
|
+
|
|
|
+ // Let's assume that the maximum version QR Code we support takes up 1/4 the height of the
|
|
|
+ // image, and then account for the center being 3 modules in size. This gives the smallest
|
|
|
+ // number of pixels the center could be, so skip this often. When trying harder, look for all
|
|
|
+ // QR versions regardless of how dense they are.
|
|
|
+ int iSkip = (int) (maxI / (MAX_MODULES * 4.0f) * 3);
|
|
|
+ if (iSkip < MIN_SKIP || tryHarder) {
|
|
|
+ iSkip = MIN_SKIP;
|
|
|
+ }
|
|
|
+
|
|
|
+ int stateCount[5];
|
|
|
+ for (int i = iSkip - 1; i < maxI; i += iSkip) {
|
|
|
+ // Get a row of black/white values
|
|
|
+ stateCount[0] = 0;
|
|
|
+ stateCount[1] = 0;
|
|
|
+ stateCount[2] = 0;
|
|
|
+ stateCount[3] = 0;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ int currentState = 0;
|
|
|
+ for (int j = 0; j < maxJ; j++) {
|
|
|
+ if (image->get(j, i)) {
|
|
|
+ // Black pixel
|
|
|
+ if ((currentState & 1) == 1) { // Counting white pixels
|
|
|
+ currentState++;
|
|
|
+ }
|
|
|
+ stateCount[currentState]++;
|
|
|
+ } else { // White pixel
|
|
|
+ if ((currentState & 1) == 0) { // Counting black pixels
|
|
|
+ if (currentState == 4) { // A winner?
|
|
|
+ if (foundPatternCross(stateCount)) { // Yes
|
|
|
+ bool confirmed = handlePossibleCenter(stateCount, i, j);
|
|
|
+ if (!confirmed) {
|
|
|
+ do { // Advance to next black pixel
|
|
|
+ j++;
|
|
|
+ } while (j < maxJ && !image->get(j, i));
|
|
|
+ j--; // back up to that last white pixel
|
|
|
+ }
|
|
|
+ // Clear state to start looking again
|
|
|
+ currentState = 0;
|
|
|
+ stateCount[0] = 0;
|
|
|
+ stateCount[1] = 0;
|
|
|
+ stateCount[2] = 0;
|
|
|
+ stateCount[3] = 0;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ } else { // No, shift counts back by two
|
|
|
+ stateCount[0] = stateCount[2];
|
|
|
+ stateCount[1] = stateCount[3];
|
|
|
+ stateCount[2] = stateCount[4];
|
|
|
+ stateCount[3] = 1;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ currentState = 3;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ stateCount[++currentState]++;
|
|
|
+ }
|
|
|
+ } else { // Counting white pixels
|
|
|
+ stateCount[currentState]++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } // for j=...
|
|
|
+
|
|
|
+ if (foundPatternCross(stateCount)) {
|
|
|
+ handlePossibleCenter(stateCount, i, maxJ);
|
|
|
+ } // end if foundPatternCross
|
|
|
+ } // for i=iSkip-1 ...
|
|
|
+ std::vector<std::vector<Ref<FinderPattern> > > patternInfo = selectBestPatterns();
|
|
|
+ std::vector<Ref<FinderPatternInfo> > result;
|
|
|
+ for (unsigned int i = 0; i < patternInfo.size(); i++) {
|
|
|
+ std::vector<Ref<FinderPattern> > pattern = patternInfo[i];
|
|
|
+ FinderPatternFinder::orderBestPatterns(pattern);
|
|
|
+ result.push_back(Ref<FinderPatternInfo>(new FinderPatternInfo(pattern)));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<std::vector<Ref<FinderPattern> > > MultiFinderPatternFinder::selectBestPatterns(){
|
|
|
+ std::vector<Ref<FinderPattern> > possibleCenters = possibleCenters_;
|
|
|
+
|
|
|
+ int size = possibleCenters.size();
|
|
|
+
|
|
|
+ if (size < 3) {
|
|
|
+ // Couldn't find enough finder patterns
|
|
|
+ throw ReaderException("No code detected");
|
|
|
+ }
|
|
|
+
|
|
|
+ std::vector<std::vector<Ref<FinderPattern> > > results;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Begin HE modifications to safely detect multiple codes of equal size
|
|
|
+ */
|
|
|
+ if (size == 3) {
|
|
|
+ results.push_back(possibleCenters_);
|
|
|
+ return results;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Sort by estimated module size to speed up the upcoming checks
|
|
|
+ //TODO do a sort based on module size
|
|
|
+ std::sort(possibleCenters.begin(), possibleCenters.end(), compareModuleSize);
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Now lets start: build a list of tuples of three finder locations that
|
|
|
+ * - feature similar module sizes
|
|
|
+ * - are placed in a distance so the estimated module count is within the QR specification
|
|
|
+ * - have similar distance between upper left/right and left top/bottom finder patterns
|
|
|
+ * - form a triangle with 90° angle (checked by comparing top right/bottom left distance
|
|
|
+ * with pythagoras)
|
|
|
+ *
|
|
|
+ * Note: we allow each point to be used for more than one code region: this might seem
|
|
|
+ * counterintuitive at first, but the performance penalty is not that big. At this point,
|
|
|
+ * we cannot make a good quality decision whether the three finders actually represent
|
|
|
+ * a QR code, or are just by chance layouted so it looks like there might be a QR code there.
|
|
|
+ * So, if the layout seems right, lets have the decoder try to decode.
|
|
|
+ */
|
|
|
+
|
|
|
+ for (int i1 = 0; i1 < (size - 2); i1++) {
|
|
|
+ Ref<FinderPattern> p1 = possibleCenters[i1];
|
|
|
+ for (int i2 = i1 + 1; i2 < (size - 1); i2++) {
|
|
|
+ Ref<FinderPattern> p2 = possibleCenters[i2];
|
|
|
+ // Compare the expected module sizes; if they are really off, skip
|
|
|
+ float vModSize12 = (p1->getEstimatedModuleSize() - p2->getEstimatedModuleSize()) / std::min(p1->getEstimatedModuleSize(), p2->getEstimatedModuleSize());
|
|
|
+ float vModSize12A = abs(p1->getEstimatedModuleSize() - p2->getEstimatedModuleSize());
|
|
|
+ if (vModSize12A > DIFF_MODSIZE_CUTOFF && vModSize12 >= DIFF_MODSIZE_CUTOFF_PERCENT) {
|
|
|
+ // break, since elements are ordered by the module size deviation there cannot be
|
|
|
+ // any more interesting elements for the given p1.
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ for (int i3 = i2 + 1; i3 < size; i3++) {
|
|
|
+ Ref<FinderPattern> p3 = possibleCenters[i3];
|
|
|
+ // Compare the expected module sizes; if they are really off, skip
|
|
|
+ float vModSize23 = (p2->getEstimatedModuleSize() - p3->getEstimatedModuleSize()) / std::min(p2->getEstimatedModuleSize(), p3->getEstimatedModuleSize());
|
|
|
+ float vModSize23A = abs(p2->getEstimatedModuleSize() - p3->getEstimatedModuleSize());
|
|
|
+ if (vModSize23A > DIFF_MODSIZE_CUTOFF && vModSize23 >= DIFF_MODSIZE_CUTOFF_PERCENT) {
|
|
|
+ // break, since elements are ordered by the module size deviation there cannot be
|
|
|
+ // any more interesting elements for the given p1.
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ std::vector<Ref<FinderPattern> > test;
|
|
|
+ test.push_back(p1);
|
|
|
+ test.push_back(p2);
|
|
|
+ test.push_back(p3);
|
|
|
+ FinderPatternFinder::orderBestPatterns(test);
|
|
|
+ // Calculate the distances: a = topleft-bottomleft, b=topleft-topright, c = diagonal
|
|
|
+ Ref<FinderPatternInfo> info = Ref<FinderPatternInfo>(new FinderPatternInfo(test));
|
|
|
+ float dA = FinderPatternFinder::distance(info->getTopLeft(), info->getBottomLeft());
|
|
|
+ float dC = FinderPatternFinder::distance(info->getTopRight(), info->getBottomLeft());
|
|
|
+ float dB = FinderPatternFinder::distance(info->getTopLeft(), info->getTopRight());
|
|
|
+ // Check the sizes
|
|
|
+ float estimatedModuleCount = (dA + dB) / (p1->getEstimatedModuleSize() * 2.0f);
|
|
|
+ if (estimatedModuleCount > MAX_MODULE_COUNT_PER_EDGE || estimatedModuleCount < MIN_MODULE_COUNT_PER_EDGE) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Calculate the difference of the edge lengths in percent
|
|
|
+ float vABBC = abs((dA - dB) / std::min(dA, dB));
|
|
|
+ if (vABBC >= 0.1f) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Calculate the diagonal length by assuming a 90° angle at topleft
|
|
|
+ float dCpy = (float) sqrt(dA * dA + dB * dB);
|
|
|
+ // Compare to the real distance in %
|
|
|
+ float vPyC = abs((dC - dCpy) / std::min(dC, dCpy));
|
|
|
+ if (vPyC >= 0.1f) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // All tests passed!
|
|
|
+ results.push_back(test);
|
|
|
+ } // end iterate p3
|
|
|
+ } // end iterate p2
|
|
|
+ } // end iterate p1
|
|
|
+ if (results.empty()){
|
|
|
+ // Nothing found!
|
|
|
+ throw ReaderException("No code detected");
|
|
|
+ }
|
|
|
+ return results;
|
|
|
+}
|
|
|
+
|
|
|
+} // End zxing::multi namespace
|
|
|
+} // End zxing namespace
|
|
|
+
|
|
|
+// file: zxing/oned/Code128Reader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 "Code128Reader.h"
|
|
|
+// #include <zxing/oned/OneDResultPoint.h>
|
|
|
+// #include <zxing/common/Array.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <math.h>
|
|
|
+// #include <string.h>
|
|
|
+// #include <sstream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ const int CODE_PATTERNS_LENGTH = 107;
|
|
|
+ const int countersLength = 6;
|
|
|
+ static const int CODE_PATTERNS[CODE_PATTERNS_LENGTH][countersLength] = {
|
|
|
+ {2, 1, 2, 2, 2, 2}, /* 0 */
|
|
|
+ {2, 2, 2, 1, 2, 2},
|
|
|
+ {2, 2, 2, 2, 2, 1},
|
|
|
+ {1, 2, 1, 2, 2, 3},
|
|
|
+ {1, 2, 1, 3, 2, 2},
|
|
|
+ {1, 3, 1, 2, 2, 2}, /* 5 */
|
|
|
+ {1, 2, 2, 2, 1, 3},
|
|
|
+ {1, 2, 2, 3, 1, 2},
|
|
|
+ {1, 3, 2, 2, 1, 2},
|
|
|
+ {2, 2, 1, 2, 1, 3},
|
|
|
+ {2, 2, 1, 3, 1, 2}, /* 10 */
|
|
|
+ {2, 3, 1, 2, 1, 2},
|
|
|
+ {1, 1, 2, 2, 3, 2},
|
|
|
+ {1, 2, 2, 1, 3, 2},
|
|
|
+ {1, 2, 2, 2, 3, 1},
|
|
|
+ {1, 1, 3, 2, 2, 2}, /* 15 */
|
|
|
+ {1, 2, 3, 1, 2, 2},
|
|
|
+ {1, 2, 3, 2, 2, 1},
|
|
|
+ {2, 2, 3, 2, 1, 1},
|
|
|
+ {2, 2, 1, 1, 3, 2},
|
|
|
+ {2, 2, 1, 2, 3, 1}, /* 20 */
|
|
|
+ {2, 1, 3, 2, 1, 2},
|
|
|
+ {2, 2, 3, 1, 1, 2},
|
|
|
+ {3, 1, 2, 1, 3, 1},
|
|
|
+ {3, 1, 1, 2, 2, 2},
|
|
|
+ {3, 2, 1, 1, 2, 2}, /* 25 */
|
|
|
+ {3, 2, 1, 2, 2, 1},
|
|
|
+ {3, 1, 2, 2, 1, 2},
|
|
|
+ {3, 2, 2, 1, 1, 2},
|
|
|
+ {3, 2, 2, 2, 1, 1},
|
|
|
+ {2, 1, 2, 1, 2, 3}, /* 30 */
|
|
|
+ {2, 1, 2, 3, 2, 1},
|
|
|
+ {2, 3, 2, 1, 2, 1},
|
|
|
+ {1, 1, 1, 3, 2, 3},
|
|
|
+ {1, 3, 1, 1, 2, 3},
|
|
|
+ {1, 3, 1, 3, 2, 1}, /* 35 */
|
|
|
+ {1, 1, 2, 3, 1, 3},
|
|
|
+ {1, 3, 2, 1, 1, 3},
|
|
|
+ {1, 3, 2, 3, 1, 1},
|
|
|
+ {2, 1, 1, 3, 1, 3},
|
|
|
+ {2, 3, 1, 1, 1, 3}, /* 40 */
|
|
|
+ {2, 3, 1, 3, 1, 1},
|
|
|
+ {1, 1, 2, 1, 3, 3},
|
|
|
+ {1, 1, 2, 3, 3, 1},
|
|
|
+ {1, 3, 2, 1, 3, 1},
|
|
|
+ {1, 1, 3, 1, 2, 3}, /* 45 */
|
|
|
+ {1, 1, 3, 3, 2, 1},
|
|
|
+ {1, 3, 3, 1, 2, 1},
|
|
|
+ {3, 1, 3, 1, 2, 1},
|
|
|
+ {2, 1, 1, 3, 3, 1},
|
|
|
+ {2, 3, 1, 1, 3, 1}, /* 50 */
|
|
|
+ {2, 1, 3, 1, 1, 3},
|
|
|
+ {2, 1, 3, 3, 1, 1},
|
|
|
+ {2, 1, 3, 1, 3, 1},
|
|
|
+ {3, 1, 1, 1, 2, 3},
|
|
|
+ {3, 1, 1, 3, 2, 1}, /* 55 */
|
|
|
+ {3, 3, 1, 1, 2, 1},
|
|
|
+ {3, 1, 2, 1, 1, 3},
|
|
|
+ {3, 1, 2, 3, 1, 1},
|
|
|
+ {3, 3, 2, 1, 1, 1},
|
|
|
+ {3, 1, 4, 1, 1, 1}, /* 60 */
|
|
|
+ {2, 2, 1, 4, 1, 1},
|
|
|
+ {4, 3, 1, 1, 1, 1},
|
|
|
+ {1, 1, 1, 2, 2, 4},
|
|
|
+ {1, 1, 1, 4, 2, 2},
|
|
|
+ {1, 2, 1, 1, 2, 4}, /* 65 */
|
|
|
+ {1, 2, 1, 4, 2, 1},
|
|
|
+ {1, 4, 1, 1, 2, 2},
|
|
|
+ {1, 4, 1, 2, 2, 1},
|
|
|
+ {1, 1, 2, 2, 1, 4},
|
|
|
+ {1, 1, 2, 4, 1, 2}, /* 70 */
|
|
|
+ {1, 2, 2, 1, 1, 4},
|
|
|
+ {1, 2, 2, 4, 1, 1},
|
|
|
+ {1, 4, 2, 1, 1, 2},
|
|
|
+ {1, 4, 2, 2, 1, 1},
|
|
|
+ {2, 4, 1, 2, 1, 1}, /* 75 */
|
|
|
+ {2, 2, 1, 1, 1, 4},
|
|
|
+ {4, 1, 3, 1, 1, 1},
|
|
|
+ {2, 4, 1, 1, 1, 2},
|
|
|
+ {1, 3, 4, 1, 1, 1},
|
|
|
+ {1, 1, 1, 2, 4, 2}, /* 80 */
|
|
|
+ {1, 2, 1, 1, 4, 2},
|
|
|
+ {1, 2, 1, 2, 4, 1},
|
|
|
+ {1, 1, 4, 2, 1, 2},
|
|
|
+ {1, 2, 4, 1, 1, 2},
|
|
|
+ {1, 2, 4, 2, 1, 1}, /* 85 */
|
|
|
+ {4, 1, 1, 2, 1, 2},
|
|
|
+ {4, 2, 1, 1, 1, 2},
|
|
|
+ {4, 2, 1, 2, 1, 1},
|
|
|
+ {2, 1, 2, 1, 4, 1},
|
|
|
+ {2, 1, 4, 1, 2, 1}, /* 90 */
|
|
|
+ {4, 1, 2, 1, 2, 1},
|
|
|
+ {1, 1, 1, 1, 4, 3},
|
|
|
+ {1, 1, 1, 3, 4, 1},
|
|
|
+ {1, 3, 1, 1, 4, 1},
|
|
|
+ {1, 1, 4, 1, 1, 3}, /* 95 */
|
|
|
+ {1, 1, 4, 3, 1, 1},
|
|
|
+ {4, 1, 1, 1, 1, 3},
|
|
|
+ {4, 1, 1, 3, 1, 1},
|
|
|
+ {1, 1, 3, 1, 4, 1},
|
|
|
+ {1, 1, 4, 1, 3, 1}, /* 100 */
|
|
|
+ {3, 1, 1, 1, 4, 1},
|
|
|
+ {4, 1, 1, 1, 3, 1},
|
|
|
+ {2, 1, 1, 4, 1, 2},
|
|
|
+ {2, 1, 1, 2, 1, 4},
|
|
|
+ {2, 1, 1, 2, 3, 2}, /* 105 */
|
|
|
+ {2, 3, 3, 1, 1, 1}
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ Code128Reader::Code128Reader(){
|
|
|
+ }
|
|
|
+
|
|
|
+ int* Code128Reader::findStartPattern(Ref<BitArray> row){
|
|
|
+ int width = row->getSize();
|
|
|
+ int rowOffset = 0;
|
|
|
+ while (rowOffset < width) {
|
|
|
+ if (row->get(rowOffset)) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ rowOffset++;
|
|
|
+ }
|
|
|
+
|
|
|
+ int counterPosition = 0;
|
|
|
+ int counters[countersLength] = {0,0,0,0,0,0};
|
|
|
+ int patternStart = rowOffset;
|
|
|
+ bool isWhite = false;
|
|
|
+ int patternLength = sizeof(counters) / sizeof(int);
|
|
|
+
|
|
|
+ for (int i = rowOffset; i < width; i++) {
|
|
|
+ bool pixel = row->get(i);
|
|
|
+ if (pixel ^ isWhite) {
|
|
|
+ counters[counterPosition]++;
|
|
|
+ } else {
|
|
|
+ if (counterPosition == patternLength - 1) {
|
|
|
+ unsigned int bestVariance = MAX_AVG_VARIANCE;
|
|
|
+ int bestMatch = -1;
|
|
|
+ for (int startCode = CODE_START_A; startCode <= CODE_START_C; startCode++) {
|
|
|
+ unsigned int variance = patternMatchVariance(counters, sizeof(counters) / sizeof(int),
|
|
|
+ CODE_PATTERNS[startCode], MAX_INDIVIDUAL_VARIANCE);
|
|
|
+ if (variance < bestVariance) {
|
|
|
+ bestVariance = variance;
|
|
|
+ bestMatch = startCode;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (bestMatch >= 0) {
|
|
|
+ // Look for whitespace before start pattern, >= 50% of width of start pattern
|
|
|
+ if (row->isRange(std::max(0, patternStart - (i - patternStart) / 2), patternStart,
|
|
|
+ false)) {
|
|
|
+ int* resultValue = new int[3];
|
|
|
+ resultValue[0] = patternStart;
|
|
|
+ resultValue[1] = i;
|
|
|
+ resultValue[2] = bestMatch;
|
|
|
+ return resultValue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ patternStart += counters[0] + counters[1];
|
|
|
+ for (int y = 2; y < patternLength; y++) {
|
|
|
+ counters[y - 2] = counters[y];
|
|
|
+ }
|
|
|
+ counters[patternLength - 2] = 0;
|
|
|
+ counters[patternLength - 1] = 0;
|
|
|
+ counterPosition--;
|
|
|
+ } else {
|
|
|
+ counterPosition++;
|
|
|
+ }
|
|
|
+ counters[counterPosition] = 1;
|
|
|
+ isWhite = !isWhite;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ int Code128Reader::decodeCode(Ref<BitArray> row, int counters[], int countersCount,
|
|
|
+ int rowOffset) {
|
|
|
+ if (!recordPattern(row, rowOffset, counters, countersCount)) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ unsigned int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
|
|
|
+ int bestMatch = -1;
|
|
|
+ for (int d = 0; d < CODE_PATTERNS_LENGTH; d++) {
|
|
|
+ int pattern[countersLength];
|
|
|
+
|
|
|
+ for(int ind = 0; ind< countersLength; ind++){
|
|
|
+ pattern[ind] = CODE_PATTERNS[d][ind];
|
|
|
+ }
|
|
|
+// memcpy(pattern, CODE_PATTERNS[d], countersLength);
|
|
|
+ unsigned int variance = patternMatchVariance(counters, countersCount, pattern,
|
|
|
+ MAX_INDIVIDUAL_VARIANCE);
|
|
|
+ if (variance < bestVariance) {
|
|
|
+ bestVariance = variance;
|
|
|
+ bestMatch = d;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // TODO We're overlooking the fact that the STOP pattern has 7 values, not 6.
|
|
|
+ if (bestMatch >= 0) {
|
|
|
+ return bestMatch;
|
|
|
+ } else {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> Code128Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
|
|
|
+ int* startPatternInfo = NULL;
|
|
|
+ try {
|
|
|
+ startPatternInfo = findStartPattern(row);
|
|
|
+ int startCode = startPatternInfo[2];
|
|
|
+ int codeSet;
|
|
|
+ switch (startCode) {
|
|
|
+ case CODE_START_A:
|
|
|
+ codeSet = CODE_CODE_A;
|
|
|
+ break;
|
|
|
+ case CODE_START_B:
|
|
|
+ codeSet = CODE_CODE_B;
|
|
|
+ break;
|
|
|
+ case CODE_START_C:
|
|
|
+ codeSet = CODE_CODE_C;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ bool done = false;
|
|
|
+ bool isNextShifted = false;
|
|
|
+
|
|
|
+ std::string tmpResultString;
|
|
|
+ std::stringstream tmpResultSStr; // used if its Code 128C
|
|
|
+
|
|
|
+ int lastStart = startPatternInfo[0];
|
|
|
+ int nextStart = startPatternInfo[1];
|
|
|
+ int counters[countersLength] = {0,0,0,0,0,0};
|
|
|
+
|
|
|
+ int lastCode = 0;
|
|
|
+ int code = 0;
|
|
|
+ int checksumTotal = startCode;
|
|
|
+ int multiplier = 0;
|
|
|
+ bool lastCharacterWasPrintable = true;
|
|
|
+
|
|
|
+ while (!done) {
|
|
|
+ bool unshift = isNextShifted;
|
|
|
+ isNextShifted = false;
|
|
|
+
|
|
|
+ // Save off last code
|
|
|
+ lastCode = code;
|
|
|
+
|
|
|
+ // Decode another code from image
|
|
|
+ try {
|
|
|
+ code = decodeCode(row, counters, sizeof(counters)/sizeof(int), nextStart);
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ throw re;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Remember whether the last code was printable or not (excluding CODE_STOP)
|
|
|
+ if (code != CODE_STOP) {
|
|
|
+ lastCharacterWasPrintable = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Add to checksum computation (if not CODE_STOP of course)
|
|
|
+ if (code != CODE_STOP) {
|
|
|
+ multiplier++;
|
|
|
+ checksumTotal += multiplier * code;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Advance to where the next code will to start
|
|
|
+ lastStart = nextStart;
|
|
|
+ int _countersLength = sizeof(counters) / sizeof(int);
|
|
|
+ for (int i = 0; i < _countersLength; i++) {
|
|
|
+ nextStart += counters[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ // Take care of illegal start codes
|
|
|
+ switch (code) {
|
|
|
+ case CODE_START_A:
|
|
|
+ case CODE_START_B:
|
|
|
+ case CODE_START_C:
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (codeSet) {
|
|
|
+
|
|
|
+ case CODE_CODE_A:
|
|
|
+ if (code < 64) {
|
|
|
+ tmpResultString.append(1, (char) (' ' + code));
|
|
|
+ } else if (code < 96) {
|
|
|
+ tmpResultString.append(1, (char) (code - 64));
|
|
|
+ } else {
|
|
|
+ // Don't let CODE_STOP, which always appears, affect whether whether we think the
|
|
|
+ // last code was printable or not.
|
|
|
+ if (code != CODE_STOP) {
|
|
|
+ lastCharacterWasPrintable = false;
|
|
|
+ }
|
|
|
+ switch (code) {
|
|
|
+ case CODE_FNC_1:
|
|
|
+ case CODE_FNC_2:
|
|
|
+ case CODE_FNC_3:
|
|
|
+ case CODE_FNC_4_A:
|
|
|
+ // do nothing?
|
|
|
+ break;
|
|
|
+ case CODE_SHIFT:
|
|
|
+ isNextShifted = true;
|
|
|
+ codeSet = CODE_CODE_B;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_B:
|
|
|
+ codeSet = CODE_CODE_B;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_C:
|
|
|
+ codeSet = CODE_CODE_C;
|
|
|
+ break;
|
|
|
+ case CODE_STOP:
|
|
|
+ done = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case CODE_CODE_B:
|
|
|
+ if (code < 96) {
|
|
|
+ tmpResultString.append(1, (char) (' ' + code));
|
|
|
+ } else {
|
|
|
+ if (code != CODE_STOP) {
|
|
|
+ lastCharacterWasPrintable = false;
|
|
|
+ }
|
|
|
+ switch (code) {
|
|
|
+ case CODE_FNC_1:
|
|
|
+ case CODE_FNC_2:
|
|
|
+ case CODE_FNC_3:
|
|
|
+ case CODE_FNC_4_B:
|
|
|
+ // do nothing?
|
|
|
+ break;
|
|
|
+ case CODE_SHIFT:
|
|
|
+ isNextShifted = true;
|
|
|
+ codeSet = CODE_CODE_C;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_A:
|
|
|
+ codeSet = CODE_CODE_A;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_C:
|
|
|
+ codeSet = CODE_CODE_C;
|
|
|
+ break;
|
|
|
+ case CODE_STOP:
|
|
|
+ done = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case CODE_CODE_C:
|
|
|
+ tmpResultSStr.str(std::string());
|
|
|
+ // the code read in this case is the number encoded directly
|
|
|
+ if (code < 100) {
|
|
|
+ if (code < 10) {
|
|
|
+ tmpResultSStr << '0';
|
|
|
+ }
|
|
|
+ tmpResultSStr << code;
|
|
|
+ tmpResultString.append(tmpResultSStr.str());
|
|
|
+ } else {
|
|
|
+ if (code != CODE_STOP) {
|
|
|
+ lastCharacterWasPrintable = false;
|
|
|
+ }
|
|
|
+ switch (code) {
|
|
|
+ case CODE_FNC_1:
|
|
|
+ // do nothing?
|
|
|
+ break;
|
|
|
+ case CODE_CODE_A:
|
|
|
+ codeSet = CODE_CODE_A;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_B:
|
|
|
+ codeSet = CODE_CODE_B;
|
|
|
+ break;
|
|
|
+ case CODE_STOP:
|
|
|
+ done = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Unshift back to another code set if we were shifted
|
|
|
+ if (unshift) {
|
|
|
+ switch (codeSet) {
|
|
|
+ case CODE_CODE_A:
|
|
|
+ codeSet = CODE_CODE_C;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_B:
|
|
|
+ codeSet = CODE_CODE_A;
|
|
|
+ break;
|
|
|
+ case CODE_CODE_C:
|
|
|
+ codeSet = CODE_CODE_B;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Check for ample whitespace following pattern, but, to do this we first need to remember that
|
|
|
+ // we fudged decoding CODE_STOP since it actually has 7 bars, not 6. There is a black bar left
|
|
|
+ // to read off. Would be slightly better to properly read. Here we just skip it:
|
|
|
+ int width = row->getSize();
|
|
|
+ while (nextStart < width && row->get(nextStart)) {
|
|
|
+ nextStart++;
|
|
|
+ }
|
|
|
+ if (!row->isRange(nextStart,
|
|
|
+ std::min(width, nextStart + (nextStart - lastStart) / 2),
|
|
|
+ false)) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Pull out from sum the value of the penultimate check code
|
|
|
+ checksumTotal -= multiplier * lastCode;
|
|
|
+ // lastCode is the checksum then:
|
|
|
+ if (checksumTotal % 103 != lastCode) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Need to pull out the check digits from string
|
|
|
+ int resultLength = tmpResultString.length();
|
|
|
+ // Only bother if the result had at least one character, and if the checksum digit happened to
|
|
|
+ // be a printable character. If it was just interpreted as a control code, nothing to remove.
|
|
|
+ if (resultLength > 0 && lastCharacterWasPrintable) {
|
|
|
+ if (codeSet == CODE_CODE_C) {
|
|
|
+ tmpResultString.erase(resultLength - 2, resultLength);
|
|
|
+ } else {
|
|
|
+ tmpResultString.erase(resultLength - 1, resultLength);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<String> resultString(new String(tmpResultString));
|
|
|
+ if (tmpResultString.length() == 0) {
|
|
|
+ // Almost surely a false positive
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ float left = (float) (startPatternInfo[1] + startPatternInfo[0]) / 2.0f;
|
|
|
+ float right = (float) (nextStart + lastStart) / 2.0f;
|
|
|
+
|
|
|
+ std::vector< Ref<ResultPoint> > resultPoints(2);
|
|
|
+ Ref<OneDResultPoint> resultPoint1(new OneDResultPoint(left, (float) rowNumber));
|
|
|
+ Ref<OneDResultPoint> resultPoint2(new OneDResultPoint(right, (float) rowNumber));
|
|
|
+ resultPoints[0] = resultPoint1;
|
|
|
+ resultPoints[1] = resultPoint2;
|
|
|
+
|
|
|
+ delete [] startPatternInfo;
|
|
|
+ ArrayRef<unsigned char> resultBytes(1);
|
|
|
+ return Ref<Result>(new Result(resultString, resultBytes, resultPoints,
|
|
|
+ BarcodeFormat_CODE_128));
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ delete [] startPatternInfo;
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void Code128Reader::append(char* s, char c){
|
|
|
+ int len = strlen(s);
|
|
|
+ s[len] = c;
|
|
|
+ s[len + 1] = '\0';
|
|
|
+ }
|
|
|
+
|
|
|
+ Code128Reader::~Code128Reader(){
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/Code39Reader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 "Code39Reader.h"
|
|
|
+// #include <zxing/oned/OneDResultPoint.h>
|
|
|
+// #include <zxing/common/Array.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <math.h>
|
|
|
+// #include <limits.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace oned {
|
|
|
+
|
|
|
+ static const char* ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * These represent the encodings of characters, as patterns of wide and narrow
|
|
|
+ * bars.
|
|
|
+ * The 9 least-significant bits of each int correspond to the pattern of wide
|
|
|
+ * and narrow, with 1s representing "wide" and 0s representing narrow.
|
|
|
+ */
|
|
|
+ const int CHARACTER_ENCODINGS_LEN = 44;
|
|
|
+ static int CHARACTER_ENCODINGS[CHARACTER_ENCODINGS_LEN] = {
|
|
|
+ 0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9
|
|
|
+ 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J
|
|
|
+ 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T
|
|
|
+ 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x094, // U-*
|
|
|
+ 0x0A8, 0x0A2, 0x08A, 0x02A // $-%
|
|
|
+ };
|
|
|
+
|
|
|
+ static int ASTERISK_ENCODING = 0x094;
|
|
|
+ static const char* ALPHABET_STRING =
|
|
|
+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. *$/+%";
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a reader that assumes all encoded data is data, and does not treat
|
|
|
+ * the final character as a check digit. It will not decoded "extended
|
|
|
+ * Code 39" sequences.
|
|
|
+ */
|
|
|
+ Code39Reader::Code39Reader() : alphabet_string(ALPHABET_STRING),
|
|
|
+ usingCheckDigit(false),
|
|
|
+ extendedMode(false) {
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a reader that can be configured to check the last character as a
|
|
|
+ * check digit. It will not decoded "extended Code 39" sequences.
|
|
|
+ *
|
|
|
+ * @param usingCheckDigit if true, treat the last data character as a check
|
|
|
+ * digit, not data, and verify that the checksum passes.
|
|
|
+ */
|
|
|
+ Code39Reader::Code39Reader(bool usingCheckDigit_) :
|
|
|
+ alphabet_string(ALPHABET_STRING),
|
|
|
+ usingCheckDigit(usingCheckDigit_),
|
|
|
+ extendedMode(false) {
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ Code39Reader::Code39Reader(bool usingCheckDigit_, bool extendedMode_) :
|
|
|
+ alphabet_string(ALPHABET_STRING),
|
|
|
+ usingCheckDigit(usingCheckDigit_),
|
|
|
+ extendedMode(extendedMode_) {
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> Code39Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
|
|
|
+ int* start = NULL;
|
|
|
+ try {
|
|
|
+ start = findAsteriskPattern(row);
|
|
|
+ int nextStart = start[1];
|
|
|
+ int end = row->getSize();
|
|
|
+
|
|
|
+ // Read off white space
|
|
|
+ while (nextStart < end && !row->get(nextStart)) {
|
|
|
+ nextStart++;
|
|
|
+ }
|
|
|
+
|
|
|
+ std::string tmpResultString;
|
|
|
+
|
|
|
+ const int countersLen = 9;
|
|
|
+ int counters[countersLen];
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ counters[i] = 0;
|
|
|
+ }
|
|
|
+ char decodedChar;
|
|
|
+ int lastStart;
|
|
|
+ do {
|
|
|
+ if (!recordPattern(row, nextStart, counters, countersLen)) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ int pattern = toNarrowWidePattern(counters, countersLen);
|
|
|
+ if (pattern < 0) {
|
|
|
+ throw ReaderException("pattern < 0");
|
|
|
+ }
|
|
|
+ decodedChar = patternToChar(pattern);
|
|
|
+ tmpResultString.append(1, decodedChar);
|
|
|
+ lastStart = nextStart;
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ nextStart += counters[i];
|
|
|
+ }
|
|
|
+ // Read off white space
|
|
|
+ while (nextStart < end && !row->get(nextStart)) {
|
|
|
+ nextStart++;
|
|
|
+ }
|
|
|
+ } while (decodedChar != '*');
|
|
|
+ tmpResultString.erase(tmpResultString.length()-1, 1);// remove asterisk
|
|
|
+
|
|
|
+ // Look for whitespace after pattern:
|
|
|
+ int lastPatternSize = 0;
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ lastPatternSize += counters[i];
|
|
|
+ }
|
|
|
+ int whiteSpaceAfterEnd = nextStart - lastStart - lastPatternSize;
|
|
|
+ // If 50% of last pattern size, following last pattern, is not whitespace,
|
|
|
+ // fail (but if it's whitespace to the very end of the image, that's OK)
|
|
|
+ if (nextStart != end && whiteSpaceAfterEnd / 2 < lastPatternSize) {
|
|
|
+ throw ReaderException("too short end white space");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (usingCheckDigit) {
|
|
|
+ int max = tmpResultString.length() - 1;
|
|
|
+ unsigned int total = 0;
|
|
|
+ for (int i = 0; i < max; i++) {
|
|
|
+ total += alphabet_string.find_first_of(tmpResultString[i], 0);
|
|
|
+ }
|
|
|
+ if (total % 43 != alphabet_string.find_first_of(tmpResultString[max], 0)) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ tmpResultString.erase(max, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<String> resultString(new String(tmpResultString));
|
|
|
+ if (extendedMode) {
|
|
|
+ resultString = decodeExtended(tmpResultString);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (tmpResultString.length() == 0) {
|
|
|
+ // Almost surely a false positive
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ float left = (float) (start[1] + start[0]) / 2.0f;
|
|
|
+ float right = (float) (nextStart + lastStart) / 2.0f;
|
|
|
+
|
|
|
+ std::vector< Ref<ResultPoint> > resultPoints(2);
|
|
|
+ Ref<OneDResultPoint> resultPoint1(
|
|
|
+ new OneDResultPoint(left, (float) rowNumber));
|
|
|
+ Ref<OneDResultPoint> resultPoint2(
|
|
|
+ new OneDResultPoint(right, (float) rowNumber));
|
|
|
+ resultPoints[0] = resultPoint1;
|
|
|
+ resultPoints[1] = resultPoint2;
|
|
|
+
|
|
|
+ ArrayRef<unsigned char> resultBytes(1);
|
|
|
+
|
|
|
+ Ref<Result> res(new Result(
|
|
|
+ resultString, resultBytes, resultPoints, BarcodeFormat_CODE_39));
|
|
|
+
|
|
|
+ delete [] start;
|
|
|
+ return res;
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ delete [] start;
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int* Code39Reader::findAsteriskPattern(Ref<BitArray> row){
|
|
|
+ int width = row->getSize();
|
|
|
+ int rowOffset = 0;
|
|
|
+ while (rowOffset < width) {
|
|
|
+ if (row->get(rowOffset)) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ rowOffset++;
|
|
|
+ }
|
|
|
+
|
|
|
+ int counterPosition = 0;
|
|
|
+ const int countersLen = 9;
|
|
|
+ int counters[countersLen];
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ counters[i] = 0;
|
|
|
+ }
|
|
|
+ int patternStart = rowOffset;
|
|
|
+ bool isWhite = false;
|
|
|
+ int patternLength = countersLen;
|
|
|
+
|
|
|
+ for (int i = rowOffset; i < width; i++) {
|
|
|
+ bool pixel = row->get(i);
|
|
|
+ if (pixel ^ isWhite) {
|
|
|
+ counters[counterPosition]++;
|
|
|
+ } else {
|
|
|
+ if (counterPosition == patternLength - 1) {
|
|
|
+ if (toNarrowWidePattern(counters, countersLen) == ASTERISK_ENCODING) {
|
|
|
+ // Look for whitespace before start pattern, >= 50% of width of
|
|
|
+ // start pattern.
|
|
|
+ if (row->isRange(std::max(0, patternStart - ((i - patternStart) >> 1)), patternStart, false)) {
|
|
|
+ int* resultValue = new int[2];
|
|
|
+ resultValue[0] = patternStart;
|
|
|
+ resultValue[1] = i;
|
|
|
+ return resultValue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ patternStart += counters[0] + counters[1];
|
|
|
+ for (int y = 2; y < patternLength; y++) {
|
|
|
+ counters[y - 2] = counters[y];
|
|
|
+ }
|
|
|
+ counters[patternLength - 2] = 0;
|
|
|
+ counters[patternLength - 1] = 0;
|
|
|
+ counterPosition--;
|
|
|
+ } else {
|
|
|
+ counterPosition++;
|
|
|
+ }
|
|
|
+ counters[counterPosition] = 1;
|
|
|
+ isWhite = !isWhite;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ // For efficiency, returns -1 on failure. Not throwing here saved as many as
|
|
|
+ // 700 exceptions per image when using some of our blackbox images.
|
|
|
+ int Code39Reader::toNarrowWidePattern(int counters[], int countersLen){
|
|
|
+ int numCounters = countersLen;
|
|
|
+ int maxNarrowCounter = 0;
|
|
|
+ int wideCounters;
|
|
|
+ do {
|
|
|
+ int minCounter = INT_MAX;
|
|
|
+ for (int i = 0; i < numCounters; i++) {
|
|
|
+ int counter = counters[i];
|
|
|
+ if (counter < minCounter && counter > maxNarrowCounter) {
|
|
|
+ minCounter = counter;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ maxNarrowCounter = minCounter;
|
|
|
+ wideCounters = 0;
|
|
|
+ int totalWideCountersWidth = 0;
|
|
|
+ int pattern = 0;
|
|
|
+ for (int i = 0; i < numCounters; i++) {
|
|
|
+ int counter = counters[i];
|
|
|
+ if (counters[i] > maxNarrowCounter) {
|
|
|
+ pattern |= 1 << (numCounters - 1 - i);
|
|
|
+ wideCounters++;
|
|
|
+ totalWideCountersWidth += counter;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (wideCounters == 3) {
|
|
|
+ // Found 3 wide counters, but are they close enough in width?
|
|
|
+ // We can perform a cheap, conservative check to see if any individual
|
|
|
+ // counter is more than 1.5 times the average:
|
|
|
+ for (int i = 0; i < numCounters && wideCounters > 0; i++) {
|
|
|
+ int counter = counters[i];
|
|
|
+ if (counters[i] > maxNarrowCounter) {
|
|
|
+ wideCounters--;
|
|
|
+ // totalWideCountersWidth = 3 * average, so this checks if
|
|
|
+ // counter >= 3/2 * average.
|
|
|
+ if ((counter << 1) >= totalWideCountersWidth) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return pattern;
|
|
|
+ }
|
|
|
+ } while (wideCounters > 3);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ char Code39Reader::patternToChar(int pattern){
|
|
|
+ for (int i = 0; i < CHARACTER_ENCODINGS_LEN; i++) {
|
|
|
+ if (CHARACTER_ENCODINGS[i] == pattern) {
|
|
|
+ return ALPHABET[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<String> Code39Reader::decodeExtended(std::string encoded){
|
|
|
+ int length = encoded.length();
|
|
|
+ std::string tmpDecoded;
|
|
|
+ for (int i = 0; i < length; i++) {
|
|
|
+ char c = encoded[i];
|
|
|
+ if (c == '+' || c == '$' || c == '%' || c == '/') {
|
|
|
+ char next = encoded[i + 1];
|
|
|
+ char decodedChar = '\0';
|
|
|
+ switch (c) {
|
|
|
+ case '+':
|
|
|
+ // +A to +Z map to a to z
|
|
|
+ if (next >= 'A' && next <= 'Z') {
|
|
|
+ decodedChar = (char) (next + 32);
|
|
|
+ } else {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case '$':
|
|
|
+ // $A to $Z map to control codes SH to SB
|
|
|
+ if (next >= 'A' && next <= 'Z') {
|
|
|
+ decodedChar = (char) (next - 64);
|
|
|
+ } else {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case '%':
|
|
|
+ // %A to %E map to control codes ESC to US
|
|
|
+ if (next >= 'A' && next <= 'E') {
|
|
|
+ decodedChar = (char) (next - 38);
|
|
|
+ } else if (next >= 'F' && next <= 'W') {
|
|
|
+ decodedChar = (char) (next - 11);
|
|
|
+ } else {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case '/':
|
|
|
+ // /A to /O map to ! to , and /Z maps to :
|
|
|
+ if (next >= 'A' && next <= 'O') {
|
|
|
+ decodedChar = (char) (next - 32);
|
|
|
+ } else if (next == 'Z') {
|
|
|
+ decodedChar = ':';
|
|
|
+ } else {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ tmpDecoded.append(1, decodedChar);
|
|
|
+ // bump up i again since we read two characters
|
|
|
+ i++;
|
|
|
+ } else {
|
|
|
+ tmpDecoded.append(1, c);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ref<String> decoded(new String(tmpDecoded));
|
|
|
+ return decoded;
|
|
|
+ }
|
|
|
+} // namespace oned
|
|
|
+} // namespace zxing
|
|
|
+
|
|
|
+
|
|
|
+// file: zxing/oned/EAN13Reader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 "EAN13Reader.h"
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ static const int FIRST_DIGIT_ENCODINGS[10] = {
|
|
|
+ 0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A
|
|
|
+ };
|
|
|
+
|
|
|
+ EAN13Reader::EAN13Reader() { }
|
|
|
+
|
|
|
+ int EAN13Reader::decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
|
|
|
+ std::string& resultString) {
|
|
|
+ (void)startGuardBegin;
|
|
|
+ const int countersLen = 4;
|
|
|
+ int counters[countersLen] = { 0, 0, 0, 0 };
|
|
|
+
|
|
|
+ int end = row->getSize();
|
|
|
+ int rowOffset = startGuardEnd;
|
|
|
+ int lgPatternFound = 0;
|
|
|
+
|
|
|
+ for (int x = 0; x < 6 && rowOffset < end; x++) {
|
|
|
+ int bestMatch = decodeDigit(row, counters, countersLen, rowOffset,
|
|
|
+ UPC_EAN_PATTERNS_L_AND_G_PATTERNS);
|
|
|
+ if (bestMatch < 0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch % 10));
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ rowOffset += counters[i];
|
|
|
+ }
|
|
|
+ if (bestMatch >= 10) {
|
|
|
+ lgPatternFound |= 1 << (5 - x);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!determineFirstDigit(resultString, lgPatternFound)) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ int middleRangeStart;
|
|
|
+ int middleRangeEnd;
|
|
|
+ if (findGuardPattern(row, rowOffset, true, (int*)getMIDDLE_PATTERN(),
|
|
|
+ getMIDDLE_PATTERN_LEN(), &middleRangeStart, &middleRangeEnd)) {
|
|
|
+ rowOffset = middleRangeEnd;
|
|
|
+ for (int x = 0; x < 6 && rowOffset < end; x++) {
|
|
|
+ int bestMatch = decodeDigit(row, counters, countersLen, rowOffset,
|
|
|
+ UPC_EAN_PATTERNS_L_PATTERNS);
|
|
|
+ if (bestMatch < 0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch));
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ rowOffset += counters[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return rowOffset;
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool EAN13Reader::determineFirstDigit(std::string& resultString, int lgPatternFound) {
|
|
|
+ for (int d = 0; d < 10; d++) {
|
|
|
+ if (lgPatternFound == FIRST_DIGIT_ENCODINGS[d]) {
|
|
|
+ resultString.insert(0, 1, (char) ('0' + d));
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ BarcodeFormat EAN13Reader::getBarcodeFormat(){
|
|
|
+ return BarcodeFormat_EAN_13;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/EAN8Reader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 "EAN8Reader.h"
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ EAN8Reader::EAN8Reader(){ }
|
|
|
+
|
|
|
+ int EAN8Reader::decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
|
|
|
+ std::string& resultString){
|
|
|
+ (void)startGuardBegin;
|
|
|
+ const int countersLen = 4;
|
|
|
+ int counters[countersLen] = { 0, 0, 0, 0 };
|
|
|
+
|
|
|
+ int end = row->getSize();
|
|
|
+ int rowOffset = startGuardEnd;
|
|
|
+
|
|
|
+ for (int x = 0; x < 4 && rowOffset < end; x++) {
|
|
|
+ int bestMatch = decodeDigit(row, counters, countersLen, rowOffset,
|
|
|
+ UPC_EAN_PATTERNS_L_PATTERNS);
|
|
|
+ if (bestMatch < 0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch));
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ rowOffset += counters[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int middleRangeStart;
|
|
|
+ int middleRangeEnd;
|
|
|
+ if (findGuardPattern(row, rowOffset, true, (int*)getMIDDLE_PATTERN(),
|
|
|
+ getMIDDLE_PATTERN_LEN(), &middleRangeStart, &middleRangeEnd)) {
|
|
|
+ rowOffset = middleRangeEnd;
|
|
|
+ for (int x = 0; x < 4 && rowOffset < end; x++) {
|
|
|
+ int bestMatch = decodeDigit(row, counters, countersLen, rowOffset,
|
|
|
+ UPC_EAN_PATTERNS_L_PATTERNS);
|
|
|
+ if (bestMatch < 0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch));
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ rowOffset += counters[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return rowOffset;
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ BarcodeFormat EAN8Reader::getBarcodeFormat(){
|
|
|
+ return BarcodeFormat_EAN_8;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/ITFReader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 "ITFReader.h"
|
|
|
+// #include <zxing/oned/OneDResultPoint.h>
|
|
|
+// #include <zxing/common/Array.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <math.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ static const int W = 3; // Pixel width of a wide line
|
|
|
+ static const int N = 1; // Pixed width of a narrow line
|
|
|
+
|
|
|
+ const int DEFAULT_ALLOWED_LENGTHS_LEN = 10;
|
|
|
+ const int DEFAULT_ALLOWED_LENGTHS[DEFAULT_ALLOWED_LENGTHS_LEN] = { 44, 24, 20, 18, 16, 14, 12, 10, 8, 6 };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Start/end guard pattern.
|
|
|
+ *
|
|
|
+ * Note: The end pattern is reversed because the row is reversed before
|
|
|
+ * searching for the END_PATTERN
|
|
|
+ */
|
|
|
+ static const int START_PATTERN_LEN = 4;
|
|
|
+ static const int START_PATTERN[START_PATTERN_LEN] = {N, N, N, N};
|
|
|
+
|
|
|
+ static const int END_PATTERN_REVERSED_LEN = 3;
|
|
|
+ static const int END_PATTERN_REVERSED[END_PATTERN_REVERSED_LEN] = {N, N, W};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Patterns of Wide / Narrow lines to indicate each digit
|
|
|
+ */
|
|
|
+ static const int PATTERNS_LEN = 10;
|
|
|
+ static const int PATTERNS[PATTERNS_LEN][5] = {
|
|
|
+ {N, N, W, W, N}, // 0
|
|
|
+ {W, N, N, N, W}, // 1
|
|
|
+ {N, W, N, N, W}, // 2
|
|
|
+ {W, W, N, N, N}, // 3
|
|
|
+ {N, N, W, N, W}, // 4
|
|
|
+ {W, N, W, N, N}, // 5
|
|
|
+ {N, W, W, N, N}, // 6
|
|
|
+ {N, N, N, W, W}, // 7
|
|
|
+ {W, N, N, W, N}, // 8
|
|
|
+ {N, W, N, W, N} // 9
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ ITFReader::ITFReader() : narrowLineWidth(-1) {
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ Ref<Result> ITFReader::decodeRow(int rowNumber, Ref<BitArray> row) {
|
|
|
+ int* startRange = 0;
|
|
|
+ int* endRange = 0;
|
|
|
+ try {
|
|
|
+ // Find out where the Middle section (payload) starts & ends
|
|
|
+ startRange = decodeStart(row);
|
|
|
+ endRange = decodeEnd(row);
|
|
|
+
|
|
|
+ std::string tmpResult;
|
|
|
+ decodeMiddle(row, startRange[1], endRange[0], tmpResult);
|
|
|
+
|
|
|
+ // To avoid false positives with 2D barcodes (and other patterns), make
|
|
|
+ // an assumption that the decoded string must be a known length
|
|
|
+ int length = tmpResult.length();
|
|
|
+ bool lengthOK = false;
|
|
|
+ for (int i = 0; i < DEFAULT_ALLOWED_LENGTHS_LEN; i++) {
|
|
|
+ if (length == DEFAULT_ALLOWED_LENGTHS[i]) {
|
|
|
+ lengthOK = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!lengthOK) {
|
|
|
+ throw ReaderException("not enough characters count");
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<String> resultString(new String(tmpResult));
|
|
|
+
|
|
|
+ std::vector< Ref<ResultPoint> > resultPoints(2);
|
|
|
+ Ref<OneDResultPoint> resultPoint1(new OneDResultPoint(startRange[1], (float) rowNumber));
|
|
|
+ Ref<OneDResultPoint> resultPoint2(new OneDResultPoint(endRange[0], (float) rowNumber));
|
|
|
+ resultPoints[0] = resultPoint1;
|
|
|
+ resultPoints[1] = resultPoint2;
|
|
|
+
|
|
|
+ delete [] startRange;
|
|
|
+ delete [] endRange;
|
|
|
+ ArrayRef<unsigned char> resultBytes(1);
|
|
|
+ return Ref<Result>(new Result(resultString, resultBytes, resultPoints, BarcodeFormat_ITF));
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ delete [] startRange;
|
|
|
+ delete [] endRange;
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param row row of black/white values to search
|
|
|
+ * @param payloadStart offset of start pattern
|
|
|
+ * @param resultString {@link StringBuffer} to append decoded chars to
|
|
|
+ * @throws ReaderException if decoding could not complete successfully
|
|
|
+ */
|
|
|
+ void ITFReader::decodeMiddle(Ref<BitArray> row, int payloadStart, int payloadEnd,
|
|
|
+ std::string& resultString) {
|
|
|
+ // Digits are interleaved in pairs - 5 black lines for one digit, and the
|
|
|
+ // 5
|
|
|
+ // interleaved white lines for the second digit.
|
|
|
+ // Therefore, need to scan 10 lines and then
|
|
|
+ // split these into two arrays
|
|
|
+ int counterDigitPairLen = 10;
|
|
|
+ int counterDigitPair[counterDigitPairLen];
|
|
|
+ for (int i=0; i<counterDigitPairLen; i++) {
|
|
|
+ counterDigitPair[i] = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ int counterBlack[5];
|
|
|
+ int counterWhite[5];
|
|
|
+ for (int i=0; i<5; i++) {
|
|
|
+ counterBlack[i] = 0;
|
|
|
+ counterWhite[i] = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ while (payloadStart < payloadEnd) {
|
|
|
+ // Get 10 runs of black/white.
|
|
|
+ if (!recordPattern(row, payloadStart, counterDigitPair, counterDigitPairLen)) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ // Split them into each array
|
|
|
+ for (int k = 0; k < 5; k++) {
|
|
|
+ int twoK = k << 1;
|
|
|
+ counterBlack[k] = counterDigitPair[twoK];
|
|
|
+ counterWhite[k] = counterDigitPair[twoK + 1];
|
|
|
+ }
|
|
|
+
|
|
|
+ int bestMatch = decodeDigit(counterBlack, 5);
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch));
|
|
|
+ bestMatch = decodeDigit(counterWhite, 5);
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch));
|
|
|
+
|
|
|
+ for (int i = 0; i < counterDigitPairLen; i++) {
|
|
|
+ payloadStart += counterDigitPair[i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Identify where the start of the middle / payload section starts.
|
|
|
+ *
|
|
|
+ * @param row row of black/white values to search
|
|
|
+ * @return Array, containing index of start of 'start block' and end of
|
|
|
+ * 'start block'
|
|
|
+ * @throws ReaderException
|
|
|
+ */
|
|
|
+ int* ITFReader::decodeStart(Ref<BitArray> row) {
|
|
|
+ int endStart = skipWhiteSpace(row);
|
|
|
+ int* startPattern = 0;
|
|
|
+ try {
|
|
|
+ startPattern = findGuardPattern(row, endStart, START_PATTERN, START_PATTERN_LEN);
|
|
|
+
|
|
|
+ // Determine the width of a narrow line in pixels. We can do this by
|
|
|
+ // getting the width of the start pattern and dividing by 4 because its
|
|
|
+ // made up of 4 narrow lines.
|
|
|
+ narrowLineWidth = (startPattern[1] - startPattern[0]) >> 2;
|
|
|
+ validateQuietZone(row, startPattern[0]);
|
|
|
+ return startPattern;
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ delete [] startPattern;
|
|
|
+ throw re;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Identify where the end of the middle / payload section ends.
|
|
|
+ *
|
|
|
+ * @param row row of black/white values to search
|
|
|
+ * @return Array, containing index of start of 'end block' and end of 'end
|
|
|
+ * block'
|
|
|
+ * @throws ReaderException
|
|
|
+ */
|
|
|
+
|
|
|
+ int* ITFReader::decodeEnd(Ref<BitArray> row) {
|
|
|
+ // For convenience, reverse the row and then
|
|
|
+ // search from 'the start' for the end block
|
|
|
+ row->reverse();
|
|
|
+ int* endPattern = 0;
|
|
|
+ try {
|
|
|
+ int endStart = skipWhiteSpace(row);
|
|
|
+ endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED, END_PATTERN_REVERSED_LEN);
|
|
|
+
|
|
|
+ // The start & end patterns must be pre/post fixed by a quiet zone. This
|
|
|
+ // zone must be at least 10 times the width of a narrow line.
|
|
|
+ // ref: http://www.barcode-1.net/i25code.html
|
|
|
+ validateQuietZone(row, endPattern[0]);
|
|
|
+
|
|
|
+ // Now recalculate the indices of where the 'endblock' starts & stops to
|
|
|
+ // accommodate
|
|
|
+ // the reversed nature of the search
|
|
|
+ int temp = endPattern[0];
|
|
|
+ endPattern[0] = row->getSize() - endPattern[1];
|
|
|
+ endPattern[1] = row->getSize() - temp;
|
|
|
+
|
|
|
+ row->reverse();
|
|
|
+ return endPattern;
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ delete [] endPattern;
|
|
|
+ row->reverse();
|
|
|
+ throw re;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The start & end patterns must be pre/post fixed by a quiet zone. This
|
|
|
+ * zone must be at least 10 times the width of a narrow line. Scan back until
|
|
|
+ * we either get to the start of the barcode or match the necessary number of
|
|
|
+ * quiet zone pixels.
|
|
|
+ *
|
|
|
+ * Note: Its assumed the row is reversed when using this method to find
|
|
|
+ * quiet zone after the end pattern.
|
|
|
+ *
|
|
|
+ * ref: http://www.barcode-1.net/i25code.html
|
|
|
+ *
|
|
|
+ * @param row bit array representing the scanned barcode.
|
|
|
+ * @param startPattern index into row of the start or end pattern.
|
|
|
+ * @throws ReaderException if the quiet zone cannot be found, a ReaderException is thrown.
|
|
|
+ */
|
|
|
+ void ITFReader::validateQuietZone(Ref<BitArray> row, int startPattern) {
|
|
|
+ (void)row;
|
|
|
+ (void)startPattern;
|
|
|
+//#pragma mark needs some corrections
|
|
|
+// int quietCount = narrowLineWidth * 10; // expect to find this many pixels of quiet zone
|
|
|
+//
|
|
|
+// for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
|
|
|
+// if (row->get(i)) {
|
|
|
+// break;
|
|
|
+// }
|
|
|
+// quietCount--;
|
|
|
+// }
|
|
|
+// if (quietCount != 0) {
|
|
|
+// // Unable to find the necessary number of quiet zone pixels.
|
|
|
+// throw ReaderException("Unable to find the necessary number of quiet zone pixels");
|
|
|
+// }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Skip all whitespace until we get to the first black line.
|
|
|
+ *
|
|
|
+ * @param row row of black/white values to search
|
|
|
+ * @return index of the first black line.
|
|
|
+ * @throws ReaderException Throws exception if no black lines are found in the row
|
|
|
+ */
|
|
|
+ int ITFReader::skipWhiteSpace(Ref<BitArray> row) {
|
|
|
+ int width = row->getSize();
|
|
|
+ int endStart = 0;
|
|
|
+ while (endStart < width) {
|
|
|
+ if (row->get(endStart)) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ endStart++;
|
|
|
+ }
|
|
|
+ if (endStart == width) {
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+ return endStart;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param row row of black/white values to search
|
|
|
+ * @param rowOffset position to start search
|
|
|
+ * @param pattern pattern of counts of number of black and white pixels that are
|
|
|
+ * being searched for as a pattern
|
|
|
+ * @return start/end horizontal offset of guard pattern, as an array of two
|
|
|
+ * ints
|
|
|
+ * @throws ReaderException if pattern is not found
|
|
|
+ */
|
|
|
+ int* ITFReader::findGuardPattern(Ref<BitArray> row, int rowOffset, const int pattern[],
|
|
|
+ int patternLen) {
|
|
|
+ // TODO: This is very similar to implementation in UPCEANReader. Consider if they can be
|
|
|
+ // merged to a single method.
|
|
|
+ int patternLength = patternLen;
|
|
|
+ int counters[patternLength];
|
|
|
+ for (int i=0; i<patternLength; i++) {
|
|
|
+ counters[i] = 0;
|
|
|
+ }
|
|
|
+ int width = row->getSize();
|
|
|
+ bool isWhite = false;
|
|
|
+
|
|
|
+ int counterPosition = 0;
|
|
|
+ int patternStart = rowOffset;
|
|
|
+ for (int x = rowOffset; x < width; x++) {
|
|
|
+ bool pixel = row->get(x);
|
|
|
+ if (pixel ^ isWhite) {
|
|
|
+ counters[counterPosition]++;
|
|
|
+ } else {
|
|
|
+ if (counterPosition == patternLength - 1) {
|
|
|
+ if (patternMatchVariance(counters, patternLength, pattern,
|
|
|
+ MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
|
|
|
+ int* resultValue = new int[2];
|
|
|
+ resultValue[0] = patternStart;
|
|
|
+ resultValue[1] = x;
|
|
|
+ return resultValue;
|
|
|
+ }
|
|
|
+ patternStart += counters[0] + counters[1];
|
|
|
+ for (int y = 2; y < patternLength; y++) {
|
|
|
+ counters[y - 2] = counters[y];
|
|
|
+ }
|
|
|
+ counters[patternLength - 2] = 0;
|
|
|
+ counters[patternLength - 1] = 0;
|
|
|
+ counterPosition--;
|
|
|
+ } else {
|
|
|
+ counterPosition++;
|
|
|
+ }
|
|
|
+ counters[counterPosition] = 1;
|
|
|
+ isWhite = !isWhite;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw ReaderException("");
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Attempts to decode a sequence of ITF black/white lines into single
|
|
|
+ * digit.
|
|
|
+ *
|
|
|
+ * @param counters the counts of runs of observed black/white/black/... values
|
|
|
+ * @return The decoded digit
|
|
|
+ * @throws ReaderException if digit cannot be decoded
|
|
|
+ */
|
|
|
+ int ITFReader::decodeDigit(int counters[], int countersLen){
|
|
|
+ unsigned int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
|
|
|
+ int bestMatch = -1;
|
|
|
+ int max = PATTERNS_LEN;
|
|
|
+ for (int i = 0; i < max; i++) {
|
|
|
+ int pattern[countersLen];
|
|
|
+ for(int ind = 0; ind<countersLen; ind++){
|
|
|
+ pattern[ind] = PATTERNS[i][ind];
|
|
|
+ }
|
|
|
+ unsigned int variance = patternMatchVariance(counters, countersLen, pattern,
|
|
|
+ MAX_INDIVIDUAL_VARIANCE);
|
|
|
+ if (variance < bestVariance) {
|
|
|
+ bestVariance = variance;
|
|
|
+ bestMatch = i;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (bestMatch >= 0) {
|
|
|
+ return bestMatch;
|
|
|
+ } else {
|
|
|
+ throw ReaderException("digit didint found");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ITFReader::~ITFReader(){
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/MultiFormatOneDReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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>();
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/MultiFormatUPCEANReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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>();
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/OneDReader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 const& re) {
|
|
|
+ continue;
|
|
|
+ } catch (IllegalArgumentException const& 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() {
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/OneDResultPoint.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * OneDResultPoint.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 "OneDResultPoint.h"
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ OneDResultPoint::OneDResultPoint(float posX, float posY) : ResultPoint(posX,posY) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/UPCAReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * UPCAReader.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 "UPCAReader.h"
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+ UPCAReader::UPCAReader() : ean13Reader() {
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> UPCAReader::decodeRow(int rowNumber, Ref<BitArray> row) {
|
|
|
+ return maybeReturnResult(ean13Reader.decodeRow(rowNumber, row));
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> UPCAReader::decodeRow(int rowNumber, Ref<BitArray> row, int startGuardBegin,
|
|
|
+ int startGuardEnd) {
|
|
|
+ return maybeReturnResult(ean13Reader.decodeRow(rowNumber, row, startGuardBegin,
|
|
|
+ startGuardEnd));
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> UPCAReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
|
|
|
+ return maybeReturnResult(ean13Reader.decode(image, hints));
|
|
|
+ }
|
|
|
+
|
|
|
+ int UPCAReader::decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
|
|
|
+ std::string& resultString) {
|
|
|
+ return ean13Reader.decodeMiddle(row, startGuardBegin, startGuardEnd, resultString);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> UPCAReader::maybeReturnResult(Ref<Result> result) {
|
|
|
+ if (result.empty()) {
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ 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 Ref<Result>();
|
|
|
+ }
|
|
|
+
|
|
|
+ BarcodeFormat UPCAReader::getBarcodeFormat(){
|
|
|
+ return BarcodeFormat_UPC_A;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/UPCEANReader.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * UPCEANReader.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 "UPCEANReader.h"
|
|
|
+// #include <zxing/oned/OneDResultPoint.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Start/end guard pattern.
|
|
|
+ */
|
|
|
+ static const int START_END_PATTERN[3] = {1, 1, 1};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Pattern marking the middle of a UPC/EAN pattern, separating the two halves.
|
|
|
+ */
|
|
|
+ static const int MIDDLE_PATTERN_LEN = 5;
|
|
|
+ static const int MIDDLE_PATTERN[MIDDLE_PATTERN_LEN] = {1, 1, 1, 1, 1};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * "Odd", or "L" patterns used to encode UPC/EAN digits.
|
|
|
+ */
|
|
|
+ const int L_PATTERNS_LEN = 10;
|
|
|
+ const int L_PATTERNS_SUB_LEN = 4;
|
|
|
+ const int L_PATTERNS[L_PATTERNS_LEN][L_PATTERNS_SUB_LEN] = {
|
|
|
+ {3, 2, 1, 1}, // 0
|
|
|
+ {2, 2, 2, 1}, // 1
|
|
|
+ {2, 1, 2, 2}, // 2
|
|
|
+ {1, 4, 1, 1}, // 3
|
|
|
+ {1, 1, 3, 2}, // 4
|
|
|
+ {1, 2, 3, 1}, // 5
|
|
|
+ {1, 1, 1, 4}, // 6
|
|
|
+ {1, 3, 1, 2}, // 7
|
|
|
+ {1, 2, 1, 3}, // 8
|
|
|
+ {3, 1, 1, 2} // 9
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * As above but also including the "even", or "G" patterns used to encode UPC/EAN digits.
|
|
|
+ */
|
|
|
+ const int L_AND_G_PATTERNS_LEN = 20;
|
|
|
+ const int L_AND_G_PATTERNS_SUB_LEN = 4;
|
|
|
+ const int L_AND_G_PATTERNS[L_AND_G_PATTERNS_LEN][L_AND_G_PATTERNS_SUB_LEN] = {
|
|
|
+ {3, 2, 1, 1}, // 0
|
|
|
+ {2, 2, 2, 1}, // 1
|
|
|
+ {2, 1, 2, 2}, // 2
|
|
|
+ {1, 4, 1, 1}, // 3
|
|
|
+ {1, 1, 3, 2}, // 4
|
|
|
+ {1, 2, 3, 1}, // 5
|
|
|
+ {1, 1, 1, 4}, // 6
|
|
|
+ {1, 3, 1, 2}, // 7
|
|
|
+ {1, 2, 1, 3}, // 8
|
|
|
+ {3, 1, 1, 2}, // 9
|
|
|
+ {1, 1, 2, 3}, // 10 reversed 0
|
|
|
+ {1, 2, 2, 2}, // 11 reversed 1
|
|
|
+ {2, 2, 1, 2}, // 12 reversed 2
|
|
|
+ {1, 1, 4, 1}, // 13 reversed 3
|
|
|
+ {2, 3, 1, 1}, // 14 reversed 4
|
|
|
+ {1, 3, 2, 1}, // 15 reversed 5
|
|
|
+ {4, 1, 1, 1}, // 16 reversed 6
|
|
|
+ {2, 1, 3, 1}, // 17 reversed 7
|
|
|
+ {3, 1, 2, 1}, // 18 reversed 8
|
|
|
+ {2, 1, 1, 3} // 19 reversed 9
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ int UPCEANReader::getMIDDLE_PATTERN_LEN() {
|
|
|
+ return MIDDLE_PATTERN_LEN;
|
|
|
+ }
|
|
|
+
|
|
|
+ const int* UPCEANReader::getMIDDLE_PATTERN() {
|
|
|
+ return MIDDLE_PATTERN;
|
|
|
+ }
|
|
|
+
|
|
|
+ UPCEANReader::UPCEANReader() {
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ Ref<Result> UPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row) {
|
|
|
+ int rangeStart;
|
|
|
+ int rangeEnd;
|
|
|
+ if (findStartGuardPattern(row, &rangeStart, &rangeEnd)) {
|
|
|
+ try {
|
|
|
+ return decodeRow(rowNumber, row, rangeStart, rangeEnd);
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Result> UPCEANReader::decodeRow(int rowNumber, Ref<BitArray> row, int startGuardBegin,
|
|
|
+ int startGuardEnd) {
|
|
|
+ std::string tmpResultString;
|
|
|
+ std::string& tmpResultStringRef = tmpResultString;
|
|
|
+ int endStart = decodeMiddle(row, startGuardBegin, startGuardEnd, tmpResultStringRef);
|
|
|
+ if (endStart < 0) {
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+
|
|
|
+ int endGuardBegin;
|
|
|
+ int endGuardEnd;
|
|
|
+ if (!decodeEnd(row, endStart, &endGuardBegin, &endGuardEnd)) {
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Make sure there is a quiet zone at least as big as the end pattern after the barcode.
|
|
|
+ // The spec might want more whitespace, but in practice this is the maximum we can count on.
|
|
|
+ size_t quietEnd = endGuardEnd + (endGuardEnd - endGuardBegin);
|
|
|
+ if (quietEnd >= row->getSize() || !row->isRange(endGuardEnd, quietEnd, false)) {
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!checkChecksum(tmpResultString)) {
|
|
|
+ return Ref<Result>();
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<String> resultString(new String(tmpResultString));
|
|
|
+ float left = (float) (startGuardBegin + startGuardEnd) / 2.0f;
|
|
|
+ float right = (float) (endGuardBegin + endGuardEnd) / 2.0f;
|
|
|
+
|
|
|
+ std::vector< Ref<ResultPoint> > resultPoints(2);
|
|
|
+ Ref<OneDResultPoint> resultPoint1(new OneDResultPoint(left, (float) rowNumber));
|
|
|
+ Ref<OneDResultPoint> resultPoint2(new OneDResultPoint(right, (float) rowNumber));
|
|
|
+ resultPoints[0] = resultPoint1;
|
|
|
+ resultPoints[1] = resultPoint2;
|
|
|
+
|
|
|
+ ArrayRef<unsigned char> resultBytes(1);
|
|
|
+ return Ref<Result>(new Result(resultString, resultBytes, resultPoints, getBarcodeFormat()));
|
|
|
+ }
|
|
|
+
|
|
|
+ bool UPCEANReader::findStartGuardPattern(Ref<BitArray> row, int* rangeStart, int* rangeEnd) {
|
|
|
+ int nextStart = 0;
|
|
|
+ while (findGuardPattern(row, nextStart, false, START_END_PATTERN,
|
|
|
+ sizeof(START_END_PATTERN) / sizeof(int), rangeStart, rangeEnd)) {
|
|
|
+ int start = *rangeStart;
|
|
|
+ nextStart = *rangeEnd;
|
|
|
+ // Make sure there is a quiet zone at least as big as the start pattern before the barcode.
|
|
|
+ // If this check would run off the left edge of the image, do not accept this barcode,
|
|
|
+ // as it is very likely to be a false positive.
|
|
|
+ int quietStart = start - (nextStart - start);
|
|
|
+ if (quietStart >= 0 && row->isRange(quietStart, start, false)) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool UPCEANReader::findGuardPattern(Ref<BitArray> row, int rowOffset, bool whiteFirst,
|
|
|
+ const int pattern[], int patternLen, int* start, int* end) {
|
|
|
+ int patternLength = patternLen;
|
|
|
+ int counters[patternLength];
|
|
|
+ int countersCount = sizeof(counters) / sizeof(int);
|
|
|
+ for (int i = 0; i < countersCount; i++) {
|
|
|
+ counters[i] = 0;
|
|
|
+ }
|
|
|
+ int width = row->getSize();
|
|
|
+ bool isWhite = false;
|
|
|
+ while (rowOffset < width) {
|
|
|
+ isWhite = !row->get(rowOffset);
|
|
|
+ if (whiteFirst == isWhite) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ rowOffset++;
|
|
|
+ }
|
|
|
+
|
|
|
+ int counterPosition = 0;
|
|
|
+ int patternStart = rowOffset;
|
|
|
+ for (int x = rowOffset; x < width; x++) {
|
|
|
+ bool pixel = row->get(x);
|
|
|
+ if (pixel ^ isWhite) {
|
|
|
+ counters[counterPosition]++;
|
|
|
+ } else {
|
|
|
+ if (counterPosition == patternLength - 1) {
|
|
|
+ if (patternMatchVariance(counters, countersCount, pattern,
|
|
|
+ MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
|
|
|
+ *start = patternStart;
|
|
|
+ *end = x;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ patternStart += counters[0] + counters[1];
|
|
|
+ for (int y = 2; y < patternLength; y++) {
|
|
|
+ counters[y - 2] = counters[y];
|
|
|
+ }
|
|
|
+ counters[patternLength - 2] = 0;
|
|
|
+ counters[patternLength - 1] = 0;
|
|
|
+ counterPosition--;
|
|
|
+ } else {
|
|
|
+ counterPosition++;
|
|
|
+ }
|
|
|
+ counters[counterPosition] = 1;
|
|
|
+ isWhite = !isWhite;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool UPCEANReader::decodeEnd(Ref<BitArray> row, int endStart, int* endGuardBegin,
|
|
|
+ int* endGuardEnd) {
|
|
|
+ return findGuardPattern(row, endStart, false, START_END_PATTERN,
|
|
|
+ sizeof(START_END_PATTERN) / sizeof(int), endGuardBegin, endGuardEnd);
|
|
|
+ }
|
|
|
+
|
|
|
+ int UPCEANReader::decodeDigit(Ref<BitArray> row, int counters[], int countersLen, int rowOffset,
|
|
|
+ UPC_EAN_PATTERNS patternType) {
|
|
|
+ if (!recordPattern(row, rowOffset, counters, countersLen)) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ unsigned int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
|
|
|
+ int bestMatch = -1;
|
|
|
+
|
|
|
+ int max = 0;
|
|
|
+ switch (patternType) {
|
|
|
+ case UPC_EAN_PATTERNS_L_PATTERNS:
|
|
|
+ max = L_PATTERNS_LEN;
|
|
|
+ for (int i = 0; i < max; i++) {
|
|
|
+ int pattern[countersLen];
|
|
|
+ for(int j = 0; j< countersLen; j++){
|
|
|
+ pattern[j] = L_PATTERNS[i][j];
|
|
|
+ }
|
|
|
+
|
|
|
+ unsigned int variance = patternMatchVariance(counters, countersLen, pattern,
|
|
|
+ MAX_INDIVIDUAL_VARIANCE);
|
|
|
+ if (variance < bestVariance) {
|
|
|
+ bestVariance = variance;
|
|
|
+ bestMatch = i;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case UPC_EAN_PATTERNS_L_AND_G_PATTERNS:
|
|
|
+ max = L_AND_G_PATTERNS_LEN;
|
|
|
+ for (int i = 0; i < max; i++) {
|
|
|
+ int pattern[countersLen];
|
|
|
+ for(int j = 0; j< countersLen; j++){
|
|
|
+ pattern[j] = L_AND_G_PATTERNS[i][j];
|
|
|
+ }
|
|
|
+
|
|
|
+ unsigned int variance = patternMatchVariance(counters, countersLen, pattern,
|
|
|
+ MAX_INDIVIDUAL_VARIANCE);
|
|
|
+ if (variance < bestVariance) {
|
|
|
+ bestVariance = variance;
|
|
|
+ bestMatch = i;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return bestMatch;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @return {@link #checkStandardUPCEANChecksum(String)}
|
|
|
+ */
|
|
|
+ bool UPCEANReader::checkChecksum(std::string s) {
|
|
|
+ return checkStandardUPCEANChecksum(s);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Computes the UPC/EAN checksum on a string of digits, and reports
|
|
|
+ * whether the checksum is correct or not.
|
|
|
+ *
|
|
|
+ * @param s string of digits to check
|
|
|
+ * @return true iff string of digits passes the UPC/EAN checksum algorithm
|
|
|
+ */
|
|
|
+ bool UPCEANReader::checkStandardUPCEANChecksum(std::string s) {
|
|
|
+ int length = s.length();
|
|
|
+ if (length == 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ int sum = 0;
|
|
|
+ for (int i = length - 2; i >= 0; i -= 2) {
|
|
|
+ int digit = (int) s[i] - (int) '0';
|
|
|
+ if (digit < 0 || digit > 9) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ sum += digit;
|
|
|
+ }
|
|
|
+ sum *= 3;
|
|
|
+ for (int i = length - 1; i >= 0; i -= 2) {
|
|
|
+ int digit = (int) s[i] - (int) '0';
|
|
|
+ if (digit < 0 || digit > 9) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ sum += digit;
|
|
|
+ }
|
|
|
+ return sum % 10 == 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ UPCEANReader::~UPCEANReader() {
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/oned/UPCEReader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * 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 "UPCEReader.h"
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace oned {
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The pattern that marks the middle, and end, of a UPC-E pattern.
|
|
|
+ * There is no "second half" to a UPC-E barcode.
|
|
|
+ */
|
|
|
+ static const int MIDDLE_END_PATTERN[6] = {1, 1, 1, 1, 1, 1};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * See {@link #L_AND_G_PATTERNS}; these values similarly represent patterns of
|
|
|
+ * even-odd parity encodings of digits that imply both the number system (0 or 1)
|
|
|
+ * used, and the check digit.
|
|
|
+ */
|
|
|
+ static const int NUMSYS_AND_CHECK_DIGIT_PATTERNS[2][10] = {
|
|
|
+ {0x38, 0x34, 0x32, 0x31, 0x2C, 0x26, 0x23, 0x2A, 0x29, 0x25},
|
|
|
+ {0x07, 0x0B, 0x0D, 0x0E, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A}
|
|
|
+ };
|
|
|
+
|
|
|
+ UPCEReader::UPCEReader() {
|
|
|
+ }
|
|
|
+
|
|
|
+ int UPCEReader::decodeMiddle(Ref<BitArray> row, int startGuardBegin, int startGuardEnd,
|
|
|
+ std::string& resultString) {
|
|
|
+ (void)startGuardBegin;
|
|
|
+ const int countersLen = 4;
|
|
|
+ int counters[countersLen] = { 0, 0, 0, 0 };
|
|
|
+
|
|
|
+ int end = row->getSize();
|
|
|
+ int rowOffset = startGuardEnd;
|
|
|
+ int lgPatternFound = 0;
|
|
|
+
|
|
|
+ for (int x = 0; x < 6 && rowOffset < end; x++) {
|
|
|
+ int bestMatch = decodeDigit(row, counters, countersLen, rowOffset,
|
|
|
+ UPC_EAN_PATTERNS_L_AND_G_PATTERNS);
|
|
|
+ if (bestMatch < 0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ resultString.append(1, (char) ('0' + bestMatch % 10));
|
|
|
+ for (int i = 0; i < countersLen; i++) {
|
|
|
+ rowOffset += counters[i];
|
|
|
+ }
|
|
|
+ if (bestMatch >= 10) {
|
|
|
+ lgPatternFound |= 1 << (5 - x);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!determineNumSysAndCheckDigit(resultString, lgPatternFound)) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ return rowOffset;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool UPCEReader::decodeEnd(Ref<BitArray> row, int endStart, int* endGuardBegin,
|
|
|
+ int* endGuardEnd) {
|
|
|
+ return findGuardPattern(row, endStart, true, MIDDLE_END_PATTERN,
|
|
|
+ sizeof(MIDDLE_END_PATTERN) / sizeof(int), endGuardBegin, endGuardEnd);
|
|
|
+ }
|
|
|
+
|
|
|
+ bool UPCEReader::checkChecksum(std::string s){
|
|
|
+ return UPCEANReader::checkChecksum(convertUPCEtoUPCA(s));
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ bool UPCEReader::determineNumSysAndCheckDigit(std::string& resultString, int lgPatternFound) {
|
|
|
+ for (int numSys = 0; numSys <= 1; numSys++) {
|
|
|
+ for (int d = 0; d < 10; d++) {
|
|
|
+ if (lgPatternFound == NUMSYS_AND_CHECK_DIGIT_PATTERNS[numSys][d]) {
|
|
|
+ resultString.insert(0, 1, (char) ('0' + numSys));
|
|
|
+ resultString.append(1, (char) ('0' + d));
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Expands a UPC-E value back into its full, equivalent UPC-A code value.
|
|
|
+ *
|
|
|
+ * @param upce UPC-E code as string of digits
|
|
|
+ * @return equivalent UPC-A code as string of digits
|
|
|
+ */
|
|
|
+ std::string UPCEReader::convertUPCEtoUPCA(std::string upce) {
|
|
|
+ std::string result;
|
|
|
+ result.append(1, upce[0]);
|
|
|
+ char lastChar = upce[6];
|
|
|
+ switch (lastChar) {
|
|
|
+ case '0':
|
|
|
+ case '1':
|
|
|
+ case '2':
|
|
|
+ result.append(upce.substr(1,2));
|
|
|
+ result.append(1, lastChar);
|
|
|
+ result.append("0000");
|
|
|
+ result.append(upce.substr(3,3));
|
|
|
+ break;
|
|
|
+ case '3':
|
|
|
+ result.append(upce.substr(1,3));
|
|
|
+ result.append("00000");
|
|
|
+ result.append(upce.substr(4,2));
|
|
|
+ break;
|
|
|
+ case '4':
|
|
|
+ result.append(upce.substr(1,4));
|
|
|
+ result.append("00000");
|
|
|
+ result.append(1, upce[5]);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ result.append(upce.substr(1,5));
|
|
|
+ result.append("0000");
|
|
|
+ result.append(1, lastChar);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ result.append(1, upce[7]);
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ BarcodeFormat UPCEReader::getBarcodeFormat() {
|
|
|
+ return BarcodeFormat_UPC_E;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/ErrorCorrectionLevel.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * ErrorCorrectionLevel.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 15/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/qrcode/ErrorCorrectionLevel.h>
|
|
|
+
|
|
|
+using std::string;
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+ErrorCorrectionLevel::ErrorCorrectionLevel(int inOrdinal,
|
|
|
+ int bits,
|
|
|
+ char const* name) :
|
|
|
+ ordinal_(inOrdinal), bits_(bits), name_(name) {}
|
|
|
+
|
|
|
+int ErrorCorrectionLevel::ordinal() const {
|
|
|
+ return ordinal_;
|
|
|
+}
|
|
|
+
|
|
|
+int ErrorCorrectionLevel::bits() const {
|
|
|
+ return bits_;
|
|
|
+}
|
|
|
+
|
|
|
+string const& ErrorCorrectionLevel::name() const {
|
|
|
+ return name_;
|
|
|
+}
|
|
|
+
|
|
|
+ErrorCorrectionLevel::operator string const& () const {
|
|
|
+ return name_;
|
|
|
+}
|
|
|
+
|
|
|
+ErrorCorrectionLevel& ErrorCorrectionLevel::forBits(int bits) {
|
|
|
+ if (bits < 0 || bits >= N_LEVELS) {
|
|
|
+ throw ReaderException("Ellegal error correction level bits");
|
|
|
+ }
|
|
|
+ return *FOR_BITS[bits];
|
|
|
+}
|
|
|
+
|
|
|
+ ErrorCorrectionLevel ErrorCorrectionLevel::L(0, 0x01, "L");
|
|
|
+ ErrorCorrectionLevel ErrorCorrectionLevel::M(1, 0x00, "M");
|
|
|
+ ErrorCorrectionLevel ErrorCorrectionLevel::Q(2, 0x03, "Q");
|
|
|
+ ErrorCorrectionLevel ErrorCorrectionLevel::H(3, 0x02, "H");
|
|
|
+ErrorCorrectionLevel *ErrorCorrectionLevel::FOR_BITS[] = { &M, &L, &H, &Q };
|
|
|
+int ErrorCorrectionLevel::N_LEVELS = 4;
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/FormatInformation.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * FormatInformation.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/qrcode/FormatInformation.h>
|
|
|
+// #include <limits>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+int FormatInformation::FORMAT_INFO_MASK_QR = 0x5412;
|
|
|
+int FormatInformation::FORMAT_INFO_DECODE_LOOKUP[][2] = { { 0x5412, 0x00 }, { 0x5125, 0x01 }, { 0x5E7C, 0x02 }, {
|
|
|
+ 0x5B4B, 0x03 }, { 0x45F9, 0x04 }, { 0x40CE, 0x05 }, { 0x4F97, 0x06 }, { 0x4AA0, 0x07 }, { 0x77C4, 0x08 }, {
|
|
|
+ 0x72F3, 0x09 }, { 0x7DAA, 0x0A }, { 0x789D, 0x0B }, { 0x662F, 0x0C }, { 0x6318, 0x0D }, { 0x6C41, 0x0E }, {
|
|
|
+ 0x6976, 0x0F }, { 0x1689, 0x10 }, { 0x13BE, 0x11 }, { 0x1CE7, 0x12 }, { 0x19D0, 0x13 }, { 0x0762, 0x14 }, {
|
|
|
+ 0x0255, 0x15 }, { 0x0D0C, 0x16 }, { 0x083B, 0x17 }, { 0x355F, 0x18 }, { 0x3068, 0x19 }, { 0x3F31, 0x1A }, {
|
|
|
+ 0x3A06, 0x1B }, { 0x24B4, 0x1C }, { 0x2183, 0x1D }, { 0x2EDA, 0x1E }, { 0x2BED, 0x1F },
|
|
|
+};
|
|
|
+int FormatInformation::N_FORMAT_INFO_DECODE_LOOKUPS = 32;
|
|
|
+
|
|
|
+int FormatInformation::BITS_SET_IN_HALF_BYTE[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
|
|
|
+
|
|
|
+FormatInformation::FormatInformation(int formatInfo) :
|
|
|
+ errorCorrectionLevel_(ErrorCorrectionLevel::forBits((formatInfo >> 3) & 0x03)), dataMask_(
|
|
|
+ (unsigned char)(formatInfo & 0x07)) {
|
|
|
+}
|
|
|
+
|
|
|
+ErrorCorrectionLevel& FormatInformation::getErrorCorrectionLevel() {
|
|
|
+ return errorCorrectionLevel_;
|
|
|
+}
|
|
|
+
|
|
|
+unsigned char FormatInformation::getDataMask() {
|
|
|
+ return dataMask_;
|
|
|
+}
|
|
|
+
|
|
|
+int FormatInformation::numBitsDiffering(unsigned int a, unsigned int b) {
|
|
|
+ a ^= b;
|
|
|
+ return BITS_SET_IN_HALF_BYTE[a & 0x0F] + BITS_SET_IN_HALF_BYTE[(a >> 4 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 8
|
|
|
+ & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 12 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 16 & 0x0F)]
|
|
|
+ + BITS_SET_IN_HALF_BYTE[(a >> 20 & 0x0F)] + BITS_SET_IN_HALF_BYTE[(a >> 24 & 0x0F)]
|
|
|
+ + BITS_SET_IN_HALF_BYTE[(a >> 28 & 0x0F)];
|
|
|
+}
|
|
|
+
|
|
|
+Ref<FormatInformation> FormatInformation::decodeFormatInformation(int maskedFormatInfo1, int maskedFormatInfo2) {
|
|
|
+ Ref<FormatInformation> result(doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2));
|
|
|
+ if (result != 0) {
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ // Should return null, but, some QR codes apparently
|
|
|
+ // do not mask this info. Try again by actually masking the pattern
|
|
|
+ // first
|
|
|
+ return doDecodeFormatInformation(maskedFormatInfo1 ^ FORMAT_INFO_MASK_QR,
|
|
|
+ maskedFormatInfo2 ^ FORMAT_INFO_MASK_QR);
|
|
|
+}
|
|
|
+Ref<FormatInformation> FormatInformation::doDecodeFormatInformation(int maskedFormatInfo1, int maskedFormatInfo2) {
|
|
|
+ // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
|
|
|
+ int bestDifference = numeric_limits<int>::max();
|
|
|
+ int bestFormatInfo = 0;
|
|
|
+ for (int i = 0; i < N_FORMAT_INFO_DECODE_LOOKUPS; i++) {
|
|
|
+ int* decodeInfo = FORMAT_INFO_DECODE_LOOKUP[i];
|
|
|
+ int targetInfo = decodeInfo[0];
|
|
|
+ if (targetInfo == maskedFormatInfo1 || targetInfo == maskedFormatInfo2) {
|
|
|
+ // Found an exact match
|
|
|
+ Ref<FormatInformation> result(new FormatInformation(decodeInfo[1]));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ int bitsDifference = numBitsDiffering(maskedFormatInfo1, targetInfo);
|
|
|
+ if (bitsDifference < bestDifference) {
|
|
|
+ bestFormatInfo = decodeInfo[1];
|
|
|
+ bestDifference = bitsDifference;
|
|
|
+ }
|
|
|
+ if (maskedFormatInfo1 != maskedFormatInfo2) {
|
|
|
+ // also try the other option
|
|
|
+ bitsDifference = numBitsDiffering(maskedFormatInfo2, targetInfo);
|
|
|
+ if (bitsDifference < bestDifference) {
|
|
|
+ bestFormatInfo = decodeInfo[1];
|
|
|
+ bestDifference = bitsDifference;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (bestDifference <= 3) {
|
|
|
+ Ref<FormatInformation> result(new FormatInformation(bestFormatInfo));
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ Ref<FormatInformation> result;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+bool operator==(const FormatInformation &a, const FormatInformation &b) {
|
|
|
+ return &(a.errorCorrectionLevel_) == &(b.errorCorrectionLevel_) && a.dataMask_ == b.dataMask_;
|
|
|
+}
|
|
|
+
|
|
|
+ostream& operator<<(ostream& out, const FormatInformation& fi) {
|
|
|
+ const FormatInformation *fip = &fi;
|
|
|
+ out << "FormatInformation @ " << fip;
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/QRCodeReader.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * QRCodeReader.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/QRCodeReader.h>
|
|
|
+// #include <zxing/qrcode/detector/Detector.h>
|
|
|
+
|
|
|
+// #include <iostream>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace qrcode {
|
|
|
+
|
|
|
+ using namespace std;
|
|
|
+
|
|
|
+ QRCodeReader::QRCodeReader() :decoder_() {
|
|
|
+ }
|
|
|
+ //TODO: see if any of the other files in the qrcode tree need tryHarder
|
|
|
+ Ref<Result> QRCodeReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "decoding image " << image.object_ << ":\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ Detector detector(image->getBlackMatrix());
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(1) created detector " << &detector << "\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ Ref<DetectorResult> detectorResult(detector.detect(hints));
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(2) detected, have detectorResult " << detectorResult.object_ << "\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ std::vector<Ref<ResultPoint> > points(detectorResult->getPoints());
|
|
|
+
|
|
|
+
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(3) extracted points " << &points << "\n" << flush;
|
|
|
+ cout << "found " << points.size() << " points:\n";
|
|
|
+ for (size_t i = 0; i < points.size(); i++) {
|
|
|
+ cout << " " << points[i]->getX() << "," << points[i]->getY() << "\n";
|
|
|
+ }
|
|
|
+ cout << "bits:\n";
|
|
|
+ cout << *(detectorResult->getBits()) << "\n";
|
|
|
+#endif
|
|
|
+
|
|
|
+ Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult->getBits()));
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(4) decoded, have decoderResult " << decoderResult.object_ << "\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ Ref<Result> result(
|
|
|
+ new Result(decoderResult->getText(), decoderResult->getRawBytes(), points, BarcodeFormat_QR_CODE));
|
|
|
+#ifdef DEBUG
|
|
|
+ cout << "(5) created result " << result.object_ << ", returning\n" << flush;
|
|
|
+#endif
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ QRCodeReader::~QRCodeReader() {
|
|
|
+ }
|
|
|
+
|
|
|
+ Decoder& QRCodeReader::getDecoder() {
|
|
|
+ return decoder_;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/Version.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * Version.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/qrcode/Version.h>
|
|
|
+// #include <zxing/qrcode/FormatInformation.h>
|
|
|
+// #include <limits>
|
|
|
+// #include <iostream>
|
|
|
+// #include <cstdarg>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+ECB::ECB(int count, int dataCodewords) :
|
|
|
+ count_(count), dataCodewords_(dataCodewords) {
|
|
|
+}
|
|
|
+
|
|
|
+int ECB::getCount() {
|
|
|
+ return count_;
|
|
|
+}
|
|
|
+
|
|
|
+int ECB::getDataCodewords() {
|
|
|
+ return dataCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks) :
|
|
|
+ ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks) {
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2) :
|
|
|
+ ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks1) {
|
|
|
+ ecBlocks_.push_back(ecBlocks2);
|
|
|
+}
|
|
|
+
|
|
|
+int ECBlocks::getECCodewords() {
|
|
|
+ return ecCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<ECB*>& ECBlocks::getECBlocks() {
|
|
|
+ return ecBlocks_;
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks::~ECBlocks() {
|
|
|
+ for (size_t i = 0; i < ecBlocks_.size(); i++) {
|
|
|
+ delete ecBlocks_[i];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+unsigned int Version::VERSION_DECODE_INFO[] = { 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, 0x0C762, 0x0D847, 0x0E60D,
|
|
|
+ 0x0F928, 0x10B78, 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,
|
|
|
+ 0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250, 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B, 0x2542E, 0x26A64,
|
|
|
+ 0x27541, 0x28C69
|
|
|
+ };
|
|
|
+int Version::N_VERSION_DECODE_INFOS = 34;
|
|
|
+vector<Ref<Version> > Version::VERSIONS;
|
|
|
+static int N_VERSIONS = Version::buildVersions();
|
|
|
+
|
|
|
+int Version::getVersionNumber() {
|
|
|
+ return versionNumber_;
|
|
|
+}
|
|
|
+
|
|
|
+vector<int> &Version::getAlignmentPatternCenters() {
|
|
|
+ return alignmentPatternCenters_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getTotalCodewords() {
|
|
|
+ return totalCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::getDimensionForVersion() {
|
|
|
+ return 17 + 4 * versionNumber_;
|
|
|
+}
|
|
|
+
|
|
|
+ECBlocks& Version::getECBlocksForLevel(ErrorCorrectionLevel &ecLevel) {
|
|
|
+ return *ecBlocks_[ecLevel.ordinal()];
|
|
|
+}
|
|
|
+
|
|
|
+Version *Version::getProvisionalVersionForDimension(int dimension) {
|
|
|
+ if (dimension % 4 != 1) {
|
|
|
+ throw ReaderException("Dimension must be 1 mod 4");
|
|
|
+ }
|
|
|
+ return Version::getVersionForNumber((dimension - 17) >> 2);
|
|
|
+}
|
|
|
+
|
|
|
+Version *Version::getVersionForNumber(int versionNumber) {
|
|
|
+ if (versionNumber < 1 || versionNumber > N_VERSIONS) {
|
|
|
+ throw ReaderException("versionNumber must be between 1 and 40");
|
|
|
+ }
|
|
|
+
|
|
|
+ return VERSIONS[versionNumber - 1];
|
|
|
+}
|
|
|
+
|
|
|
+Version::Version(int versionNumber, vector<int> *alignmentPatternCenters, ECBlocks *ecBlocks1, ECBlocks *ecBlocks2,
|
|
|
+ ECBlocks *ecBlocks3, ECBlocks *ecBlocks4) :
|
|
|
+ versionNumber_(versionNumber), alignmentPatternCenters_(*alignmentPatternCenters), ecBlocks_(4), totalCodewords_(0) {
|
|
|
+ ecBlocks_[0] = ecBlocks1;
|
|
|
+ ecBlocks_[1] = ecBlocks2;
|
|
|
+ ecBlocks_[2] = ecBlocks3;
|
|
|
+ ecBlocks_[3] = ecBlocks4;
|
|
|
+
|
|
|
+ int total = 0;
|
|
|
+ int ecCodewords = ecBlocks1->getECCodewords();
|
|
|
+ vector<ECB*> &ecbArray = ecBlocks1->getECBlocks();
|
|
|
+ for (size_t i = 0; i < ecbArray.size(); i++) {
|
|
|
+ ECB *ecBlock = ecbArray[i];
|
|
|
+ total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
|
|
|
+ }
|
|
|
+ totalCodewords_ = total;
|
|
|
+}
|
|
|
+
|
|
|
+Version::~Version() {
|
|
|
+ delete &alignmentPatternCenters_;
|
|
|
+ for (size_t i = 0; i < ecBlocks_.size(); i++) {
|
|
|
+ delete ecBlocks_[i];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Version *Version::decodeVersionInformation(unsigned int versionBits) {
|
|
|
+ int bestDifference = numeric_limits<int>::max();
|
|
|
+ size_t bestVersion = 0;
|
|
|
+ for (int i = 0; i < N_VERSION_DECODE_INFOS; i++) {
|
|
|
+ unsigned targetVersion = VERSION_DECODE_INFO[i];
|
|
|
+ // Do the version info bits match exactly? done.
|
|
|
+ if (targetVersion == versionBits) {
|
|
|
+ return getVersionForNumber(i + 7);
|
|
|
+ }
|
|
|
+ // Otherwise see if this is the closest to a real version info bit
|
|
|
+ // string we have seen so far
|
|
|
+ int bitsDifference = FormatInformation::numBitsDiffering(versionBits, targetVersion);
|
|
|
+ if (bitsDifference < bestDifference) {
|
|
|
+ bestVersion = i + 7;
|
|
|
+ bestDifference = bitsDifference;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // We can tolerate up to 3 bits of error since no two version info codewords will
|
|
|
+ // differ in less than 4 bits.
|
|
|
+ if (bestDifference <= 3) {
|
|
|
+ return getVersionForNumber(bestVersion);
|
|
|
+ }
|
|
|
+ // If we didn't find a close enough match, fail
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> Version::buildFunctionPattern() {
|
|
|
+ int dimension = getDimensionForVersion();
|
|
|
+ Ref<BitMatrix> functionPattern(new BitMatrix(dimension));
|
|
|
+
|
|
|
+
|
|
|
+ // Top left finder pattern + separator + format
|
|
|
+ functionPattern->setRegion(0, 0, 9, 9);
|
|
|
+ // Top right finder pattern + separator + format
|
|
|
+ functionPattern->setRegion(dimension - 8, 0, 8, 9);
|
|
|
+ // Bottom left finder pattern + separator + format
|
|
|
+ functionPattern->setRegion(0, dimension - 8, 9, 8);
|
|
|
+
|
|
|
+
|
|
|
+ // Alignment patterns
|
|
|
+ size_t max = alignmentPatternCenters_.size();
|
|
|
+ for (size_t x = 0; x < max; x++) {
|
|
|
+ int i = alignmentPatternCenters_[x] - 2;
|
|
|
+ for (size_t y = 0; y < max; y++) {
|
|
|
+ if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
|
|
|
+ // No alignment patterns near the three finder patterns
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ functionPattern->setRegion(alignmentPatternCenters_[y] - 2, i, 5, 5);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Vertical timing pattern
|
|
|
+ functionPattern->setRegion(6, 9, 1, dimension - 17);
|
|
|
+ // Horizontal timing pattern
|
|
|
+ functionPattern->setRegion(9, 6, dimension - 17, 1);
|
|
|
+
|
|
|
+ if (versionNumber_ > 6) {
|
|
|
+ // Version info, top right
|
|
|
+ functionPattern->setRegion(dimension - 11, 0, 3, 6);
|
|
|
+ // Version info, bottom left
|
|
|
+ functionPattern->setRegion(0, dimension - 11, 6, 3);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ //#ifdef DEBUG
|
|
|
+ // cout << "version " << versionNumber_ << " built function pattern:\n";
|
|
|
+ // cout << *functionPattern;
|
|
|
+ //#endif
|
|
|
+
|
|
|
+ return functionPattern;
|
|
|
+}
|
|
|
+
|
|
|
+static vector<int> *intArray(size_t n...) {
|
|
|
+ va_list ap;
|
|
|
+ va_start(ap, n);
|
|
|
+ vector<int> *result = new vector<int>(n);
|
|
|
+ for (size_t i = 0; i < n; i++) {
|
|
|
+ (*result)[i] = va_arg(ap, int);
|
|
|
+ }
|
|
|
+ va_end(ap);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+int Version::buildVersions() {
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(1, intArray(0),
|
|
|
+ new ECBlocks(7, new ECB(1, 19)),
|
|
|
+ new ECBlocks(10, new ECB(1, 16)),
|
|
|
+ new ECBlocks(13, new ECB(1, 13)),
|
|
|
+ new ECBlocks(17, new ECB(1, 9)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(2, intArray(2, 6, 18),
|
|
|
+ new ECBlocks(10, new ECB(1, 34)),
|
|
|
+ new ECBlocks(16, new ECB(1, 28)),
|
|
|
+ new ECBlocks(22, new ECB(1, 22)),
|
|
|
+ new ECBlocks(28, new ECB(1, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(3, intArray(2, 6, 22),
|
|
|
+ new ECBlocks(15, new ECB(1, 55)),
|
|
|
+ new ECBlocks(26, new ECB(1, 44)),
|
|
|
+ new ECBlocks(18, new ECB(2, 17)),
|
|
|
+ new ECBlocks(22, new ECB(2, 13)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(4, intArray(2, 6, 26),
|
|
|
+ new ECBlocks(20, new ECB(1, 80)),
|
|
|
+ new ECBlocks(18, new ECB(2, 32)),
|
|
|
+ new ECBlocks(26, new ECB(2, 24)),
|
|
|
+ new ECBlocks(16, new ECB(4, 9)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(5, intArray(2, 6, 30),
|
|
|
+ new ECBlocks(26, new ECB(1, 108)),
|
|
|
+ new ECBlocks(24, new ECB(2, 43)),
|
|
|
+ new ECBlocks(18, new ECB(2, 15),
|
|
|
+ new ECB(2, 16)),
|
|
|
+ new ECBlocks(22, new ECB(2, 11),
|
|
|
+ new ECB(2, 12)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(6, intArray(2, 6, 34),
|
|
|
+ new ECBlocks(18, new ECB(2, 68)),
|
|
|
+ new ECBlocks(16, new ECB(4, 27)),
|
|
|
+ new ECBlocks(24, new ECB(4, 19)),
|
|
|
+ new ECBlocks(28, new ECB(4, 15)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(7, intArray(3, 6, 22, 38),
|
|
|
+ new ECBlocks(20, new ECB(2, 78)),
|
|
|
+ new ECBlocks(18, new ECB(4, 31)),
|
|
|
+ new ECBlocks(18, new ECB(2, 14),
|
|
|
+ new ECB(4, 15)),
|
|
|
+ new ECBlocks(26, new ECB(4, 13),
|
|
|
+ new ECB(1, 14)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(8, intArray(3, 6, 24, 42),
|
|
|
+ new ECBlocks(24, new ECB(2, 97)),
|
|
|
+ new ECBlocks(22, new ECB(2, 38),
|
|
|
+ new ECB(2, 39)),
|
|
|
+ new ECBlocks(22, new ECB(4, 18),
|
|
|
+ new ECB(2, 19)),
|
|
|
+ new ECBlocks(26, new ECB(4, 14),
|
|
|
+ new ECB(2, 15)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(9, intArray(3, 6, 26, 46),
|
|
|
+ new ECBlocks(30, new ECB(2, 116)),
|
|
|
+ new ECBlocks(22, new ECB(3, 36),
|
|
|
+ new ECB(2, 37)),
|
|
|
+ new ECBlocks(20, new ECB(4, 16),
|
|
|
+ new ECB(4, 17)),
|
|
|
+ new ECBlocks(24, new ECB(4, 12),
|
|
|
+ new ECB(4, 13)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(10, intArray(3, 6, 28, 50),
|
|
|
+ new ECBlocks(18, new ECB(2, 68),
|
|
|
+ new ECB(2, 69)),
|
|
|
+ new ECBlocks(26, new ECB(4, 43),
|
|
|
+ new ECB(1, 44)),
|
|
|
+ new ECBlocks(24, new ECB(6, 19),
|
|
|
+ new ECB(2, 20)),
|
|
|
+ new ECBlocks(28, new ECB(6, 15),
|
|
|
+ new ECB(2, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(11, intArray(3, 6, 30, 54),
|
|
|
+ new ECBlocks(20, new ECB(4, 81)),
|
|
|
+ new ECBlocks(30, new ECB(1, 50),
|
|
|
+ new ECB(4, 51)),
|
|
|
+ new ECBlocks(28, new ECB(4, 22),
|
|
|
+ new ECB(4, 23)),
|
|
|
+ new ECBlocks(24, new ECB(3, 12),
|
|
|
+ new ECB(8, 13)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(12, intArray(3, 6, 32, 58),
|
|
|
+ new ECBlocks(24, new ECB(2, 92),
|
|
|
+ new ECB(2, 93)),
|
|
|
+ new ECBlocks(22, new ECB(6, 36),
|
|
|
+ new ECB(2, 37)),
|
|
|
+ new ECBlocks(26, new ECB(4, 20),
|
|
|
+ new ECB(6, 21)),
|
|
|
+ new ECBlocks(28, new ECB(7, 14),
|
|
|
+ new ECB(4, 15)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(13, intArray(3, 6, 34, 62),
|
|
|
+ new ECBlocks(26, new ECB(4, 107)),
|
|
|
+ new ECBlocks(22, new ECB(8, 37),
|
|
|
+ new ECB(1, 38)),
|
|
|
+ new ECBlocks(24, new ECB(8, 20),
|
|
|
+ new ECB(4, 21)),
|
|
|
+ new ECBlocks(22, new ECB(12, 11),
|
|
|
+ new ECB(4, 12)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(14, intArray(4, 6, 26, 46, 66),
|
|
|
+ new ECBlocks(30, new ECB(3, 115),
|
|
|
+ new ECB(1, 116)),
|
|
|
+ new ECBlocks(24, new ECB(4, 40),
|
|
|
+ new ECB(5, 41)),
|
|
|
+ new ECBlocks(20, new ECB(11, 16),
|
|
|
+ new ECB(5, 17)),
|
|
|
+ new ECBlocks(24, new ECB(11, 12),
|
|
|
+ new ECB(5, 13)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(15, intArray(4, 6, 26, 48, 70),
|
|
|
+ new ECBlocks(22, new ECB(5, 87),
|
|
|
+ new ECB(1, 88)),
|
|
|
+ new ECBlocks(24, new ECB(5, 41),
|
|
|
+ new ECB(5, 42)),
|
|
|
+ new ECBlocks(30, new ECB(5, 24),
|
|
|
+ new ECB(7, 25)),
|
|
|
+ new ECBlocks(24, new ECB(11, 12),
|
|
|
+ new ECB(7, 13)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(16, intArray(4, 6, 26, 50, 74),
|
|
|
+ new ECBlocks(24, new ECB(5, 98),
|
|
|
+ new ECB(1, 99)),
|
|
|
+ new ECBlocks(28, new ECB(7, 45),
|
|
|
+ new ECB(3, 46)),
|
|
|
+ new ECBlocks(24, new ECB(15, 19),
|
|
|
+ new ECB(2, 20)),
|
|
|
+ new ECBlocks(30, new ECB(3, 15),
|
|
|
+ new ECB(13, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(17, intArray(4, 6, 30, 54, 78),
|
|
|
+ new ECBlocks(28, new ECB(1, 107),
|
|
|
+ new ECB(5, 108)),
|
|
|
+ new ECBlocks(28, new ECB(10, 46),
|
|
|
+ new ECB(1, 47)),
|
|
|
+ new ECBlocks(28, new ECB(1, 22),
|
|
|
+ new ECB(15, 23)),
|
|
|
+ new ECBlocks(28, new ECB(2, 14),
|
|
|
+ new ECB(17, 15)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(18, intArray(4, 6, 30, 56, 82),
|
|
|
+ new ECBlocks(30, new ECB(5, 120),
|
|
|
+ new ECB(1, 121)),
|
|
|
+ new ECBlocks(26, new ECB(9, 43),
|
|
|
+ new ECB(4, 44)),
|
|
|
+ new ECBlocks(28, new ECB(17, 22),
|
|
|
+ new ECB(1, 23)),
|
|
|
+ new ECBlocks(28, new ECB(2, 14),
|
|
|
+ new ECB(19, 15)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(19, intArray(4, 6, 30, 58, 86),
|
|
|
+ new ECBlocks(28, new ECB(3, 113),
|
|
|
+ new ECB(4, 114)),
|
|
|
+ new ECBlocks(26, new ECB(3, 44),
|
|
|
+ new ECB(11, 45)),
|
|
|
+ new ECBlocks(26, new ECB(17, 21),
|
|
|
+ new ECB(4, 22)),
|
|
|
+ new ECBlocks(26, new ECB(9, 13),
|
|
|
+ new ECB(16, 14)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(20, intArray(4, 6, 34, 62, 90),
|
|
|
+ new ECBlocks(28, new ECB(3, 107),
|
|
|
+ new ECB(5, 108)),
|
|
|
+ new ECBlocks(26, new ECB(3, 41),
|
|
|
+ new ECB(13, 42)),
|
|
|
+ new ECBlocks(30, new ECB(15, 24),
|
|
|
+ new ECB(5, 25)),
|
|
|
+ new ECBlocks(28, new ECB(15, 15),
|
|
|
+ new ECB(10, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(21, intArray(5, 6, 28, 50, 72, 94),
|
|
|
+ new ECBlocks(28, new ECB(4, 116),
|
|
|
+ new ECB(4, 117)),
|
|
|
+ new ECBlocks(26, new ECB(17, 42)),
|
|
|
+ new ECBlocks(28, new ECB(17, 22),
|
|
|
+ new ECB(6, 23)),
|
|
|
+ new ECBlocks(30, new ECB(19, 16),
|
|
|
+ new ECB(6, 17)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(22, intArray(5, 6, 26, 50, 74, 98),
|
|
|
+ new ECBlocks(28, new ECB(2, 111),
|
|
|
+ new ECB(7, 112)),
|
|
|
+ new ECBlocks(28, new ECB(17, 46)),
|
|
|
+ new ECBlocks(30, new ECB(7, 24),
|
|
|
+ new ECB(16, 25)),
|
|
|
+ new ECBlocks(24, new ECB(34, 13)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(23, intArray(5, 6, 30, 54, 78, 102),
|
|
|
+ new ECBlocks(30, new ECB(4, 121),
|
|
|
+ new ECB(5, 122)),
|
|
|
+ new ECBlocks(28, new ECB(4, 47),
|
|
|
+ new ECB(14, 48)),
|
|
|
+ new ECBlocks(30, new ECB(11, 24),
|
|
|
+ new ECB(14, 25)),
|
|
|
+ new ECBlocks(30, new ECB(16, 15),
|
|
|
+ new ECB(14, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(24, intArray(5, 6, 28, 54, 80, 106),
|
|
|
+ new ECBlocks(30, new ECB(6, 117),
|
|
|
+ new ECB(4, 118)),
|
|
|
+ new ECBlocks(28, new ECB(6, 45),
|
|
|
+ new ECB(14, 46)),
|
|
|
+ new ECBlocks(30, new ECB(11, 24),
|
|
|
+ new ECB(16, 25)),
|
|
|
+ new ECBlocks(30, new ECB(30, 16),
|
|
|
+ new ECB(2, 17)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(25, intArray(5, 6, 32, 58, 84, 110),
|
|
|
+ new ECBlocks(26, new ECB(8, 106),
|
|
|
+ new ECB(4, 107)),
|
|
|
+ new ECBlocks(28, new ECB(8, 47),
|
|
|
+ new ECB(13, 48)),
|
|
|
+ new ECBlocks(30, new ECB(7, 24),
|
|
|
+ new ECB(22, 25)),
|
|
|
+ new ECBlocks(30, new ECB(22, 15),
|
|
|
+ new ECB(13, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(26, intArray(5, 6, 30, 58, 86, 114),
|
|
|
+ new ECBlocks(28, new ECB(10, 114),
|
|
|
+ new ECB(2, 115)),
|
|
|
+ new ECBlocks(28, new ECB(19, 46),
|
|
|
+ new ECB(4, 47)),
|
|
|
+ new ECBlocks(28, new ECB(28, 22),
|
|
|
+ new ECB(6, 23)),
|
|
|
+ new ECBlocks(30, new ECB(33, 16),
|
|
|
+ new ECB(4, 17)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(27, intArray(5, 6, 34, 62, 90, 118),
|
|
|
+ new ECBlocks(30, new ECB(8, 122),
|
|
|
+ new ECB(4, 123)),
|
|
|
+ new ECBlocks(28, new ECB(22, 45),
|
|
|
+ new ECB(3, 46)),
|
|
|
+ new ECBlocks(30, new ECB(8, 23),
|
|
|
+ new ECB(26, 24)),
|
|
|
+ new ECBlocks(30, new ECB(12, 15),
|
|
|
+ new ECB(28, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(28, intArray(6, 6, 26, 50, 74, 98, 122),
|
|
|
+ new ECBlocks(30, new ECB(3, 117),
|
|
|
+ new ECB(10, 118)),
|
|
|
+ new ECBlocks(28, new ECB(3, 45),
|
|
|
+ new ECB(23, 46)),
|
|
|
+ new ECBlocks(30, new ECB(4, 24),
|
|
|
+ new ECB(31, 25)),
|
|
|
+ new ECBlocks(30, new ECB(11, 15),
|
|
|
+ new ECB(31, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(29, intArray(6, 6, 30, 54, 78, 102, 126),
|
|
|
+ new ECBlocks(30, new ECB(7, 116),
|
|
|
+ new ECB(7, 117)),
|
|
|
+ new ECBlocks(28, new ECB(21, 45),
|
|
|
+ new ECB(7, 46)),
|
|
|
+ new ECBlocks(30, new ECB(1, 23),
|
|
|
+ new ECB(37, 24)),
|
|
|
+ new ECBlocks(30, new ECB(19, 15),
|
|
|
+ new ECB(26, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(30, intArray(6, 6, 26, 52, 78, 104, 130),
|
|
|
+ new ECBlocks(30, new ECB(5, 115),
|
|
|
+ new ECB(10, 116)),
|
|
|
+ new ECBlocks(28, new ECB(19, 47),
|
|
|
+ new ECB(10, 48)),
|
|
|
+ new ECBlocks(30, new ECB(15, 24),
|
|
|
+ new ECB(25, 25)),
|
|
|
+ new ECBlocks(30, new ECB(23, 15),
|
|
|
+ new ECB(25, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(31, intArray(6, 6, 30, 56, 82, 108, 134),
|
|
|
+ new ECBlocks(30, new ECB(13, 115),
|
|
|
+ new ECB(3, 116)),
|
|
|
+ new ECBlocks(28, new ECB(2, 46),
|
|
|
+ new ECB(29, 47)),
|
|
|
+ new ECBlocks(30, new ECB(42, 24),
|
|
|
+ new ECB(1, 25)),
|
|
|
+ new ECBlocks(30, new ECB(23, 15),
|
|
|
+ new ECB(28, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(32, intArray(6, 6, 34, 60, 86, 112, 138),
|
|
|
+ new ECBlocks(30, new ECB(17, 115)),
|
|
|
+ new ECBlocks(28, new ECB(10, 46),
|
|
|
+ new ECB(23, 47)),
|
|
|
+ new ECBlocks(30, new ECB(10, 24),
|
|
|
+ new ECB(35, 25)),
|
|
|
+ new ECBlocks(30, new ECB(19, 15),
|
|
|
+ new ECB(35, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(33, intArray(6, 6, 30, 58, 86, 114, 142),
|
|
|
+ new ECBlocks(30, new ECB(17, 115),
|
|
|
+ new ECB(1, 116)),
|
|
|
+ new ECBlocks(28, new ECB(14, 46),
|
|
|
+ new ECB(21, 47)),
|
|
|
+ new ECBlocks(30, new ECB(29, 24),
|
|
|
+ new ECB(19, 25)),
|
|
|
+ new ECBlocks(30, new ECB(11, 15),
|
|
|
+ new ECB(46, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(34, intArray(6, 6, 34, 62, 90, 118, 146),
|
|
|
+ new ECBlocks(30, new ECB(13, 115),
|
|
|
+ new ECB(6, 116)),
|
|
|
+ new ECBlocks(28, new ECB(14, 46),
|
|
|
+ new ECB(23, 47)),
|
|
|
+ new ECBlocks(30, new ECB(44, 24),
|
|
|
+ new ECB(7, 25)),
|
|
|
+ new ECBlocks(30, new ECB(59, 16),
|
|
|
+ new ECB(1, 17)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(35, intArray(7, 6, 30, 54, 78,
|
|
|
+ 102, 126, 150),
|
|
|
+ new ECBlocks(30, new ECB(12, 121),
|
|
|
+ new ECB(7, 122)),
|
|
|
+ new ECBlocks(28, new ECB(12, 47),
|
|
|
+ new ECB(26, 48)),
|
|
|
+ new ECBlocks(30, new ECB(39, 24),
|
|
|
+ new ECB(14, 25)),
|
|
|
+ new ECBlocks(30, new ECB(22, 15),
|
|
|
+ new ECB(41, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(36, intArray(7, 6, 24, 50, 76,
|
|
|
+ 102, 128, 154),
|
|
|
+ new ECBlocks(30, new ECB(6, 121),
|
|
|
+ new ECB(14, 122)),
|
|
|
+ new ECBlocks(28, new ECB(6, 47),
|
|
|
+ new ECB(34, 48)),
|
|
|
+ new ECBlocks(30, new ECB(46, 24),
|
|
|
+ new ECB(10, 25)),
|
|
|
+ new ECBlocks(30, new ECB(2, 15),
|
|
|
+ new ECB(64, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(37, intArray(7, 6, 28, 54, 80,
|
|
|
+ 106, 132, 158),
|
|
|
+ new ECBlocks(30, new ECB(17, 122),
|
|
|
+ new ECB(4, 123)),
|
|
|
+ new ECBlocks(28, new ECB(29, 46),
|
|
|
+ new ECB(14, 47)),
|
|
|
+ new ECBlocks(30, new ECB(49, 24),
|
|
|
+ new ECB(10, 25)),
|
|
|
+ new ECBlocks(30, new ECB(24, 15),
|
|
|
+ new ECB(46, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(38, intArray(7, 6, 32, 58, 84,
|
|
|
+ 110, 136, 162),
|
|
|
+ new ECBlocks(30, new ECB(4, 122),
|
|
|
+ new ECB(18, 123)),
|
|
|
+ new ECBlocks(28, new ECB(13, 46),
|
|
|
+ new ECB(32, 47)),
|
|
|
+ new ECBlocks(30, new ECB(48, 24),
|
|
|
+ new ECB(14, 25)),
|
|
|
+ new ECBlocks(30, new ECB(42, 15),
|
|
|
+ new ECB(32, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(39, intArray(7, 6, 26, 54, 82,
|
|
|
+ 110, 138, 166),
|
|
|
+ new ECBlocks(30, new ECB(20, 117),
|
|
|
+ new ECB(4, 118)),
|
|
|
+ new ECBlocks(28, new ECB(40, 47),
|
|
|
+ new ECB(7, 48)),
|
|
|
+ new ECBlocks(30, new ECB(43, 24),
|
|
|
+ new ECB(22, 25)),
|
|
|
+ new ECBlocks(30, new ECB(10, 15),
|
|
|
+ new ECB(67, 16)))));
|
|
|
+ VERSIONS.push_back(Ref<Version>(new Version(40, intArray(7, 6, 30, 58, 86,
|
|
|
+ 114, 142, 170),
|
|
|
+ new ECBlocks(30, new ECB(19, 118),
|
|
|
+ new ECB(6, 119)),
|
|
|
+ new ECBlocks(28, new ECB(18, 47),
|
|
|
+ new ECB(31, 48)),
|
|
|
+ new ECBlocks(30, new ECB(34, 24),
|
|
|
+ new ECB(34, 25)),
|
|
|
+ new ECBlocks(30, new ECB(20, 15),
|
|
|
+ new ECB(61, 16)))));
|
|
|
+ return VERSIONS.size();
|
|
|
+}
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/decoder/BitMatrixParser.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * BitMatrixParser.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/BitMatrixParser.h>
|
|
|
+// #include <zxing/qrcode/decoder/DataMask.h>
|
|
|
+
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+int BitMatrixParser::copyBit(size_t x, size_t y, int versionBits) {
|
|
|
+ return bitMatrix_->get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1;
|
|
|
+}
|
|
|
+
|
|
|
+BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix) :
|
|
|
+ bitMatrix_(bitMatrix), parsedVersion_(0), parsedFormatInfo_() {
|
|
|
+ size_t dimension = bitMatrix->getDimension();
|
|
|
+ if ((dimension < 21) || (dimension & 0x03) != 1) {
|
|
|
+ throw ReaderException("Dimension must be 1 mod 4 and >= 21");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<FormatInformation> BitMatrixParser::readFormatInformation() {
|
|
|
+ if (parsedFormatInfo_ != 0) {
|
|
|
+ return parsedFormatInfo_;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Read top-left format info bits
|
|
|
+ int formatInfoBits1 = 0;
|
|
|
+ for (int i = 0; i < 6; i++) {
|
|
|
+ formatInfoBits1 = copyBit(i, 8, formatInfoBits1);
|
|
|
+ }
|
|
|
+ // .. and skip a bit in the timing pattern ...
|
|
|
+ formatInfoBits1 = copyBit(7, 8, formatInfoBits1);
|
|
|
+ formatInfoBits1 = copyBit(8, 8, formatInfoBits1);
|
|
|
+ formatInfoBits1 = copyBit(8, 7, formatInfoBits1);
|
|
|
+ // .. and skip a bit in the timing pattern ...
|
|
|
+ for (int j = 5; j >= 0; j--) {
|
|
|
+ formatInfoBits1 = copyBit(8, j, formatInfoBits1);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Read the top-right/bottom-left pattern
|
|
|
+ int dimension = bitMatrix_->getDimension();
|
|
|
+ int formatInfoBits2 = 0;
|
|
|
+ int jMin = dimension - 7;
|
|
|
+ for (int j = dimension - 1; j >= jMin; j--) {
|
|
|
+ formatInfoBits2 = copyBit(8, j, formatInfoBits2);
|
|
|
+ }
|
|
|
+ for (int i = dimension - 8; i < dimension; i++) {
|
|
|
+ formatInfoBits2 = copyBit(i, 8, formatInfoBits2);
|
|
|
+ }
|
|
|
+
|
|
|
+ parsedFormatInfo_ = FormatInformation::decodeFormatInformation(formatInfoBits1,formatInfoBits2);
|
|
|
+ if (parsedFormatInfo_ != 0) {
|
|
|
+ return parsedFormatInfo_;
|
|
|
+ }
|
|
|
+ throw ReaderException("Could not decode format information");
|
|
|
+}
|
|
|
+
|
|
|
+Version *BitMatrixParser::readVersion() {
|
|
|
+ if (parsedVersion_ != 0) {
|
|
|
+ return parsedVersion_;
|
|
|
+ }
|
|
|
+
|
|
|
+ int dimension = bitMatrix_->getDimension();
|
|
|
+
|
|
|
+ int provisionalVersion = (dimension - 17) >> 2;
|
|
|
+ if (provisionalVersion <= 6) {
|
|
|
+ return Version::getVersionForNumber(provisionalVersion);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Read top-right version info: 3 wide by 6 tall
|
|
|
+ int versionBits = 0;
|
|
|
+ for (int y = 5; y >= 0; y--) {
|
|
|
+ int xMin = dimension - 11;
|
|
|
+ for (int x = dimension - 9; x >= xMin; x--) {
|
|
|
+ versionBits = copyBit(x, y, versionBits);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ parsedVersion_ = Version::decodeVersionInformation(versionBits);
|
|
|
+ if (parsedVersion_ != 0 && parsedVersion_->getDimensionForVersion() == dimension) {
|
|
|
+ return parsedVersion_;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Hmm, failed. Try bottom left: 6 wide by 3 tall
|
|
|
+ versionBits = 0;
|
|
|
+ for (int x = 5; x >= 0; x--) {
|
|
|
+ int yMin = dimension - 11;
|
|
|
+ for (int y = dimension - 9; y >= yMin; y--) {
|
|
|
+ versionBits = copyBit(x, y, versionBits);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ parsedVersion_ = Version::decodeVersionInformation(versionBits);
|
|
|
+ if (parsedVersion_ != 0 && parsedVersion_->getDimensionForVersion() == dimension) {
|
|
|
+ return parsedVersion_;
|
|
|
+ }
|
|
|
+ throw ReaderException("Could not decode version");
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<unsigned char> BitMatrixParser::readCodewords() {
|
|
|
+ Ref<FormatInformation> formatInfo = readFormatInformation();
|
|
|
+ Version *version = readVersion();
|
|
|
+
|
|
|
+
|
|
|
+ // cerr << *bitMatrix_ << endl;
|
|
|
+ // cerr << bitMatrix_->getDimension() << endl;
|
|
|
+
|
|
|
+ // Get the data mask for the format used in this QR Code. This will exclude
|
|
|
+ // some bits from reading as we wind through the bit matrix.
|
|
|
+ DataMask &dataMask = DataMask::forReference((int)formatInfo->getDataMask());
|
|
|
+ // cout << (int)formatInfo->getDataMask() << endl;
|
|
|
+ int dimension = bitMatrix_->getDimension();
|
|
|
+ dataMask.unmaskBitMatrix(*bitMatrix_, dimension);
|
|
|
+
|
|
|
+
|
|
|
+ // cerr << *bitMatrix_ << endl;
|
|
|
+ // cerr << version->getTotalCodewords() << endl;
|
|
|
+
|
|
|
+ Ref<BitMatrix> functionPattern = version->buildFunctionPattern();
|
|
|
+
|
|
|
+
|
|
|
+ // cout << *functionPattern << endl;
|
|
|
+
|
|
|
+ bool readingUp = true;
|
|
|
+ ArrayRef<unsigned char> result(version->getTotalCodewords());
|
|
|
+ int resultOffset = 0;
|
|
|
+ int currentByte = 0;
|
|
|
+ int bitsRead = 0;
|
|
|
+ // Read columns in pairs, from right to left
|
|
|
+ for (int x = dimension - 1; x > 0; x -= 2) {
|
|
|
+ if (x == 6) {
|
|
|
+ // Skip whole column with vertical alignment pattern;
|
|
|
+ // saves time and makes the other code proceed more cleanly
|
|
|
+ x--;
|
|
|
+ }
|
|
|
+ // Read alternatingly from bottom to top then top to bottom
|
|
|
+ for (int counter = 0; counter < dimension; counter++) {
|
|
|
+ int y = readingUp ? dimension - 1 - counter : counter;
|
|
|
+ for (int col = 0; col < 2; col++) {
|
|
|
+ // Ignore bits covered by the function pattern
|
|
|
+ if (!functionPattern->get(x - col, y)) {
|
|
|
+ // Read a bit
|
|
|
+ bitsRead++;
|
|
|
+ currentByte <<= 1;
|
|
|
+ if (bitMatrix_->get(x - col, y)) {
|
|
|
+ currentByte |= 1;
|
|
|
+ }
|
|
|
+ // If we've made a whole byte, save it off
|
|
|
+ if (bitsRead == 8) {
|
|
|
+ result[resultOffset++] = (unsigned char)currentByte;
|
|
|
+ bitsRead = 0;
|
|
|
+ currentByte = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ readingUp = !readingUp; // switch directions
|
|
|
+ }
|
|
|
+
|
|
|
+ if (resultOffset != version->getTotalCodewords()) {
|
|
|
+ throw ReaderException("Did not read all codewords");
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/decoder/DataBlock.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * DataBlock.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/qrcode/decoder/DataBlock.h>
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+DataBlock::DataBlock(int numDataCodewords, ArrayRef<unsigned char> codewords) :
|
|
|
+ numDataCodewords_(numDataCodewords), codewords_(codewords) {
|
|
|
+}
|
|
|
+
|
|
|
+int DataBlock::getNumDataCodewords() {
|
|
|
+ return numDataCodewords_;
|
|
|
+}
|
|
|
+
|
|
|
+ArrayRef<unsigned char> DataBlock::getCodewords() {
|
|
|
+ return codewords_;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+std::vector<Ref<DataBlock> > DataBlock::getDataBlocks(ArrayRef<unsigned char> rawCodewords, Version *version,
|
|
|
+ ErrorCorrectionLevel &ecLevel) {
|
|
|
+
|
|
|
+
|
|
|
+ // Figure out the number and size of data blocks used by this version and
|
|
|
+ // error correction level
|
|
|
+ ECBlocks &ecBlocks = version->getECBlocksForLevel(ecLevel);
|
|
|
+
|
|
|
+
|
|
|
+ // First count the total number of data blocks
|
|
|
+ int totalBlocks = 0;
|
|
|
+ vector<ECB*> ecBlockArray = ecBlocks.getECBlocks();
|
|
|
+ for (size_t i = 0; i < ecBlockArray.size(); i++) {
|
|
|
+ totalBlocks += ecBlockArray[i]->getCount();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Now establish DataBlocks of the appropriate size and number of data codewords
|
|
|
+ std::vector<Ref<DataBlock> > result(totalBlocks);
|
|
|
+ int numResultBlocks = 0;
|
|
|
+ for (size_t j = 0; j < ecBlockArray.size(); j++) {
|
|
|
+ ECB *ecBlock = ecBlockArray[j];
|
|
|
+ for (int i = 0; i < ecBlock->getCount(); i++) {
|
|
|
+ int numDataCodewords = ecBlock->getDataCodewords();
|
|
|
+ int numBlockCodewords = ecBlocks.getECCodewords() + numDataCodewords;
|
|
|
+ ArrayRef<unsigned char> buffer(numBlockCodewords);
|
|
|
+ Ref<DataBlock> blockRef(new DataBlock(numDataCodewords, buffer));
|
|
|
+ result[numResultBlocks++] = blockRef;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // All blocks have the same amount of data, except that the last n
|
|
|
+ // (where n may be 0) have 1 more byte. Figure out where these start.
|
|
|
+ int shorterBlocksTotalCodewords = result[0]->codewords_.size();
|
|
|
+ int longerBlocksStartAt = result.size() - 1;
|
|
|
+ while (longerBlocksStartAt >= 0) {
|
|
|
+ int numCodewords = result[longerBlocksStartAt]->codewords_.size();
|
|
|
+ if (numCodewords == shorterBlocksTotalCodewords) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (numCodewords != shorterBlocksTotalCodewords + 1) {
|
|
|
+ throw IllegalArgumentException("Data block sizes differ by more than 1");
|
|
|
+ }
|
|
|
+ longerBlocksStartAt--;
|
|
|
+ }
|
|
|
+ longerBlocksStartAt++;
|
|
|
+
|
|
|
+ int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.getECCodewords();
|
|
|
+ // The last elements of result may be 1 element longer;
|
|
|
+ // first fill out as many elements as all of them have
|
|
|
+ int rawCodewordsOffset = 0;
|
|
|
+ for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
|
|
|
+ for (int j = 0; j < numResultBlocks; j++) {
|
|
|
+ result[j]->codewords_[i] = rawCodewords[rawCodewordsOffset++];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Fill out the last data block in the longer ones
|
|
|
+ for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
|
|
|
+ result[j]->codewords_[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
|
|
|
+ }
|
|
|
+ // Now add in error correction blocks
|
|
|
+ int max = result[0]->codewords_.size();
|
|
|
+ for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
|
|
|
+ for (int j = 0; j < numResultBlocks; j++) {
|
|
|
+ int iOffset = j < longerBlocksStartAt ? i : i + 1;
|
|
|
+ result[j]->codewords_[iOffset] = rawCodewords[rawCodewordsOffset++];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((size_t)rawCodewordsOffset != rawCodewords.size()) {
|
|
|
+ throw IllegalArgumentException("rawCodewordsOffset != rawCodewords.length");
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/decoder/DataMask.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * DataMask.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/qrcode/decoder/DataMask.h>
|
|
|
+
|
|
|
+// #include <zxing/common/IllegalArgumentException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+DataMask::DataMask() {
|
|
|
+}
|
|
|
+
|
|
|
+DataMask::~DataMask() {
|
|
|
+}
|
|
|
+
|
|
|
+vector<Ref<DataMask> > DataMask::DATA_MASKS;
|
|
|
+static int N_DATA_MASKS = DataMask::buildDataMasks();
|
|
|
+
|
|
|
+DataMask &DataMask::forReference(int reference) {
|
|
|
+ if (reference < 0 || reference > 7) {
|
|
|
+ throw IllegalArgumentException("reference must be between 0 and 7");
|
|
|
+ }
|
|
|
+ return *DATA_MASKS[reference];
|
|
|
+}
|
|
|
+
|
|
|
+void DataMask::unmaskBitMatrix(BitMatrix& bits, size_t dimension) {
|
|
|
+ for (size_t y = 0; y < dimension; y++) {
|
|
|
+ for (size_t x = 0; x < dimension; x++) {
|
|
|
+ // TODO: check why the coordinates have to be swapped
|
|
|
+ if (isMasked(y, x)) {
|
|
|
+ bits.flip(x, y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 000: mask bits for which (x + y) mod 2 == 0
|
|
|
+ */
|
|
|
+class DataMask000 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t y) {
|
|
|
+ // return ((x + y) & 0x01) == 0;
|
|
|
+ return ((x + y) % 2) == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 001: mask bits for which x mod 2 == 0
|
|
|
+ */
|
|
|
+class DataMask001 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t) {
|
|
|
+ // return (x & 0x01) == 0;
|
|
|
+ return (x % 2) == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 010: mask bits for which y mod 3 == 0
|
|
|
+ */
|
|
|
+class DataMask010 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t, size_t y) {
|
|
|
+ return y % 3 == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 011: mask bits for which (x + y) mod 3 == 0
|
|
|
+ */
|
|
|
+class DataMask011 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t y) {
|
|
|
+ return (x + y) % 3 == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 100: mask bits for which (x/2 + y/3) mod 2 == 0
|
|
|
+ */
|
|
|
+class DataMask100 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t y) {
|
|
|
+ // return (((x >> 1) + (y / 3)) & 0x01) == 0;
|
|
|
+ return (((x >> 1) + (y / 3)) % 2) == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 101: mask bits for which xy mod 2 + xy mod 3 == 0
|
|
|
+ */
|
|
|
+class DataMask101 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t y) {
|
|
|
+ size_t temp = x * y;
|
|
|
+ // return (temp & 0x01) + (temp % 3) == 0;
|
|
|
+ return (temp % 2) + (temp % 3) == 0;
|
|
|
+
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 110: mask bits for which (xy mod 2 + xy mod 3) mod 2 == 0
|
|
|
+ */
|
|
|
+class DataMask110 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t y) {
|
|
|
+ size_t temp = x * y;
|
|
|
+ // return (((temp & 0x01) + (temp % 3)) & 0x01) == 0;
|
|
|
+ return (((temp % 2) + (temp % 3)) % 2) == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 111: mask bits for which ((x+y)mod 2 + xy mod 3) mod 2 == 0
|
|
|
+ */
|
|
|
+class DataMask111 : public DataMask {
|
|
|
+public:
|
|
|
+ bool isMasked(size_t x, size_t y) {
|
|
|
+ // return ((((x + y) & 0x01) + ((x * y) % 3)) & 0x01) == 0;
|
|
|
+ return ((((x + y) % 2) + ((x * y) % 3)) % 2) == 0;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+int DataMask::buildDataMasks() {
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask000()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask001()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask010()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask011()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask100()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask101()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask110()));
|
|
|
+ DATA_MASKS.push_back(Ref<DataMask> (new DataMask111()));
|
|
|
+ return DATA_MASKS.size();
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/decoder/DecodedBitStreamParser.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * DecodedBitStreamParser.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/DecodedBitStreamParser.h>
|
|
|
+// #include <zxing/common/CharacterSetECI.h>
|
|
|
+// #include <zxing/FormatException.h>
|
|
|
+// #include <zxing/common/StringUtils.h>
|
|
|
+// #include <iostream>
|
|
|
+#ifndef NO_ICONV
|
|
|
+// #include <iconv.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+// Required for compatibility. TODO: test on Symbian
|
|
|
+#ifdef ZXING_ICONV_CONST
|
|
|
+#undef ICONV_CONST
|
|
|
+#define ICONV_CONST const
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifndef ICONV_CONST
|
|
|
+#define ICONV_CONST /**/
|
|
|
+#endif
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+using namespace zxing;
|
|
|
+using namespace zxing::qrcode;
|
|
|
+using namespace zxing::common;
|
|
|
+
|
|
|
+const char DecodedBitStreamParser::ALPHANUMERIC_CHARS[] =
|
|
|
+{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
|
|
|
+ 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
|
|
+ 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
|
|
|
+ 'Y', 'Z', ' ', '$', '%', '*', '+', '-', '.', '/', ':'
|
|
|
+};
|
|
|
+
|
|
|
+namespace {int GB2312_SUBSET = 1;}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::append(std::string &result,
|
|
|
+ string const& in,
|
|
|
+ const char *src) {
|
|
|
+ append(result, (unsigned char const*)in.c_str(), in.length(), src);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::append(std::string &result,
|
|
|
+ const unsigned char *bufIn,
|
|
|
+ size_t nIn,
|
|
|
+ const char *src) {
|
|
|
+#ifndef NO_ICONV
|
|
|
+ if (nIn == 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ iconv_t cd = iconv_open(StringUtils::UTF8, src);
|
|
|
+ if (cd == (iconv_t)-1) {
|
|
|
+ result.append((const char *)bufIn, nIn);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ const int maxOut = 4 * nIn + 1;
|
|
|
+ unsigned char* bufOut = new unsigned char[maxOut];
|
|
|
+
|
|
|
+ ICONV_CONST char *fromPtr = (ICONV_CONST char *)bufIn;
|
|
|
+ size_t nFrom = nIn;
|
|
|
+ char *toPtr = (char *)bufOut;
|
|
|
+ size_t nTo = maxOut;
|
|
|
+
|
|
|
+ while (nFrom > 0) {
|
|
|
+ size_t oneway = iconv(cd, &fromPtr, &nFrom, &toPtr, &nTo);
|
|
|
+ if (oneway == (size_t)(-1)) {
|
|
|
+ iconv_close(cd);
|
|
|
+ delete[] bufOut;
|
|
|
+ throw ReaderException("error converting characters");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ iconv_close(cd);
|
|
|
+
|
|
|
+ int nResult = maxOut - nTo;
|
|
|
+ bufOut[nResult] = '\0';
|
|
|
+ result.append((const char *)bufOut);
|
|
|
+ delete[] bufOut;
|
|
|
+#else
|
|
|
+ result.append((const char *)bufIn, nIn);
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeHanziSegment(Ref<BitSource> bits_,
|
|
|
+ string& result,
|
|
|
+ int count) {
|
|
|
+ BitSource& bits (*bits_);
|
|
|
+ // Don't crash trying to read more bits than we have available.
|
|
|
+ if (count * 13 > bits.available()) {
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Each character will require 2 bytes. Read the characters as 2-byte pairs
|
|
|
+ // and decode as GB2312 afterwards
|
|
|
+ size_t nBytes = 2 * count;
|
|
|
+ unsigned char* buffer = new unsigned char[nBytes];
|
|
|
+ int offset = 0;
|
|
|
+ while (count > 0) {
|
|
|
+ // Each 13 bits encodes a 2-byte character
|
|
|
+ int twoBytes = bits.readBits(13);
|
|
|
+ int assembledTwoBytes = ((twoBytes / 0x060) << 8) | (twoBytes % 0x060);
|
|
|
+ if (assembledTwoBytes < 0x003BF) {
|
|
|
+ // In the 0xA1A1 to 0xAAFE range
|
|
|
+ assembledTwoBytes += 0x0A1A1;
|
|
|
+ } else {
|
|
|
+ // In the 0xB0A1 to 0xFAFE range
|
|
|
+ assembledTwoBytes += 0x0A6A1;
|
|
|
+ }
|
|
|
+ buffer[offset] = (unsigned char) ((assembledTwoBytes >> 8) & 0xFF);
|
|
|
+ buffer[offset + 1] = (unsigned char) (assembledTwoBytes & 0xFF);
|
|
|
+ offset += 2;
|
|
|
+ count--;
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ append(result, buffer, nBytes, StringUtils::GB2312);
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ delete [] buffer;
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+
|
|
|
+ delete [] buffer;
|
|
|
+ }
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeKanjiSegment(Ref<BitSource> bits, std::string &result, int count) {
|
|
|
+ // Each character will require 2 bytes. Read the characters as 2-byte pairs
|
|
|
+ // and decode as Shift_JIS afterwards
|
|
|
+ size_t nBytes = 2 * count;
|
|
|
+ unsigned char* buffer = new unsigned char[nBytes];
|
|
|
+ int offset = 0;
|
|
|
+ while (count > 0) {
|
|
|
+ // Each 13 bits encodes a 2-byte character
|
|
|
+
|
|
|
+ int twoBytes = bits->readBits(13);
|
|
|
+ int assembledTwoBytes = ((twoBytes / 0x0C0) << 8) | (twoBytes % 0x0C0);
|
|
|
+ if (assembledTwoBytes < 0x01F00) {
|
|
|
+ // In the 0x8140 to 0x9FFC range
|
|
|
+ assembledTwoBytes += 0x08140;
|
|
|
+ } else {
|
|
|
+ // In the 0xE040 to 0xEBBF range
|
|
|
+ assembledTwoBytes += 0x0C140;
|
|
|
+ }
|
|
|
+ buffer[offset] = (unsigned char)(assembledTwoBytes >> 8);
|
|
|
+ buffer[offset + 1] = (unsigned char)assembledTwoBytes;
|
|
|
+ offset += 2;
|
|
|
+ count--;
|
|
|
+ }
|
|
|
+
|
|
|
+ append(result, buffer, nBytes, StringUtils::SHIFT_JIS);
|
|
|
+ delete[] buffer;
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeByteSegment(Ref<BitSource> bits_,
|
|
|
+ string& result,
|
|
|
+ int count,
|
|
|
+ CharacterSetECI* currentCharacterSetECI,
|
|
|
+ ArrayRef< ArrayRef<unsigned char> >& byteSegments,
|
|
|
+ Hashtable const& hints) {
|
|
|
+ int nBytes = count;
|
|
|
+ BitSource& bits (*bits_);
|
|
|
+ // Don't crash trying to read more bits than we have available.
|
|
|
+ if (count << 3 > bits.available()) {
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+
|
|
|
+ ArrayRef<unsigned char> bytes_ (count);
|
|
|
+ unsigned char* readBytes = &(*bytes_)[0];
|
|
|
+ for (int i = 0; i < count; i++) {
|
|
|
+ readBytes[i] = (unsigned char) bits.readBits(8);
|
|
|
+ }
|
|
|
+ string encoding;
|
|
|
+ if (currentCharacterSetECI == 0) {
|
|
|
+ // The spec isn't clear on this mode; see
|
|
|
+ // section 6.4.5: t does not say which encoding to assuming
|
|
|
+ // upon decoding. I have seen ISO-8859-1 used as well as
|
|
|
+ // Shift_JIS -- without anything like an ECI designator to
|
|
|
+ // give a hint.
|
|
|
+ encoding = StringUtils::guessEncoding(readBytes, count, hints);
|
|
|
+ } else {
|
|
|
+ encoding = currentCharacterSetECI->getEncodingName();
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ append(result, readBytes, nBytes, encoding.c_str());
|
|
|
+ } catch (ReaderException const& re) {
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+ byteSegments->values().push_back(bytes_);
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeNumericSegment(Ref<BitSource> bits, std::string &result, int count) {
|
|
|
+ int nBytes = count;
|
|
|
+ unsigned char* bytes = new unsigned char[nBytes];
|
|
|
+ int i = 0;
|
|
|
+ // Read three digits at a time
|
|
|
+ while (count >= 3) {
|
|
|
+ // Each 10 bits encodes three digits
|
|
|
+ if (bits->available() < 10) {
|
|
|
+ throw ReaderException("format exception");
|
|
|
+ }
|
|
|
+ int threeDigitsBits = bits->readBits(10);
|
|
|
+ if (threeDigitsBits >= 1000) {
|
|
|
+ ostringstream s;
|
|
|
+ s << "Illegal value for 3-digit unit: " << threeDigitsBits;
|
|
|
+ delete[] bytes;
|
|
|
+ throw ReaderException(s.str().c_str());
|
|
|
+ }
|
|
|
+ bytes[i++] = ALPHANUMERIC_CHARS[threeDigitsBits / 100];
|
|
|
+ bytes[i++] = ALPHANUMERIC_CHARS[(threeDigitsBits / 10) % 10];
|
|
|
+ bytes[i++] = ALPHANUMERIC_CHARS[threeDigitsBits % 10];
|
|
|
+ count -= 3;
|
|
|
+ }
|
|
|
+ if (count == 2) {
|
|
|
+ if (bits->available() < 7) {
|
|
|
+ throw ReaderException("format exception");
|
|
|
+ }
|
|
|
+ // Two digits left over to read, encoded in 7 bits
|
|
|
+ int twoDigitsBits = bits->readBits(7);
|
|
|
+ if (twoDigitsBits >= 100) {
|
|
|
+ ostringstream s;
|
|
|
+ s << "Illegal value for 2-digit unit: " << twoDigitsBits;
|
|
|
+ delete[] bytes;
|
|
|
+ throw ReaderException(s.str().c_str());
|
|
|
+ }
|
|
|
+ bytes[i++] = ALPHANUMERIC_CHARS[twoDigitsBits / 10];
|
|
|
+ bytes[i++] = ALPHANUMERIC_CHARS[twoDigitsBits % 10];
|
|
|
+ } else if (count == 1) {
|
|
|
+ if (bits->available() < 4) {
|
|
|
+ throw ReaderException("format exception");
|
|
|
+ }
|
|
|
+ // One digit left over to read
|
|
|
+ int digitBits = bits->readBits(4);
|
|
|
+ if (digitBits >= 10) {
|
|
|
+ ostringstream s;
|
|
|
+ s << "Illegal value for digit unit: " << digitBits;
|
|
|
+ delete[] bytes;
|
|
|
+ throw ReaderException(s.str().c_str());
|
|
|
+ }
|
|
|
+ bytes[i++] = ALPHANUMERIC_CHARS[digitBits];
|
|
|
+ }
|
|
|
+ append(result, bytes, nBytes, StringUtils::ASCII);
|
|
|
+ delete[] bytes;
|
|
|
+}
|
|
|
+
|
|
|
+char DecodedBitStreamParser::toAlphaNumericChar(size_t value) {
|
|
|
+ if (value >= sizeof(DecodedBitStreamParser::ALPHANUMERIC_CHARS)) {
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+ return ALPHANUMERIC_CHARS[value];
|
|
|
+}
|
|
|
+
|
|
|
+void DecodedBitStreamParser::decodeAlphanumericSegment(Ref<BitSource> bits_,
|
|
|
+ string& result,
|
|
|
+ int count,
|
|
|
+ bool fc1InEffect) {
|
|
|
+ BitSource& bits (*bits_);
|
|
|
+ ostringstream bytes;
|
|
|
+ // Read two characters at a time
|
|
|
+ while (count > 1) {
|
|
|
+ int nextTwoCharsBits = bits.readBits(11);
|
|
|
+ bytes << toAlphaNumericChar(nextTwoCharsBits / 45);
|
|
|
+ bytes << toAlphaNumericChar(nextTwoCharsBits % 45);
|
|
|
+ count -= 2;
|
|
|
+ }
|
|
|
+ if (count == 1) {
|
|
|
+ // special case: one character left
|
|
|
+ bytes << toAlphaNumericChar(bits.readBits(6));
|
|
|
+ }
|
|
|
+ // See section 6.4.8.1, 6.4.8.2
|
|
|
+ string s = bytes.str();
|
|
|
+ if (fc1InEffect) {
|
|
|
+ // We need to massage the result a bit if in an FNC1 mode:
|
|
|
+ ostringstream r;
|
|
|
+ for (size_t i = 0; i < s.length(); i++) {
|
|
|
+ if (s[i] != '%') {
|
|
|
+ r << s[i];
|
|
|
+ } else {
|
|
|
+ if (i < s.length() - 1 && s[i + 1] == '%') {
|
|
|
+ // %% is rendered as %
|
|
|
+ r << s[i++];
|
|
|
+ } else {
|
|
|
+ // In alpha mode, % should be converted to FNC1 separator 0x1D
|
|
|
+ r << (char)0x1D;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ s = r.str();
|
|
|
+ }
|
|
|
+ append(result, s, StringUtils::ASCII);
|
|
|
+}
|
|
|
+
|
|
|
+namespace {
|
|
|
+ int parseECIValue(BitSource bits) {
|
|
|
+ int firstByte = bits.readBits(8);
|
|
|
+ if ((firstByte & 0x80) == 0) {
|
|
|
+ // just one byte
|
|
|
+ return firstByte & 0x7F;
|
|
|
+ }
|
|
|
+ if ((firstByte & 0xC0) == 0x80) {
|
|
|
+ // two bytes
|
|
|
+ int secondByte = bits.readBits(8);
|
|
|
+ return ((firstByte & 0x3F) << 8) | secondByte;
|
|
|
+ }
|
|
|
+ if ((firstByte & 0xE0) == 0xC0) {
|
|
|
+ // three bytes
|
|
|
+ int secondThirdBytes = bits.readBits(16);
|
|
|
+ return ((firstByte & 0x1F) << 16) | secondThirdBytes;
|
|
|
+ }
|
|
|
+ throw IllegalArgumentException("Bad ECI bits starting with byte ");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<DecoderResult>
|
|
|
+DecodedBitStreamParser::decode(ArrayRef<unsigned char> bytes,
|
|
|
+ Version* version,
|
|
|
+ ErrorCorrectionLevel const& ecLevel,
|
|
|
+ Hashtable const& hints) {
|
|
|
+ Ref<BitSource> bits_ (new BitSource(bytes));
|
|
|
+ BitSource& bits (*bits_);
|
|
|
+ string result;
|
|
|
+ CharacterSetECI* currentCharacterSetECI = 0;
|
|
|
+ bool fc1InEffect = false;
|
|
|
+ ArrayRef< ArrayRef<unsigned char> > byteSegments (size_t(0));
|
|
|
+ Mode* mode = 0;
|
|
|
+ do {
|
|
|
+ // While still another segment to read...
|
|
|
+ if (bits.available() < 4) {
|
|
|
+ // OK, assume we're done. Really, a TERMINATOR mode should have been recorded here
|
|
|
+ mode = &Mode::TERMINATOR;
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ mode = &Mode::forBits(bits.readBits(4)); // mode is encoded by 4 bits
|
|
|
+ } catch (IllegalArgumentException const& iae) {
|
|
|
+ throw iae;
|
|
|
+ // throw FormatException.getFormatInstance();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (mode != &Mode::TERMINATOR) {
|
|
|
+ if ((mode == &Mode::FNC1_FIRST_POSITION) || (mode == &Mode::FNC1_SECOND_POSITION)) {
|
|
|
+ // We do little with FNC1 except alter the parsed result a bit according to the spec
|
|
|
+ fc1InEffect = true;
|
|
|
+ } else if (mode == &Mode::STRUCTURED_APPEND) {
|
|
|
+ // not really supported; all we do is ignore it
|
|
|
+ // Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue
|
|
|
+ bits.readBits(16);
|
|
|
+ } else if (mode == &Mode::ECI) {
|
|
|
+ // Count doesn't apply to ECI
|
|
|
+ int value = parseECIValue(bits);
|
|
|
+ currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValue(value);
|
|
|
+ if (currentCharacterSetECI == 0) {
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // First handle Hanzi mode which does not start with character count
|
|
|
+ if (mode == &Mode::HANZI) {
|
|
|
+ //chinese mode contains a sub set indicator right after mode indicator
|
|
|
+ int subset = bits.readBits(4);
|
|
|
+ int countHanzi = bits.readBits(mode->getCharacterCountBits(version));
|
|
|
+ if (subset == GB2312_SUBSET) {
|
|
|
+ decodeHanziSegment(bits_, result, countHanzi);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // "Normal" QR code modes:
|
|
|
+ // How many characters will follow, encoded in this mode?
|
|
|
+ int count = bits.readBits(mode->getCharacterCountBits(version));
|
|
|
+ if (mode == &Mode::NUMERIC) {
|
|
|
+ decodeNumericSegment(bits_, result, count);
|
|
|
+ } else if (mode == &Mode::ALPHANUMERIC) {
|
|
|
+ decodeAlphanumericSegment(bits_, result, count, fc1InEffect);
|
|
|
+ } else if (mode == &Mode::BYTE) {
|
|
|
+ decodeByteSegment(bits_, result, count, currentCharacterSetECI, byteSegments, hints);
|
|
|
+ } else if (mode == &Mode::KANJI) {
|
|
|
+ decodeKanjiSegment(bits_, result, count);
|
|
|
+ } else {
|
|
|
+ throw FormatException();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } while (mode != &Mode::TERMINATOR);
|
|
|
+
|
|
|
+ return Ref<DecoderResult>(new DecoderResult(bytes, Ref<String>(new String(result)), byteSegments, (string)ecLevel));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+// file: zxing/qrcode/decoder/Decoder.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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/common/reedsolomon/ReedSolomonException.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+Decoder::Decoder() :
|
|
|
+ rsDecoder_(GF256::QR_CODE_FIELD) {
|
|
|
+}
|
|
|
+
|
|
|
+void Decoder::correctErrors(ArrayRef<unsigned 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& ex) {
|
|
|
+ ReaderException rex(ex.what());
|
|
|
+ throw rex;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < numDataCodewords; i++) {
|
|
|
+ codewordBytes[i] = (unsigned char)codewordInts[i];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
|
|
|
+ // Construct a parser and read version, error-correction level
|
|
|
+ BitMatrixParser parser(bits);
|
|
|
+
|
|
|
+ Version *version = parser.readVersion();
|
|
|
+ ErrorCorrectionLevel &ecLevel = parser.readFormatInformation()->getErrorCorrectionLevel();
|
|
|
+
|
|
|
+
|
|
|
+ // Read codewords
|
|
|
+ ArrayRef<unsigned 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<unsigned 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<unsigned 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());
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/decoder/Mode.cpp
|
|
|
+
|
|
|
+// -*- 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/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;
|
|
|
+
|
|
|
+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(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::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(Version *version) {
|
|
|
+ int number = version->getVersionNumber();
|
|
|
+ if (number <= 9) {
|
|
|
+ return characterCountBitsForVersions0To9_;
|
|
|
+ } else if (number <= 26) {
|
|
|
+ return characterCountBitsForVersions10To26_;
|
|
|
+ } else {
|
|
|
+ return characterCountBitsForVersions27AndHigher_;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/AlignmentPattern.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * AlignmentPattern.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/detector/AlignmentPattern.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+AlignmentPattern::AlignmentPattern(float posX, float posY, float estimatedModuleSize) :
|
|
|
+ ResultPoint(posX,posY), estimatedModuleSize_(estimatedModuleSize) {
|
|
|
+}
|
|
|
+
|
|
|
+bool AlignmentPattern::aboutEquals(float moduleSize, float i, float j) const {
|
|
|
+ if (abs(i - getY()) <= moduleSize && abs(j - getX()) <= moduleSize) {
|
|
|
+ float moduleSizeDiff = abs(moduleSize - estimatedModuleSize_);
|
|
|
+ return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize_;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<AlignmentPattern> AlignmentPattern::combineEstimate(float i, float j, float newModuleSize) const {
|
|
|
+ float combinedX = (getX() + j) / 2.0f;
|
|
|
+ float combinedY = (getY() + i) / 2.0f;
|
|
|
+ float combinedModuleSize = (estimatedModuleSize_ + newModuleSize) / 2.0f;
|
|
|
+ Ref<AlignmentPattern> result
|
|
|
+ (new AlignmentPattern(combinedX, combinedY, combinedModuleSize));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/AlignmentPatternFinder.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * AlignmentPatternFinder.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 "AlignmentPatternFinder.h"
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <zxing/common/BitArray.h>
|
|
|
+// #include <vector>
|
|
|
+// #include <cmath>
|
|
|
+// #include <cstdlib>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+float AlignmentPatternFinder::centerFromEnd(vector<int> &stateCount, int end) {
|
|
|
+ return (float)(end - stateCount[2]) - stateCount[1] / 2.0f;
|
|
|
+}
|
|
|
+
|
|
|
+bool AlignmentPatternFinder::foundPatternCross(vector<int> &stateCount) {
|
|
|
+ float maxVariance = moduleSize_ / 2.0f;
|
|
|
+ for (size_t i = 0; i < 3; i++) {
|
|
|
+ if (abs(moduleSize_ - stateCount[i]) >= maxVariance) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+float AlignmentPatternFinder::crossCheckVertical(size_t startI, size_t centerJ, int maxCount,
|
|
|
+ int originalStateCountTotal) {
|
|
|
+ int maxI = image_->getHeight();
|
|
|
+ vector<int> stateCount(3, 0);
|
|
|
+
|
|
|
+
|
|
|
+ // Start counting up from center
|
|
|
+ int i = startI;
|
|
|
+ while (i >= 0 && image_->get(centerJ, i) && stateCount[1] <= maxCount) {
|
|
|
+ stateCount[1]++;
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ // If already too many modules in this state or ran off the edge:
|
|
|
+ if (i < 0 || stateCount[1] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (i >= 0 && !image_->get(centerJ, i) && stateCount[0] <= maxCount) {
|
|
|
+ stateCount[0]++;
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ if (stateCount[0] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Now also count down from center
|
|
|
+ i = startI + 1;
|
|
|
+ while (i < maxI && image_->get(centerJ, i) && stateCount[1] <= maxCount) {
|
|
|
+ stateCount[1]++;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ if (i == maxI || stateCount[1] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (i < maxI && !image_->get(centerJ, i) && stateCount[2] <= maxCount) {
|
|
|
+ stateCount[2]++;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ if (stateCount[2] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
|
|
|
+ if (5 * abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : NAN;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<AlignmentPattern> AlignmentPatternFinder::handlePossibleCenter(vector<int> &stateCount, size_t i, size_t j) {
|
|
|
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
|
|
|
+ float centerJ = centerFromEnd(stateCount, j);
|
|
|
+ float centerI = crossCheckVertical(i, (int)centerJ, 2 * stateCount[1], stateCountTotal);
|
|
|
+ if (!isnan(centerI)) {
|
|
|
+ float estimatedModuleSize = (float)(stateCount[0] + stateCount[1] + stateCount[2]) / 3.0f;
|
|
|
+ int max = possibleCenters_->size();
|
|
|
+ for (int index = 0; index < max; index++) {
|
|
|
+ Ref<AlignmentPattern> center((*possibleCenters_)[index]);
|
|
|
+ // Look for about the same center and module size:
|
|
|
+ if (center->aboutEquals(estimatedModuleSize, centerI, centerJ)) {
|
|
|
+ return center->combineEstimate(centerI, centerJ, estimatedModuleSize);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ AlignmentPattern *tmp = new AlignmentPattern(centerJ, centerI, estimatedModuleSize);
|
|
|
+ // Hadn't found this before; save it
|
|
|
+ tmp->retain();
|
|
|
+ possibleCenters_->push_back(tmp);
|
|
|
+ if (callback_ != 0) {
|
|
|
+ callback_->foundPossibleResultPoint(*tmp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ref<AlignmentPattern> result;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+AlignmentPatternFinder::AlignmentPatternFinder(Ref<BitMatrix> image, size_t startX, size_t startY, size_t width,
|
|
|
+ size_t height, float moduleSize,
|
|
|
+ Ref<ResultPointCallback>const& callback) :
|
|
|
+ image_(image), possibleCenters_(new vector<AlignmentPattern *> ()), startX_(startX), startY_(startY),
|
|
|
+ width_(width), height_(height), moduleSize_(moduleSize), callback_(callback) {
|
|
|
+}
|
|
|
+
|
|
|
+AlignmentPatternFinder::~AlignmentPatternFinder() {
|
|
|
+ for (size_t i = 0; i < possibleCenters_->size(); i++) {
|
|
|
+ (*possibleCenters_)[i]->release();
|
|
|
+ (*possibleCenters_)[i] = 0;
|
|
|
+ }
|
|
|
+ delete possibleCenters_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<AlignmentPattern> AlignmentPatternFinder::find() {
|
|
|
+ size_t maxJ = startX_ + width_;
|
|
|
+ size_t middleI = startY_ + (height_ >> 1);
|
|
|
+ // Ref<BitArray> luminanceRow(new BitArray(width_));
|
|
|
+ // We are looking for black/white/black modules in 1:1:1 ratio;
|
|
|
+ // this tracks the number of black/white/black modules seen so far
|
|
|
+ vector<int> stateCount(3, 0);
|
|
|
+ for (size_t iGen = 0; iGen < height_; iGen++) {
|
|
|
+ // Search from middle outwards
|
|
|
+ size_t i = middleI + ((iGen & 0x01) == 0 ? ((iGen + 1) >> 1) : -((iGen + 1) >> 1));
|
|
|
+ // image_->getBlackRow(i, luminanceRow, startX_, width_);
|
|
|
+ stateCount[0] = 0;
|
|
|
+ stateCount[1] = 0;
|
|
|
+ stateCount[2] = 0;
|
|
|
+ size_t j = startX_;
|
|
|
+ // Burn off leading white pixels before anything else; if we start in the middle of
|
|
|
+ // a white run, it doesn't make sense to count its length, since we don't know if the
|
|
|
+ // white run continued to the left of the start point
|
|
|
+ while (j < maxJ && !image_->get(j, i)) {
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+ int currentState = 0;
|
|
|
+ while (j < maxJ) {
|
|
|
+ if (image_->get(j, i)) {
|
|
|
+ // Black pixel
|
|
|
+ if (currentState == 1) { // Counting black pixels
|
|
|
+ stateCount[currentState]++;
|
|
|
+ } else { // Counting white pixels
|
|
|
+ if (currentState == 2) { // A winner?
|
|
|
+ if (foundPatternCross(stateCount)) { // Yes
|
|
|
+ Ref<AlignmentPattern> confirmed(handlePossibleCenter(stateCount, i, j));
|
|
|
+ if (confirmed != 0) {
|
|
|
+ return confirmed;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ stateCount[0] = stateCount[2];
|
|
|
+ stateCount[1] = 1;
|
|
|
+ stateCount[2] = 0;
|
|
|
+ currentState = 1;
|
|
|
+ } else {
|
|
|
+ stateCount[++currentState]++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else { // White pixel
|
|
|
+ if (currentState == 1) { // Counting black pixels
|
|
|
+ currentState++;
|
|
|
+ }
|
|
|
+ stateCount[currentState]++;
|
|
|
+ }
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+ if (foundPatternCross(stateCount)) {
|
|
|
+ Ref<AlignmentPattern> confirmed(handlePossibleCenter(stateCount, i, maxJ));
|
|
|
+ if (confirmed != 0) {
|
|
|
+ return confirmed;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Hmm, nothing we saw was observed and confirmed twice. If we had
|
|
|
+ // any guess at all, return it.
|
|
|
+ if (possibleCenters_->size() > 0) {
|
|
|
+ Ref<AlignmentPattern> center((*possibleCenters_)[0]);
|
|
|
+ return center;
|
|
|
+ }
|
|
|
+
|
|
|
+ throw zxing::ReaderException("Could not find alignment pattern");
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/Detector.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Detector.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/qrcode/detector/Detector.h>
|
|
|
+// #include <zxing/qrcode/detector/FinderPatternFinder.h>
|
|
|
+// #include <zxing/qrcode/detector/FinderPattern.h>
|
|
|
+// #include <zxing/qrcode/detector/AlignmentPattern.h>
|
|
|
+// #include <zxing/qrcode/detector/AlignmentPatternFinder.h>
|
|
|
+// #include <zxing/qrcode/Version.h>
|
|
|
+// #include <zxing/common/GridSampler.h>
|
|
|
+// #include <zxing/DecodeHints.h>
|
|
|
+// #include <cmath>
|
|
|
+// #include <sstream>
|
|
|
+// #include <cstdlib>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+Detector::Detector(Ref<BitMatrix> image) :
|
|
|
+ image_(image) {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> Detector::getImage() {
|
|
|
+ return image_;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<DetectorResult> Detector::detect(DecodeHints const& hints) {
|
|
|
+ callback_ = hints.getResultPointCallback();
|
|
|
+ FinderPatternFinder finder(image_, hints.getResultPointCallback());
|
|
|
+ Ref<FinderPatternInfo> info(finder.find(hints));
|
|
|
+ return processFinderPatternInfo(info);
|
|
|
+}
|
|
|
+
|
|
|
+Ref<DetectorResult> Detector::processFinderPatternInfo(Ref<FinderPatternInfo> info){
|
|
|
+ Ref<FinderPattern> topLeft(info->getTopLeft());
|
|
|
+ Ref<FinderPattern> topRight(info->getTopRight());
|
|
|
+ Ref<FinderPattern> bottomLeft(info->getBottomLeft());
|
|
|
+
|
|
|
+ float moduleSize = calculateModuleSize(topLeft, topRight, bottomLeft);
|
|
|
+ if (moduleSize < 1.0f) {
|
|
|
+ throw zxing::ReaderException("bad module size");
|
|
|
+ }
|
|
|
+ int dimension = computeDimension(topLeft, topRight, bottomLeft, moduleSize);
|
|
|
+ Version *provisionalVersion = Version::getProvisionalVersionForDimension(dimension);
|
|
|
+ int modulesBetweenFPCenters = provisionalVersion->getDimensionForVersion() - 7;
|
|
|
+
|
|
|
+ Ref<AlignmentPattern> alignmentPattern;
|
|
|
+ // Anything above version 1 has an alignment pattern
|
|
|
+ if (provisionalVersion->getAlignmentPatternCenters().size() > 0) {
|
|
|
+
|
|
|
+
|
|
|
+ // Guess where a "bottom right" finder pattern would have been
|
|
|
+ float bottomRightX = topRight->getX() - topLeft->getX() + bottomLeft->getX();
|
|
|
+ float bottomRightY = topRight->getY() - topLeft->getY() + bottomLeft->getY();
|
|
|
+
|
|
|
+
|
|
|
+ // Estimate that alignment pattern is closer by 3 modules
|
|
|
+ // from "bottom right" to known top left location
|
|
|
+ float correctionToTopLeft = 1.0f - 3.0f / (float)modulesBetweenFPCenters;
|
|
|
+ int estAlignmentX = (int)(topLeft->getX() + correctionToTopLeft * (bottomRightX - topLeft->getX()));
|
|
|
+ int estAlignmentY = (int)(topLeft->getY() + correctionToTopLeft * (bottomRightY - topLeft->getY()));
|
|
|
+
|
|
|
+
|
|
|
+ // Kind of arbitrary -- expand search radius before giving up
|
|
|
+ for (int i = 4; i <= 16; i <<= 1) {
|
|
|
+ try {
|
|
|
+ alignmentPattern = findAlignmentInRegion(moduleSize, estAlignmentX, estAlignmentY, (float)i);
|
|
|
+ break;
|
|
|
+ } catch (zxing::ReaderException const& re) {
|
|
|
+ // try next round
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (alignmentPattern == 0) {
|
|
|
+ // Try anyway
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<PerspectiveTransform> transform = createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension);
|
|
|
+ Ref<BitMatrix> bits(sampleGrid(image_, dimension, transform));
|
|
|
+ std::vector<Ref<ResultPoint> > points(alignmentPattern == 0 ? 3 : 4);
|
|
|
+ points[0].reset(bottomLeft);
|
|
|
+ points[1].reset(topLeft);
|
|
|
+ points[2].reset(topRight);
|
|
|
+ if (alignmentPattern != 0) {
|
|
|
+ points[3].reset(alignmentPattern);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<DetectorResult> result(new DetectorResult(bits, points, transform));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> Detector::createTransform(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref <
|
|
|
+ ResultPoint > bottomLeft, Ref<ResultPoint> alignmentPattern, int dimension) {
|
|
|
+
|
|
|
+ float dimMinusThree = (float)dimension - 3.5f;
|
|
|
+ float bottomRightX;
|
|
|
+ float bottomRightY;
|
|
|
+ float sourceBottomRightX;
|
|
|
+ float sourceBottomRightY;
|
|
|
+ if (alignmentPattern != 0) {
|
|
|
+ bottomRightX = alignmentPattern->getX();
|
|
|
+ bottomRightY = alignmentPattern->getY();
|
|
|
+ sourceBottomRightX = sourceBottomRightY = dimMinusThree - 3.0f;
|
|
|
+ } else {
|
|
|
+ // Don't have an alignment pattern, just make up the bottom-right point
|
|
|
+ bottomRightX = (topRight->getX() - topLeft->getX()) + bottomLeft->getX();
|
|
|
+ bottomRightY = (topRight->getY() - topLeft->getY()) + bottomLeft->getY();
|
|
|
+ sourceBottomRightX = sourceBottomRightY = dimMinusThree;
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<PerspectiveTransform> transform(PerspectiveTransform::quadrilateralToQuadrilateral(3.5f, 3.5f, dimMinusThree, 3.5f, sourceBottomRightX,
|
|
|
+ sourceBottomRightY, 3.5f, dimMinusThree, topLeft->getX(), topLeft->getY(), topRight->getX(),
|
|
|
+ topRight->getY(), bottomRightX, bottomRightY, bottomLeft->getX(), bottomLeft->getY()));
|
|
|
+
|
|
|
+ return transform;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<BitMatrix> Detector::sampleGrid(Ref<BitMatrix> image, int dimension, Ref<PerspectiveTransform> transform) {
|
|
|
+ GridSampler &sampler = GridSampler::getInstance();
|
|
|
+ return sampler.sampleGrid(image, dimension, transform);
|
|
|
+}
|
|
|
+
|
|
|
+int Detector::computeDimension(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft,
|
|
|
+ float moduleSize) {
|
|
|
+ int tltrCentersDimension = int(FinderPatternFinder::distance(topLeft, topRight) / moduleSize + 0.5f);
|
|
|
+ int tlblCentersDimension = int(FinderPatternFinder::distance(topLeft, bottomLeft) / moduleSize + 0.5f);
|
|
|
+ int dimension = ((tltrCentersDimension + tlblCentersDimension) >> 1) + 7;
|
|
|
+ switch (dimension & 0x03) { // mod 4
|
|
|
+ case 0:
|
|
|
+ dimension++;
|
|
|
+ break;
|
|
|
+ // 1? do nothing
|
|
|
+ case 2:
|
|
|
+ dimension--;
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ ostringstream s;
|
|
|
+ s << "Bad dimension: " << dimension;
|
|
|
+ throw zxing::ReaderException(s.str().c_str());
|
|
|
+ }
|
|
|
+ return dimension;
|
|
|
+}
|
|
|
+
|
|
|
+float Detector::calculateModuleSize(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref<ResultPoint> bottomLeft) {
|
|
|
+ // Take the average
|
|
|
+ return (calculateModuleSizeOneWay(topLeft, topRight) + calculateModuleSizeOneWay(topLeft, bottomLeft)) / 2.0f;
|
|
|
+}
|
|
|
+
|
|
|
+float Detector::calculateModuleSizeOneWay(Ref<ResultPoint> pattern, Ref<ResultPoint> otherPattern) {
|
|
|
+ float moduleSizeEst1 = sizeOfBlackWhiteBlackRunBothWays((int)pattern->getX(), (int)pattern->getY(),
|
|
|
+ (int)otherPattern->getX(), (int)otherPattern->getY());
|
|
|
+ float moduleSizeEst2 = sizeOfBlackWhiteBlackRunBothWays((int)otherPattern->getX(), (int)otherPattern->getY(),
|
|
|
+ (int)pattern->getX(), (int)pattern->getY());
|
|
|
+ if (isnan(moduleSizeEst1)) {
|
|
|
+ return moduleSizeEst2;
|
|
|
+ }
|
|
|
+ if (isnan(moduleSizeEst2)) {
|
|
|
+ return moduleSizeEst1;
|
|
|
+ }
|
|
|
+ // Average them, and divide by 7 since we've counted the width of 3 black modules,
|
|
|
+ // and 1 white and 1 black module on either side. Ergo, divide sum by 14.
|
|
|
+ return (moduleSizeEst1 + moduleSizeEst2) / 14.0f;
|
|
|
+}
|
|
|
+
|
|
|
+float Detector::sizeOfBlackWhiteBlackRunBothWays(int fromX, int fromY, int toX, int toY) {
|
|
|
+
|
|
|
+ float result = sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY);
|
|
|
+
|
|
|
+ // Now count other way -- don't run off image though of course
|
|
|
+ float scale = 1.0f;
|
|
|
+ int otherToX = fromX - (toX - fromX);
|
|
|
+ if (otherToX < 0) {
|
|
|
+ scale = (float) fromX / (float) (fromX - otherToX);
|
|
|
+ otherToX = 0;
|
|
|
+ } else if (otherToX >= (int)image_->getWidth()) {
|
|
|
+ scale = (float) (image_->getWidth() - 1 - fromX) / (float) (otherToX - fromX);
|
|
|
+ otherToX = image_->getWidth() - 1;
|
|
|
+ }
|
|
|
+ int otherToY = (int) (fromY - (toY - fromY) * scale);
|
|
|
+
|
|
|
+ scale = 1.0f;
|
|
|
+ if (otherToY < 0) {
|
|
|
+ scale = (float) fromY / (float) (fromY - otherToY);
|
|
|
+ otherToY = 0;
|
|
|
+ } else if (otherToY >= (int)image_->getHeight()) {
|
|
|
+ scale = (float) (image_->getHeight() - 1 - fromY) / (float) (otherToY - fromY);
|
|
|
+ otherToY = image_->getHeight() - 1;
|
|
|
+ }
|
|
|
+ otherToX = (int) (fromX + (otherToX - fromX) * scale);
|
|
|
+
|
|
|
+ result += sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY);
|
|
|
+
|
|
|
+ // Middle pixel is double-counted this way; subtract 1
|
|
|
+ return result - 1.0f;
|
|
|
+}
|
|
|
+
|
|
|
+float Detector::sizeOfBlackWhiteBlackRun(int fromX, int fromY, int toX, int toY) {
|
|
|
+ // Mild variant of Bresenham's algorithm;
|
|
|
+ // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
|
|
|
+ bool steep = abs(toY - fromY) > abs(toX - fromX);
|
|
|
+ if (steep) {
|
|
|
+ int temp = fromX;
|
|
|
+ fromX = fromY;
|
|
|
+ fromY = temp;
|
|
|
+ temp = toX;
|
|
|
+ toX = toY;
|
|
|
+ toY = temp;
|
|
|
+ }
|
|
|
+
|
|
|
+ int dx = abs(toX - fromX);
|
|
|
+ int dy = abs(toY - fromY);
|
|
|
+ int error = -dx >> 1;
|
|
|
+ int xstep = fromX < toX ? 1 : -1;
|
|
|
+ int ystep = fromY < toY ? 1 : -1;
|
|
|
+
|
|
|
+ // In black pixels, looking for white, first or second time.
|
|
|
+ int state = 0;
|
|
|
+ // Loop up until x == toX, but not beyond
|
|
|
+ int xLimit = toX + xstep;
|
|
|
+ for (int x = fromX, y = fromY; x != xLimit; x += xstep) {
|
|
|
+ int realX = steep ? y : x;
|
|
|
+ int realY = steep ? x : y;
|
|
|
+
|
|
|
+ // Does current pixel mean we have moved white to black or vice versa?
|
|
|
+ if (!((state == 1) ^ image_->get(realX, realY))) {
|
|
|
+ if (state == 2) {
|
|
|
+ int diffX = x - fromX;
|
|
|
+ int diffY = y - fromY;
|
|
|
+ return (float) sqrt((double) (diffX * diffX + diffY * diffY));
|
|
|
+ }
|
|
|
+ state++;
|
|
|
+ }
|
|
|
+
|
|
|
+ error += dy;
|
|
|
+ if (error > 0) {
|
|
|
+ if (y == toY) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ y += ystep;
|
|
|
+ error -= dx;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Found black-white-black; give the benefit of the doubt that the next pixel outside the image
|
|
|
+ // is "white" so this last point at (toX+xStep,toY) is the right ending. This is really a
|
|
|
+ // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this.
|
|
|
+ if (state == 2) {
|
|
|
+ int diffX = toX + xstep - fromX;
|
|
|
+ int diffY = toY - fromY;
|
|
|
+ return (float) sqrt((double) (diffX * diffX + diffY * diffY));
|
|
|
+ }
|
|
|
+ // else we didn't find even black-white-black; no estimate is really possible
|
|
|
+ return NAN;
|
|
|
+}
|
|
|
+
|
|
|
+Ref<AlignmentPattern> Detector::findAlignmentInRegion(float overallEstModuleSize, int estAlignmentX, int estAlignmentY,
|
|
|
+ float allowanceFactor) {
|
|
|
+ // Look for an alignment pattern (3 modules in size) around where it
|
|
|
+ // should be
|
|
|
+ int allowance = (int)(allowanceFactor * overallEstModuleSize);
|
|
|
+ int alignmentAreaLeftX = max(0, estAlignmentX - allowance);
|
|
|
+ int alignmentAreaRightX = min((int)(image_->getWidth() - 1), estAlignmentX + allowance);
|
|
|
+ if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) {
|
|
|
+ throw zxing::ReaderException("region too small to hold alignment pattern");
|
|
|
+ }
|
|
|
+ int alignmentAreaTopY = max(0, estAlignmentY - allowance);
|
|
|
+ int alignmentAreaBottomY = min((int)(image_->getHeight() - 1), estAlignmentY + allowance);
|
|
|
+ if (alignmentAreaBottomY - alignmentAreaTopY < overallEstModuleSize * 3) {
|
|
|
+ throw zxing::ReaderException("region too small to hold alignment pattern");
|
|
|
+ }
|
|
|
+
|
|
|
+ AlignmentPatternFinder alignmentFinder(image_, alignmentAreaLeftX, alignmentAreaTopY, alignmentAreaRightX
|
|
|
+ - alignmentAreaLeftX, alignmentAreaBottomY - alignmentAreaTopY, overallEstModuleSize, callback_);
|
|
|
+ return alignmentFinder.find();
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/FinderPattern.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * FinderPattern.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/detector/FinderPattern.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+ namespace qrcode {
|
|
|
+
|
|
|
+ using namespace std;
|
|
|
+
|
|
|
+ FinderPattern::FinderPattern(float posX, float posY, float estimatedModuleSize) :
|
|
|
+ ResultPoint(posX,posY), estimatedModuleSize_(estimatedModuleSize), count_(1) {
|
|
|
+ }
|
|
|
+
|
|
|
+ FinderPattern::FinderPattern(float posX, float posY, float estimatedModuleSize, int count) :
|
|
|
+ ResultPoint(posX,posY), estimatedModuleSize_(estimatedModuleSize), count_(count) {
|
|
|
+ }
|
|
|
+
|
|
|
+ int FinderPattern::getCount() const {
|
|
|
+ return count_;
|
|
|
+ }
|
|
|
+
|
|
|
+ float FinderPattern::getEstimatedModuleSize() const {
|
|
|
+ return estimatedModuleSize_;
|
|
|
+ }
|
|
|
+
|
|
|
+ void FinderPattern::incrementCount() {
|
|
|
+ count_++;
|
|
|
+ }
|
|
|
+
|
|
|
+/*
|
|
|
+ bool FinderPattern::aboutEquals(float moduleSize, float i, float j) const {
|
|
|
+ return abs(i - posY_) <= moduleSize && abs(j - posX_) <= moduleSize && (abs(moduleSize - estimatedModuleSize_)
|
|
|
+ <= 1.0f || abs(moduleSize - estimatedModuleSize_) / estimatedModuleSize_ <= 0.1f);
|
|
|
+ }
|
|
|
+*/
|
|
|
+ bool FinderPattern::aboutEquals(float moduleSize, float i, float j) const {
|
|
|
+ if (abs(i - getY()) <= moduleSize && abs(j - getX()) <= moduleSize) {
|
|
|
+ float moduleSizeDiff = abs(moduleSize - estimatedModuleSize_);
|
|
|
+ return moduleSizeDiff <= 1.0f || moduleSizeDiff <= estimatedModuleSize_;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<FinderPattern> FinderPattern::combineEstimate(float i, float j, float newModuleSize) const {
|
|
|
+ int combinedCount = count_ + 1;
|
|
|
+ float combinedX = (count_ * getX() + j) / combinedCount;
|
|
|
+ float combinedY = (count_ * getY() + i) / combinedCount;
|
|
|
+ float combinedModuleSize = (count_ * getEstimatedModuleSize() + newModuleSize) / combinedCount;
|
|
|
+ return Ref<FinderPattern>(new FinderPattern(combinedX, combinedY, combinedModuleSize, combinedCount));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/FinderPatternFinder.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * FinderPatternFinder.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/detector/FinderPatternFinder.h>
|
|
|
+// #include <zxing/ReaderException.h>
|
|
|
+// #include <zxing/DecodeHints.h>
|
|
|
+// #include <vector>
|
|
|
+// #include <cmath>
|
|
|
+// #include <cstdlib>
|
|
|
+// #include <algorithm>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+class FurthestFromAverageComparator {
|
|
|
+private:
|
|
|
+ const float averageModuleSize_;
|
|
|
+public:
|
|
|
+ FurthestFromAverageComparator(float averageModuleSize) :
|
|
|
+ averageModuleSize_(averageModuleSize) {
|
|
|
+ }
|
|
|
+ bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
|
|
|
+ float dA = abs(a->getEstimatedModuleSize() - averageModuleSize_);
|
|
|
+ float dB = abs(b->getEstimatedModuleSize() - averageModuleSize_);
|
|
|
+ return dA > dB;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+class CenterComparator {
|
|
|
+ const float averageModuleSize_;
|
|
|
+public:
|
|
|
+ CenterComparator(float averageModuleSize) :
|
|
|
+ averageModuleSize_(averageModuleSize) {
|
|
|
+ }
|
|
|
+ bool operator()(Ref<FinderPattern> a, Ref<FinderPattern> b) {
|
|
|
+ // N.B.: we want the result in descending order ...
|
|
|
+ if (a->getCount() != b->getCount()) {
|
|
|
+ return a->getCount() > b->getCount();
|
|
|
+ } else {
|
|
|
+ float dA = abs(a->getEstimatedModuleSize() - averageModuleSize_);
|
|
|
+ float dB = abs(b->getEstimatedModuleSize() - averageModuleSize_);
|
|
|
+ return dA < dB;
|
|
|
+ }
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+int FinderPatternFinder::CENTER_QUORUM = 2;
|
|
|
+int FinderPatternFinder::MIN_SKIP = 3;
|
|
|
+int FinderPatternFinder::MAX_MODULES = 57;
|
|
|
+
|
|
|
+float FinderPatternFinder::centerFromEnd(int* stateCount, int end) {
|
|
|
+ return (float)(end - stateCount[4] - stateCount[3]) - stateCount[2] / 2.0f;
|
|
|
+}
|
|
|
+
|
|
|
+bool FinderPatternFinder::foundPatternCross(int* stateCount) {
|
|
|
+ int totalModuleSize = 0;
|
|
|
+ for (int i = 0; i < 5; i++) {
|
|
|
+ if (stateCount[i] == 0) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ totalModuleSize += stateCount[i];
|
|
|
+ }
|
|
|
+ if (totalModuleSize < 7) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ float moduleSize = (float)totalModuleSize / 7.0f;
|
|
|
+ float maxVariance = moduleSize / 2.0f;
|
|
|
+ // Allow less than 50% variance from 1-1-3-1-1 proportions
|
|
|
+ return abs(moduleSize - stateCount[0]) < maxVariance && abs(moduleSize - stateCount[1]) < maxVariance && abs(3.0f
|
|
|
+ * moduleSize - stateCount[2]) < 3.0f * maxVariance && abs(moduleSize - stateCount[3]) < maxVariance && abs(
|
|
|
+ moduleSize - stateCount[4]) < maxVariance;
|
|
|
+}
|
|
|
+
|
|
|
+float FinderPatternFinder::crossCheckVertical(size_t startI, size_t centerJ, int maxCount, int originalStateCountTotal) {
|
|
|
+
|
|
|
+ int maxI = image_->getHeight();
|
|
|
+ int stateCount[5];
|
|
|
+ for (int i = 0; i < 5; i++)
|
|
|
+ stateCount[i] = 0;
|
|
|
+
|
|
|
+
|
|
|
+ // Start counting up from center
|
|
|
+ int i = startI;
|
|
|
+ while (i >= 0 && image_->get(centerJ, i)) {
|
|
|
+ stateCount[2]++;
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ if (i < 0) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (i >= 0 && !image_->get(centerJ, i) && stateCount[1] <= maxCount) {
|
|
|
+ stateCount[1]++;
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ // If already too many modules in this state or ran off the edge:
|
|
|
+ if (i < 0 || stateCount[1] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (i >= 0 && image_->get(centerJ, i) && stateCount[0] <= maxCount) {
|
|
|
+ stateCount[0]++;
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ if (stateCount[0] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Now also count down from center
|
|
|
+ i = startI + 1;
|
|
|
+ while (i < maxI && image_->get(centerJ, i)) {
|
|
|
+ stateCount[2]++;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ if (i == maxI) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (i < maxI && !image_->get(centerJ, i) && stateCount[3] < maxCount) {
|
|
|
+ stateCount[3]++;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ if (i == maxI || stateCount[3] >= maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (i < maxI && image_->get(centerJ, i) && stateCount[4] < maxCount) {
|
|
|
+ stateCount[4]++;
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ if (stateCount[4] >= maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ // If we found a finder-pattern-like section, but its size is more than 40% different than
|
|
|
+ // the original, assume it's a false positive
|
|
|
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
|
|
|
+ if (5 * abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : NAN;
|
|
|
+}
|
|
|
+
|
|
|
+float FinderPatternFinder::crossCheckHorizontal(size_t startJ, size_t centerI, int maxCount,
|
|
|
+ int originalStateCountTotal) {
|
|
|
+
|
|
|
+ int maxJ = image_->getWidth();
|
|
|
+ int stateCount[5];
|
|
|
+ for (int i = 0; i < 5; i++)
|
|
|
+ stateCount[i] = 0;
|
|
|
+
|
|
|
+ int j = startJ;
|
|
|
+ while (j >= 0 && image_->get(j, centerI)) {
|
|
|
+ stateCount[2]++;
|
|
|
+ j--;
|
|
|
+ }
|
|
|
+ if (j < 0) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (j >= 0 && !image_->get(j, centerI) && stateCount[1] <= maxCount) {
|
|
|
+ stateCount[1]++;
|
|
|
+ j--;
|
|
|
+ }
|
|
|
+ if (j < 0 || stateCount[1] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (j >= 0 && image_->get(j, centerI) && stateCount[0] <= maxCount) {
|
|
|
+ stateCount[0]++;
|
|
|
+ j--;
|
|
|
+ }
|
|
|
+ if (stateCount[0] > maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ j = startJ + 1;
|
|
|
+ while (j < maxJ && image_->get(j, centerI)) {
|
|
|
+ stateCount[2]++;
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+ if (j == maxJ) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (j < maxJ && !image_->get(j, centerI) && stateCount[3] < maxCount) {
|
|
|
+ stateCount[3]++;
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+ if (j == maxJ || stateCount[3] >= maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+ while (j < maxJ && image_->get(j, centerI) && stateCount[4] < maxCount) {
|
|
|
+ stateCount[4]++;
|
|
|
+ j++;
|
|
|
+ }
|
|
|
+ if (stateCount[4] >= maxCount) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ // If we found a finder-pattern-like section, but its size is significantly different than
|
|
|
+ // the original, assume it's a false positive
|
|
|
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
|
|
|
+ if (5 * abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) {
|
|
|
+ return NAN;
|
|
|
+ }
|
|
|
+
|
|
|
+ return foundPatternCross(stateCount) ? centerFromEnd(stateCount, j) : NAN;
|
|
|
+}
|
|
|
+
|
|
|
+bool FinderPatternFinder::handlePossibleCenter(int* stateCount, size_t i, size_t j) {
|
|
|
+ int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
|
|
|
+ float centerJ = centerFromEnd(stateCount, j);
|
|
|
+ float centerI = crossCheckVertical(i, (size_t)centerJ, stateCount[2], stateCountTotal);
|
|
|
+ if (!isnan(centerI)) {
|
|
|
+ // Re-cross check
|
|
|
+ centerJ = crossCheckHorizontal((size_t)centerJ, (size_t)centerI, stateCount[2], stateCountTotal);
|
|
|
+ if (!isnan(centerJ)) {
|
|
|
+ float estimatedModuleSize = (float)stateCountTotal / 7.0f;
|
|
|
+ bool found = false;
|
|
|
+ size_t max = possibleCenters_.size();
|
|
|
+ for (size_t index = 0; index < max; index++) {
|
|
|
+ Ref<FinderPattern> center = possibleCenters_[index];
|
|
|
+ // Look for about the same center and module size:
|
|
|
+ if (center->aboutEquals(estimatedModuleSize, centerI, centerJ)) {
|
|
|
+ possibleCenters_[index] = center->combineEstimate(centerI, centerJ, estimatedModuleSize);
|
|
|
+ found = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!found) {
|
|
|
+ Ref<FinderPattern> newPattern(new FinderPattern(centerJ, centerI, estimatedModuleSize));
|
|
|
+ possibleCenters_.push_back(newPattern);
|
|
|
+ if (callback_ != 0) {
|
|
|
+ callback_->foundPossibleResultPoint(*newPattern);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+int FinderPatternFinder::findRowSkip() {
|
|
|
+ size_t max = possibleCenters_.size();
|
|
|
+ if (max <= 1) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ Ref<FinderPattern> firstConfirmedCenter;
|
|
|
+ for (size_t i = 0; i < max; i++) {
|
|
|
+ Ref<FinderPattern> center = possibleCenters_[i];
|
|
|
+ if (center->getCount() >= CENTER_QUORUM) {
|
|
|
+ if (firstConfirmedCenter == 0) {
|
|
|
+ firstConfirmedCenter = center;
|
|
|
+ } else {
|
|
|
+ // We have two confirmed centers
|
|
|
+ // How far down can we skip before resuming looking for the next
|
|
|
+ // pattern? In the worst case, only the difference between the
|
|
|
+ // difference in the x / y coordinates of the two centers.
|
|
|
+ // This is the case where you find top left first. Draw it out.
|
|
|
+ hasSkipped_ = true;
|
|
|
+ return (int)(abs(firstConfirmedCenter->getX() - center->getX()) - abs(firstConfirmedCenter->getY()
|
|
|
+ - center->getY()))/2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+bool FinderPatternFinder::haveMultiplyConfirmedCenters() {
|
|
|
+ int confirmedCount = 0;
|
|
|
+ float totalModuleSize = 0.0f;
|
|
|
+ size_t max = possibleCenters_.size();
|
|
|
+ for (size_t i = 0; i < max; i++) {
|
|
|
+ Ref<FinderPattern> pattern = possibleCenters_[i];
|
|
|
+ if (pattern->getCount() >= CENTER_QUORUM) {
|
|
|
+ confirmedCount++;
|
|
|
+ totalModuleSize += pattern->getEstimatedModuleSize();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (confirmedCount < 3) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ // OK, we have at least 3 confirmed centers, but, it's possible that one is a "false positive"
|
|
|
+ // and that we need to keep looking. We detect this by asking if the estimated module sizes
|
|
|
+ // vary too much. We arbitrarily say that when the total deviation from average exceeds
|
|
|
+ // 5% of the total module size estimates, it's too much.
|
|
|
+ float average = totalModuleSize / max;
|
|
|
+ float totalDeviation = 0.0f;
|
|
|
+ for (size_t i = 0; i < max; i++) {
|
|
|
+ Ref<FinderPattern> pattern = possibleCenters_[i];
|
|
|
+ totalDeviation += abs(pattern->getEstimatedModuleSize() - average);
|
|
|
+ }
|
|
|
+ return totalDeviation <= 0.05f * totalModuleSize;
|
|
|
+}
|
|
|
+
|
|
|
+vector<Ref<FinderPattern> > FinderPatternFinder::selectBestPatterns() {
|
|
|
+ size_t startSize = possibleCenters_.size();
|
|
|
+
|
|
|
+ if (startSize < 3) {
|
|
|
+ // Couldn't find enough finder patterns
|
|
|
+ throw zxing::ReaderException("Could not find three finder patterns");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Filter outlier possibilities whose module size is too different
|
|
|
+ if (startSize > 3) {
|
|
|
+ // But we can only afford to do so if we have at least 4 possibilities to choose from
|
|
|
+ float totalModuleSize = 0.0f;
|
|
|
+ float square = 0.0f;
|
|
|
+ for (size_t i = 0; i < startSize; i++) {
|
|
|
+ float size = possibleCenters_[i]->getEstimatedModuleSize();
|
|
|
+ totalModuleSize += size;
|
|
|
+ square += size * size;
|
|
|
+ }
|
|
|
+ float average = totalModuleSize / (float) startSize;
|
|
|
+ float stdDev = (float)sqrt(square / startSize - average * average);
|
|
|
+
|
|
|
+ sort(possibleCenters_.begin(), possibleCenters_.end(), FurthestFromAverageComparator(average));
|
|
|
+
|
|
|
+ float limit = max(0.2f * average, stdDev);
|
|
|
+
|
|
|
+ for (size_t i = 0; i < possibleCenters_.size() && possibleCenters_.size() > 3; i++) {
|
|
|
+ if (abs(possibleCenters_[i]->getEstimatedModuleSize() - average) > limit) {
|
|
|
+ possibleCenters_.erase(possibleCenters_.begin()+i);
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (possibleCenters_.size() > 3) {
|
|
|
+ // Throw away all but those first size candidate points we found.
|
|
|
+ float totalModuleSize = 0.0f;
|
|
|
+ for (size_t i = 0; i < possibleCenters_.size(); i++) {
|
|
|
+ float size = possibleCenters_[i]->getEstimatedModuleSize();
|
|
|
+ totalModuleSize += size;
|
|
|
+ }
|
|
|
+ float average = totalModuleSize / (float) possibleCenters_.size();
|
|
|
+ sort(possibleCenters_.begin(), possibleCenters_.end(), CenterComparator(average));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (possibleCenters_.size() > 3) {
|
|
|
+ possibleCenters_.erase(possibleCenters_.begin()+3,possibleCenters_.end());
|
|
|
+ }
|
|
|
+
|
|
|
+ vector<Ref<FinderPattern> > result(3);
|
|
|
+ result[0] = possibleCenters_[0];
|
|
|
+ result[1] = possibleCenters_[1];
|
|
|
+ result[2] = possibleCenters_[2];
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+vector<Ref<FinderPattern> > FinderPatternFinder::orderBestPatterns(vector<Ref<FinderPattern> > patterns) {
|
|
|
+ // Find distances between pattern centers
|
|
|
+ float abDistance = distance(patterns[0], patterns[1]);
|
|
|
+ float bcDistance = distance(patterns[1], patterns[2]);
|
|
|
+ float acDistance = distance(patterns[0], patterns[2]);
|
|
|
+
|
|
|
+ Ref<FinderPattern> topLeft;
|
|
|
+ Ref<FinderPattern> topRight;
|
|
|
+ Ref<FinderPattern> bottomLeft;
|
|
|
+ // Assume one closest to other two is top left;
|
|
|
+ // topRight and bottomLeft will just be guesses below at first
|
|
|
+ if (bcDistance >= abDistance && bcDistance >= acDistance) {
|
|
|
+ topLeft = patterns[0];
|
|
|
+ topRight = patterns[1];
|
|
|
+ bottomLeft = patterns[2];
|
|
|
+ } else if (acDistance >= bcDistance && acDistance >= abDistance) {
|
|
|
+ topLeft = patterns[1];
|
|
|
+ topRight = patterns[0];
|
|
|
+ bottomLeft = patterns[2];
|
|
|
+ } else {
|
|
|
+ topLeft = patterns[2];
|
|
|
+ topRight = patterns[0];
|
|
|
+ bottomLeft = patterns[1];
|
|
|
+ }
|
|
|
+
|
|
|
+ // Use cross product to figure out which of other1/2 is the bottom left
|
|
|
+ // pattern. The vector "top-left -> bottom-left" x "top-left -> top-right"
|
|
|
+ // should yield a vector with positive z component
|
|
|
+ if ((bottomLeft->getY() - topLeft->getY()) * (topRight->getX() - topLeft->getX()) < (bottomLeft->getX()
|
|
|
+ - topLeft->getX()) * (topRight->getY() - topLeft->getY())) {
|
|
|
+ Ref<FinderPattern> temp = topRight;
|
|
|
+ topRight = bottomLeft;
|
|
|
+ bottomLeft = temp;
|
|
|
+ }
|
|
|
+
|
|
|
+ vector<Ref<FinderPattern> > results(3);
|
|
|
+ results[0] = bottomLeft;
|
|
|
+ results[1] = topLeft;
|
|
|
+ results[2] = topRight;
|
|
|
+ return results;
|
|
|
+}
|
|
|
+
|
|
|
+float FinderPatternFinder::distance(Ref<ResultPoint> p1, Ref<ResultPoint> p2) {
|
|
|
+ float dx = p1->getX() - p2->getX();
|
|
|
+ float dy = p1->getY() - p2->getY();
|
|
|
+ return (float)sqrt(dx * dx + dy * dy);
|
|
|
+}
|
|
|
+
|
|
|
+FinderPatternFinder::FinderPatternFinder(Ref<BitMatrix> image,
|
|
|
+ Ref<ResultPointCallback>const& callback) :
|
|
|
+ image_(image), possibleCenters_(), hasSkipped_(false), callback_(callback) {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<FinderPatternInfo> FinderPatternFinder::find(DecodeHints const& hints) {
|
|
|
+ bool tryHarder = hints.getTryHarder();
|
|
|
+
|
|
|
+ size_t maxI = image_->getHeight();
|
|
|
+ size_t maxJ = image_->getWidth();
|
|
|
+
|
|
|
+
|
|
|
+ // We are looking for black/white/black/white/black modules in
|
|
|
+ // 1:1:3:1:1 ratio; this tracks the number of such modules seen so far
|
|
|
+
|
|
|
+ // As this is used often, we use an integer array instead of vector
|
|
|
+ int stateCount[5];
|
|
|
+ bool done = false;
|
|
|
+
|
|
|
+
|
|
|
+ // Let's assume that the maximum version QR Code we support takes up 1/4
|
|
|
+ // the height of the image, and then account for the center being 3
|
|
|
+ // modules in size. This gives the smallest number of pixels the center
|
|
|
+ // could be, so skip this often. When trying harder, look for all
|
|
|
+ // QR versions regardless of how dense they are.
|
|
|
+ int iSkip = (3 * maxI) / (4 * MAX_MODULES);
|
|
|
+ if (iSkip < MIN_SKIP || tryHarder) {
|
|
|
+ iSkip = MIN_SKIP;
|
|
|
+ }
|
|
|
+
|
|
|
+ // This is slightly faster than using the Ref. Efficiency is important here
|
|
|
+ BitMatrix& matrix = *image_;
|
|
|
+
|
|
|
+ for (size_t i = iSkip - 1; i < maxI && !done; i += iSkip) {
|
|
|
+ // Get a row of black/white values
|
|
|
+
|
|
|
+ stateCount[0] = 0;
|
|
|
+ stateCount[1] = 0;
|
|
|
+ stateCount[2] = 0;
|
|
|
+ stateCount[3] = 0;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ int currentState = 0;
|
|
|
+ for (size_t j = 0; j < maxJ; j++) {
|
|
|
+ if (matrix.get(j, i)) {
|
|
|
+ // Black pixel
|
|
|
+ if ((currentState & 1) == 1) { // Counting white pixels
|
|
|
+ currentState++;
|
|
|
+ }
|
|
|
+ stateCount[currentState]++;
|
|
|
+ } else { // White pixel
|
|
|
+ if ((currentState & 1) == 0) { // Counting black pixels
|
|
|
+ if (currentState == 4) { // A winner?
|
|
|
+ if (foundPatternCross(stateCount)) { // Yes
|
|
|
+ bool confirmed = handlePossibleCenter(stateCount, i, j);
|
|
|
+ if (confirmed) {
|
|
|
+ // Start examining every other line. Checking each line turned out to be too
|
|
|
+ // expensive and didn't improve performance.
|
|
|
+ iSkip = 2;
|
|
|
+ if (hasSkipped_) {
|
|
|
+ done = haveMultiplyConfirmedCenters();
|
|
|
+ } else {
|
|
|
+ int rowSkip = findRowSkip();
|
|
|
+ if (rowSkip > stateCount[2]) {
|
|
|
+ // Skip rows between row of lower confirmed center
|
|
|
+ // and top of presumed third confirmed center
|
|
|
+ // but back up a bit to get a full chance of detecting
|
|
|
+ // it, entire width of center of finder pattern
|
|
|
+
|
|
|
+ // Skip by rowSkip, but back off by stateCount[2] (size
|
|
|
+ // of last center of pattern we saw) to be conservative,
|
|
|
+ // and also back off by iSkip which is about to be
|
|
|
+ // re-added
|
|
|
+ i += rowSkip - stateCount[2] - iSkip;
|
|
|
+ j = maxJ - 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ stateCount[0] = stateCount[2];
|
|
|
+ stateCount[1] = stateCount[3];
|
|
|
+ stateCount[2] = stateCount[4];
|
|
|
+ stateCount[3] = 1;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ currentState = 3;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Clear state to start looking again
|
|
|
+ currentState = 0;
|
|
|
+ stateCount[0] = 0;
|
|
|
+ stateCount[1] = 0;
|
|
|
+ stateCount[2] = 0;
|
|
|
+ stateCount[3] = 0;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ } else { // No, shift counts back by two
|
|
|
+ stateCount[0] = stateCount[2];
|
|
|
+ stateCount[1] = stateCount[3];
|
|
|
+ stateCount[2] = stateCount[4];
|
|
|
+ stateCount[3] = 1;
|
|
|
+ stateCount[4] = 0;
|
|
|
+ currentState = 3;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ stateCount[++currentState]++;
|
|
|
+ }
|
|
|
+ } else { // Counting white pixels
|
|
|
+ stateCount[currentState]++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (foundPatternCross(stateCount)) {
|
|
|
+ bool confirmed = handlePossibleCenter(stateCount, i, maxJ);
|
|
|
+ if (confirmed) {
|
|
|
+ iSkip = stateCount[0];
|
|
|
+ if (hasSkipped_) {
|
|
|
+ // Found a third one
|
|
|
+ done = haveMultiplyConfirmedCenters();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ vector<Ref<FinderPattern> > patternInfo = selectBestPatterns();
|
|
|
+ patternInfo = orderBestPatterns(patternInfo);
|
|
|
+
|
|
|
+ Ref<FinderPatternInfo> result(new FinderPatternInfo(patternInfo));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/FinderPatternInfo.cpp
|
|
|
+
|
|
|
+/*
|
|
|
+ * FinderPatternInfo.cpp
|
|
|
+ * zxing
|
|
|
+ *
|
|
|
+ * Created by Christian Brunschen on 13/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/detector/FinderPatternInfo.h>
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+FinderPatternInfo::FinderPatternInfo(std::vector<Ref<FinderPattern> > patternCenters) :
|
|
|
+ bottomLeft_(patternCenters[0]), topLeft_(patternCenters[1]), topRight_(patternCenters[2]) {
|
|
|
+}
|
|
|
+
|
|
|
+Ref<FinderPattern> FinderPatternInfo::getBottomLeft() {
|
|
|
+ return bottomLeft_;
|
|
|
+}
|
|
|
+Ref<FinderPattern> FinderPatternInfo::getTopLeft() {
|
|
|
+ return topLeft_;
|
|
|
+}
|
|
|
+Ref<FinderPattern> FinderPatternInfo::getTopRight() {
|
|
|
+ return topRight_;
|
|
|
+}
|
|
|
+
|
|
|
+}
|
|
|
+}
|
|
|
+
|
|
|
+// file: zxing/qrcode/detector/QREdgeDetector.cpp
|
|
|
+
|
|
|
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
|
|
|
+/*
|
|
|
+ * Created by Ralf Kistner on 7/12/2009.
|
|
|
+ * 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/detector/QREdgeDetector.h>
|
|
|
+// #include <zxing/common/EdgeDetector.h>
|
|
|
+// #include <cstdlib>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+namespace zxing {
|
|
|
+namespace qrcode {
|
|
|
+
|
|
|
+static const float patternEdgeThreshold = 2;
|
|
|
+static const int patternEdgeWidth = 3;
|
|
|
+static const float patternEdgeSearchRatio = 1.1;
|
|
|
+static const int patternEdgeSkip = 2;
|
|
|
+
|
|
|
+static const float accurateEdgeThreshold = 3.3;
|
|
|
+static const int accurateEdgeWidth = 7;
|
|
|
+static const int accurateEdgeSkip = 2;
|
|
|
+
|
|
|
+static Point guessLastPattern(Point topLeft, Point topRight, Point bottomLeft) {
|
|
|
+ return Point(topRight.x - topLeft.x + bottomLeft.x, topRight.y - topLeft.y + bottomLeft.y);
|
|
|
+}
|
|
|
+
|
|
|
+static Point rp(Ref<ResultPoint> rp) {
|
|
|
+ return Point(rp->getX(), rp->getY());
|
|
|
+}
|
|
|
+
|
|
|
+QREdgeDetector::QREdgeDetector(Ref<BitMatrix> image) : Detector(image) { }
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> QREdgeDetector::createTransform(Ref<ResultPoint> topLeft, Ref<ResultPoint> topRight, Ref <
|
|
|
+ ResultPoint > bottomLeft, Ref<ResultPoint> alignmentPattern, int dimension) {
|
|
|
+
|
|
|
+ if(alignmentPattern == NULL) {
|
|
|
+ Point corner = findCorner(*Detector::getImage(), rp(topLeft), rp(topRight), rp(bottomLeft), dimension);
|
|
|
+ return get1CornerTransform(rp(topLeft), rp(topRight), rp(bottomLeft), corner, dimension);
|
|
|
+ } else {
|
|
|
+ return Detector::createTransform(topLeft, topRight, bottomLeft, alignmentPattern, dimension);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+Point QREdgeDetector::findCorner(const BitMatrix& image, Point topLeft, Point topRight, Point bottomLeft, int dimension) {
|
|
|
+ (void)dimension;
|
|
|
+ Point bottomRight = guessLastPattern(topLeft, topRight, bottomLeft);
|
|
|
+
|
|
|
+ Line bottomEst = findPatternEdge(image, bottomLeft, topLeft, bottomRight, false);
|
|
|
+ Line rightEst = findPatternEdge(image, topRight, topLeft, bottomRight, true);
|
|
|
+
|
|
|
+ //return EdgeDetector::intersection(bottomEst, rightEst);
|
|
|
+
|
|
|
+ Line bottom = EdgeDetector::findLine(image, bottomEst, false, accurateEdgeWidth, accurateEdgeThreshold, accurateEdgeSkip);
|
|
|
+ Line right = EdgeDetector::findLine(image, rightEst, true, accurateEdgeWidth, accurateEdgeThreshold, accurateEdgeSkip);
|
|
|
+
|
|
|
+
|
|
|
+ return EdgeDetector::intersection(bottom, right);
|
|
|
+}
|
|
|
+
|
|
|
+Line QREdgeDetector::findPatternEdge(const BitMatrix& image, Point pattern, Point opposite, Point direction, bool invert) {
|
|
|
+ Point start = endOfReverseBlackWhiteBlackRun(image, pattern, opposite);
|
|
|
+
|
|
|
+ float dx = pattern.x - start.x;
|
|
|
+ float dy = pattern.y - start.y;
|
|
|
+ float dist = sqrt(dx*dx + dy*dy);
|
|
|
+
|
|
|
+ float dirX = direction.x - pattern.x;
|
|
|
+ float dirY = direction.y - pattern.y;
|
|
|
+ float dirSize = sqrt(dirX*dirX + dirY*dirY);
|
|
|
+
|
|
|
+ float nx = dirX/dirSize;
|
|
|
+ float ny = dirY/dirSize;
|
|
|
+
|
|
|
+ float search = dist * patternEdgeSearchRatio;
|
|
|
+ Point a(start.x + nx*search, start.y + ny*search);
|
|
|
+ Point b(start.x - nx*search, start.y - ny*search);
|
|
|
+
|
|
|
+ return EdgeDetector::findLine(image, Line(a, b), invert, patternEdgeWidth, patternEdgeThreshold, patternEdgeSkip);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+Ref<PerspectiveTransform> QREdgeDetector::get1CornerTransform(Point topLeft, Point topRight, Point bottomLeft, Point corner, int dimension) {
|
|
|
+ float dimMinusThree = (float) dimension - 3.5f;
|
|
|
+
|
|
|
+ Ref<PerspectiveTransform> transform(PerspectiveTransform::quadrilateralToQuadrilateral(3.5f, 3.5f, dimMinusThree, 3.5f, dimension,
|
|
|
+ dimension, 3.5f, dimMinusThree, topLeft.x, topLeft.y, topRight.x,
|
|
|
+ topRight.y, corner.x, corner.y, bottomLeft.x, bottomLeft.y));
|
|
|
+
|
|
|
+ return transform;
|
|
|
+}
|
|
|
+
|
|
|
+// Adapted from "sizeOfBlackWhiteBlackRun" in zxing::qrcode::Detector
|
|
|
+Point QREdgeDetector::endOfReverseBlackWhiteBlackRun(const BitMatrix& image, Point from, Point to) {
|
|
|
+ int fromX = (int)from.x;
|
|
|
+ int fromY = (int)from.y;
|
|
|
+ int toX = (int)to.x;
|
|
|
+ int toY = (int)to.y;
|
|
|
+
|
|
|
+ bool steep = abs(toY - fromY) > abs(toX - fromX);
|
|
|
+ if (steep) {
|
|
|
+ int temp = fromX;
|
|
|
+ fromX = fromY;
|
|
|
+ fromY = temp;
|
|
|
+ temp = toX;
|
|
|
+ toX = toY;
|
|
|
+ toY = temp;
|
|
|
+ }
|
|
|
+
|
|
|
+ int dx = abs(toX - fromX);
|
|
|
+ int dy = abs(toY - fromY);
|
|
|
+ int error = -dx >> 1;
|
|
|
+ int ystep = fromY < toY ? -1 : 1;
|
|
|
+ int xstep = fromX < toX ? -1 : 1;
|
|
|
+ int state = 0; // In black pixels, looking for white, first or second time
|
|
|
+
|
|
|
+ // In case there are no points, prepopulate to from
|
|
|
+ int realX = fromX;
|
|
|
+ int realY = fromY;
|
|
|
+ for (int x = fromX, y = fromY; x != toX; x += xstep) {
|
|
|
+ realX = steep ? y : x;
|
|
|
+ realY = steep ? x : y;
|
|
|
+
|
|
|
+ if(realX < 0 || realY < 0 || realX >= (int)image.getWidth() || realY >= (int)image.getHeight())
|
|
|
+ break;
|
|
|
+
|
|
|
+ if (state == 1) { // In white pixels, looking for black
|
|
|
+ if (image.get(realX, realY)) {
|
|
|
+ state++;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (!image.get(realX, realY)) {
|
|
|
+ state++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state == 3) { // Found black, white, black, and stumbled back onto white; done
|
|
|
+ return Point(realX, realY);
|
|
|
+ }
|
|
|
+ error += dy;
|
|
|
+ if (error > 0) {
|
|
|
+ y += ystep;
|
|
|
+ error -= dx;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // B-W-B run not found, return the last point visited.
|
|
|
+ return Point(realX, realY);
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace qrcode
|
|
|
+} // namespace zxing
|
|
|
+
|
