react-native-nitro-zxing 0.1.0-alpha.0

package/cpp/zxing-core/core/src/pdf417/PDFDecoder.h

@@ -0,0 +1,20 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <vector>
+
+namespace ZXing {
+
+class DecoderResult;
+
+namespace Pdf417 {
+
+DecoderResult Decode(const std::vector<int>& codewords);
+
+} // namespace Pdf417
+} // namespace ZXing

package/cpp/zxing-core/core/src/pdf417/PDFDetectionResult.cpp

@@ -0,0 +1,247 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "PDFDetectionResult.h"
+#include "PDFCodewordDecoder.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <array>
+
+namespace ZXing {
+namespace Pdf417 {
+
+static const int ADJUST_ROW_NUMBER_SKIP = 2;
+
+DetectionResult::DetectionResult(const BarcodeMetadata& barcodeMetadata, const Nullable<BoundingBox>& boundingBox) :
+	_barcodeMetadata(barcodeMetadata),
+	_detectionResultColumns(barcodeMetadata.columnCount() + 2),
+	_boundingBox(boundingBox)
+{
+}
+
+void
+DetectionResult::init(const BarcodeMetadata& barcodeMetadata, const Nullable<BoundingBox>& boundingBox)
+{
+	_barcodeMetadata = barcodeMetadata;
+	_boundingBox = boundingBox;
+	_detectionResultColumns.resize(barcodeMetadata.columnCount() + 2);
+	std::fill(_detectionResultColumns.begin(), _detectionResultColumns.end(), nullptr);
+}
+
+static void AdjustIndicatorColumnRowNumbers(Nullable<DetectionResultColumn>& detectionResultColumn, const BarcodeMetadata& barcodeMetadata)
+{
+	if (detectionResultColumn != nullptr) {
+		detectionResultColumn.value().adjustCompleteIndicatorColumnRowNumbers(barcodeMetadata);
+	}
+}
+
+static void AdjustRowNumbersFromBothRI(std::vector<Nullable<DetectionResultColumn>>& detectionResultColumns)
+{
+	if (detectionResultColumns.front() == nullptr || detectionResultColumns.back() == nullptr) {
+		return;
+	}
+	auto& LRIcodewords = detectionResultColumns.front().value().allCodewords();
+	auto& RRIcodewords = detectionResultColumns.back().value().allCodewords();
+	for (size_t codewordsRow = 0; codewordsRow < LRIcodewords.size(); codewordsRow++) {
+		if (LRIcodewords[codewordsRow] != nullptr && RRIcodewords[codewordsRow] != nullptr &&
+			LRIcodewords[codewordsRow].value().rowNumber() == RRIcodewords[codewordsRow].value().rowNumber()) {
+			auto lastColumn = detectionResultColumns.end() - 1;
+			for (auto columnIter = detectionResultColumns.begin() + 1; columnIter != lastColumn; ++columnIter) {
+				if (!columnIter->hasValue()) {
+					continue;
+				}
+				auto& codeword = columnIter->value().allCodewords()[codewordsRow];
+				if (codeword != nullptr) {
+					codeword.value().setRowNumber(LRIcodewords[codewordsRow].value().rowNumber());
+					if (!codeword.value().hasValidRowNumber()) {
+						columnIter->value().allCodewords()[codewordsRow] = nullptr;
+					}
+				}
+			}
+		}
+	}
+}
+
+static int AdjustRowNumberIfValid(int rowIndicatorRowNumber, int invalidRowCounts, Codeword& codeword) {
+	if (!codeword.hasValidRowNumber()) {
+		if (codeword.isValidRowNumber(rowIndicatorRowNumber)) {
+			codeword.setRowNumber(rowIndicatorRowNumber);
+			invalidRowCounts = 0;
+		}
+		else {
+			++invalidRowCounts;
+		}
+	}
+	return invalidRowCounts;
+}
+
+static int AdjustRowNumbersFromLRI(std::vector<Nullable<DetectionResultColumn>>& detectionResultColumns) {
+	if (detectionResultColumns.front() == nullptr) {
+		return 0;
+	}
+	int unadjustedCount = 0;
+	auto& codewords = detectionResultColumns.front().value().allCodewords();
+	for (size_t codewordsRow = 0; codewordsRow < codewords.size(); codewordsRow++) {
+		if (codewords[codewordsRow] == nullptr) {
+			continue;
+		}
+		int rowIndicatorRowNumber = codewords[codewordsRow].value().rowNumber();
+		int invalidRowCounts = 0;
+		auto lastColumn = detectionResultColumns.end() - 1;
+		for (auto columnIter = detectionResultColumns.begin() + 1; columnIter != lastColumn && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP; ++columnIter) {
+			if (!columnIter->hasValue()) {
+				continue;
+			}
+			auto& codeword = columnIter->value().allCodewords()[codewordsRow];
+			if (codeword != nullptr) {
+				invalidRowCounts = AdjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword.value());
+				if (!codeword.value().hasValidRowNumber()) {
+					unadjustedCount++;
+				}
+			}
+		}
+	}
+	return unadjustedCount;
+}
+
+static int AdjustRowNumbersFromRRI(std::vector<Nullable<DetectionResultColumn>>& detectionResultColumns) {
+	if (detectionResultColumns.back() == nullptr) {
+		return 0;
+	}
+	int unadjustedCount = 0;
+	auto& codewords = detectionResultColumns.back().value().allCodewords();
+	for (size_t codewordsRow = 0; codewordsRow < codewords.size(); codewordsRow++) {
+		if (codewords[codewordsRow] == nullptr) {
+			continue;
+		}
+		int rowIndicatorRowNumber = codewords[codewordsRow].value().rowNumber();
+		int invalidRowCounts = 0;
+		auto lastColumn = detectionResultColumns.end() - 1;
+		for (auto columnIter = detectionResultColumns.begin() + 1; columnIter != lastColumn && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP; ++columnIter) {
+			if (!columnIter->hasValue()) {
+				continue;
+			}
+			auto& codeword = columnIter->value().allCodewords()[codewordsRow];
+			if (codeword != nullptr) {
+				invalidRowCounts = AdjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword.value());
+				if (!codeword.value().hasValidRowNumber()) {
+					unadjustedCount++;
+				}
+			}
+		}
+	}
+	return unadjustedCount;
+}
+
+
+static int AdjustRowNumbersByRow(std::vector<Nullable<DetectionResultColumn>>& detectionResultColumns) {
+	AdjustRowNumbersFromBothRI(detectionResultColumns);
+	// TODO we should only do full row adjustments if row numbers of left and right row indicator column match.
+	// Maybe it's even better to calculated the height (in codeword rows) and divide it by the number of barcode
+	// rows. This, together with the LRI and RRI row numbers should allow us to get a good estimate where a row
+	// number starts and ends.
+	int unadjustedCount = AdjustRowNumbersFromLRI(detectionResultColumns);
+	return unadjustedCount + AdjustRowNumbersFromRRI(detectionResultColumns);
+}
+
+
+/**
+* @return true, if row number was adjusted, false otherwise
+*/
+static bool AdjustRowNumber(Nullable<Codeword>& codeword, const Nullable<Codeword>& otherCodeword) {
+	if (codeword != nullptr && otherCodeword != nullptr
+		&& otherCodeword.value().hasValidRowNumber() && otherCodeword.value().bucket() == codeword.value().bucket()) {
+		codeword.value().setRowNumber(otherCodeword.value().rowNumber());
+		return true;
+	}
+	return false;
+}
+
+static void AdjustRowNumbers(const std::vector<Nullable<DetectionResultColumn>>& detectionResultColumns, int barcodeColumn, int codewordsRow, std::vector<Nullable<Codeword>>& codewords) {
+	auto& codeword = codewords[codewordsRow];
+	auto& previousColumnCodewords = detectionResultColumns[barcodeColumn - 1].value().allCodewords();
+	auto& nextColumnCodewords = detectionResultColumns[barcodeColumn + 1] != nullptr ? detectionResultColumns[barcodeColumn + 1].value().allCodewords() : previousColumnCodewords;
+
+	std::array<Nullable<Codeword>, 14> otherCodewords;
+
+	otherCodewords[2] = previousColumnCodewords[codewordsRow];
+	otherCodewords[3] = nextColumnCodewords[codewordsRow];
+
+	if (codewordsRow > 0) {
+		otherCodewords[0] = codewords[codewordsRow - 1];
+		otherCodewords[4] = previousColumnCodewords[codewordsRow - 1];
+		otherCodewords[5] = nextColumnCodewords[codewordsRow - 1];
+	}
+	if (codewordsRow > 1) {
+		otherCodewords[8] = codewords[codewordsRow - 2];
+		otherCodewords[10] = previousColumnCodewords[codewordsRow - 2];
+		otherCodewords[11] = nextColumnCodewords[codewordsRow - 2];
+	}
+	if (codewordsRow < Size(codewords) - 1) {
+		otherCodewords[1] = codewords[codewordsRow + 1];
+		otherCodewords[6] = previousColumnCodewords[codewordsRow + 1];
+		otherCodewords[7] = nextColumnCodewords[codewordsRow + 1];
+	}
+	if (codewordsRow < Size(codewords) - 2) {
+		otherCodewords[9] = codewords[codewordsRow + 2];
+		otherCodewords[12] = previousColumnCodewords[codewordsRow + 2];
+		otherCodewords[13] = nextColumnCodewords[codewordsRow + 2];
+	}
+	for (const auto& otherCodeword : otherCodewords) {
+		if (AdjustRowNumber(codeword, otherCodeword)) {
+			return;
+		}
+	}
+}
+
+
+// TODO ensure that no detected codewords with unknown row number are left
+// we should be able to estimate the row height and use it as a hint for the row number
+// we should also fill the rows top to bottom and bottom to top
+/**
+* @return number of codewords which don't have a valid row number. Note that the count is not accurate as codewords
+* will be counted several times. It just serves as an indicator to see when we can stop adjusting row numbers
+*/
+static int AdjustRowNumbers(std::vector<Nullable<DetectionResultColumn>>& detectionResultColumns) {
+	int unadjustedCount = AdjustRowNumbersByRow(detectionResultColumns);
+	if (unadjustedCount == 0) {
+		return 0;
+	}
+	for (int barcodeColumn = 1; barcodeColumn < Size(detectionResultColumns) - 1; barcodeColumn++) {
+		if (detectionResultColumns[barcodeColumn] == nullptr) {
+			continue;
+		}
+		auto& codewords = detectionResultColumns[barcodeColumn].value().allCodewords();
+		for (int codewordsRow = 0; codewordsRow < Size(codewords); codewordsRow++) {
+			if (codewords[codewordsRow] == nullptr) {
+				continue;
+			}
+			if (!codewords[codewordsRow].value().hasValidRowNumber()) {
+				AdjustRowNumbers(detectionResultColumns, barcodeColumn, codewordsRow, codewords);
+			}
+		}
+	}
+	return unadjustedCount;
+}
+
+
+const std::vector<Nullable<DetectionResultColumn>> &
+DetectionResult::allColumns()
+{
+	AdjustIndicatorColumnRowNumbers(_detectionResultColumns.front(), _barcodeMetadata);
+	AdjustIndicatorColumnRowNumbers(_detectionResultColumns.back(), _barcodeMetadata);
+	int unadjustedCodewordCount = CodewordDecoder::MAX_CODEWORDS_IN_BARCODE;
+	int previousUnadjustedCount;
+	do {
+		previousUnadjustedCount = unadjustedCodewordCount;
+		unadjustedCodewordCount = AdjustRowNumbers(_detectionResultColumns);
+	} while (unadjustedCodewordCount > 0 && unadjustedCodewordCount < previousUnadjustedCount);
+	return _detectionResultColumns;
+}
+
+} // Pdf417
+} // ZXing

package/cpp/zxing-core/core/src/pdf417/PDFDetectionResult.h

@@ -0,0 +1,74 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "PDFBarcodeMetadata.h"
+#include "PDFBoundingBox.h"
+#include "PDFDetectionResultColumn.h"
+#include "ZXNullable.h"
+#include <vector>
+
+namespace ZXing {
+namespace Pdf417 {
+
+/**
+* @author Guenther Grau
+*/
+class DetectionResult
+{
+	BarcodeMetadata _barcodeMetadata;
+	std::vector<Nullable<DetectionResultColumn>> _detectionResultColumns;
+	Nullable<BoundingBox> _boundingBox;
+
+public:
+	DetectionResult() = default;
+	DetectionResult(const BarcodeMetadata& barcodeMetadata, const Nullable<BoundingBox>& boundingBox);
+
+	void init(const BarcodeMetadata& barcodeMetadata, const Nullable<BoundingBox>& boundingBox);
+
+	const std::vector<Nullable<DetectionResultColumn>> & allColumns();
+
+	int barcodeColumnCount() const {
+		return _barcodeMetadata.columnCount();
+	}
+
+	int barcodeRowCount() const {
+		return _barcodeMetadata.rowCount();
+	}
+
+	int barcodeECLevel() const {
+		return _barcodeMetadata.errorCorrectionLevel();
+	}
+
+	void setBoundingBox(const BoundingBox& boundingBox) {
+		_boundingBox = boundingBox;
+	}
+
+	const Nullable<BoundingBox> & getBoundingBox() const {
+		return _boundingBox;
+	}
+
+	void setBoundingBox(const Nullable<BoundingBox>& box) {
+		_boundingBox = box;
+	}
+
+	void setColumn(int barcodeColumn, const Nullable<DetectionResultColumn>& detectionResultColumn) {
+		_detectionResultColumns[barcodeColumn] = detectionResultColumn;
+	}
+
+	const Nullable<DetectionResultColumn>& column(int barcodeColumn) const {
+		return _detectionResultColumns[barcodeColumn];
+	}
+
+	Nullable<DetectionResultColumn>& column(int barcodeColumn) {
+		return _detectionResultColumns[barcodeColumn];
+	}
+
+};
+
+} // Pdf417
+} // ZXing

package/cpp/zxing-core/core/src/pdf417/PDFDetectionResultColumn.cpp

@@ -0,0 +1,321 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "PDFDetectionResultColumn.h"
+#include "PDFBarcodeMetadata.h"
+#include "PDFBarcodeValue.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+namespace ZXing {
+namespace Pdf417 {
+
+static const int MAX_NEARBY_DISTANCE = 5;
+static const int MIN_ROWS_IN_BARCODE = 3;
+static const int MAX_ROWS_IN_BARCODE = 90;
+
+DetectionResultColumn::DetectionResultColumn(const BoundingBox& boundingBox, RowIndicator rowIndicator) :
+	_boundingBox(boundingBox),
+	_rowIndicator(rowIndicator)
+{
+	if (boundingBox.maxY() < boundingBox.minY()) {
+		throw std::invalid_argument("Invalid bounding box");
+	}
+	_codewords.resize(boundingBox.maxY() - boundingBox.minY() + 1);
+}
+
+Nullable<Codeword>
+DetectionResultColumn::codewordNearby(int imageRow) const
+{
+	int index = imageRowToCodewordIndex(imageRow);
+	if (_codewords[index] != nullptr) {
+		return _codewords[index];
+	}
+
+	for (int i = 1; i < MAX_NEARBY_DISTANCE; i++) {
+		int nearImageRow = imageRowToCodewordIndex(imageRow) - i;
+		if (nearImageRow >= 0) {
+			if (_codewords[nearImageRow] != nullptr) {
+				return _codewords[nearImageRow];
+			}
+		}
+		nearImageRow = imageRowToCodewordIndex(imageRow) + i;
+		if (nearImageRow < Size(_codewords)) {
+			if (_codewords[nearImageRow] != nullptr) {
+				return _codewords[nearImageRow];
+			}
+		}
+	}
+	return nullptr;
+}
+
+void
+DetectionResultColumn::setRowNumbers()
+{
+	for (auto& codeword : allCodewords()) {
+		if (codeword != nullptr) {
+			codeword.value().setRowNumberAsRowIndicatorColumn();
+		}
+	}
+}
+
+static void RemoveIncorrectCodewords(bool isLeft, std::vector<Nullable<Codeword>>& codewords, const BarcodeMetadata& barcodeMetadata)
+{
+	// Remove codewords which do not match the metadata
+	// TODO Maybe we should keep the incorrect codewords for the start and end positions?
+	for (auto& item : codewords) {
+		if (item == nullptr) {
+			continue;
+		}
+
+		const auto& codeword = item.value();
+
+		int rowIndicatorValue = codeword.value() % 30;
+		int codewordRowNumber = codeword.rowNumber();
+		if (codewordRowNumber > barcodeMetadata.rowCount()) {
+			item = nullptr;
+			continue;
+		}
+		if (!isLeft) {
+			codewordRowNumber += 2;
+		}
+		switch (codewordRowNumber % 3) {
+		case 0:
+			if (rowIndicatorValue * 3 + 1 != barcodeMetadata.rowCountUpperPart()) {
+				item = nullptr;
+			}
+			break;
+		case 1:
+			if (rowIndicatorValue / 3 != barcodeMetadata.errorCorrectionLevel() ||
+				rowIndicatorValue % 3 != barcodeMetadata.rowCountLowerPart()) {
+				item = nullptr;
+			}
+			break;
+		case 2:
+			if (rowIndicatorValue + 1 != barcodeMetadata.columnCount()) {
+				item = nullptr;
+			}
+			break;
+		}
+	}
+}
+
+// TODO implement properly
+// TODO maybe we should add missing codewords to store the correct row number to make
+// finding row numbers for other columns easier
+// use row height count to make detection of invalid row numbers more reliable
+void
+DetectionResultColumn::adjustCompleteIndicatorColumnRowNumbers(const BarcodeMetadata& barcodeMetadata)
+{
+	if (!isRowIndicator()) {
+		return;
+	}
+
+	auto& codewords = allCodewords();
+	setRowNumbers();
+	RemoveIncorrectCodewords(isLeftRowIndicator(), codewords, barcodeMetadata);
+	const auto& bb = boundingBox();
+	auto top = isLeftRowIndicator() ? bb.topLeft() : bb.topRight();
+	auto bottom = isLeftRowIndicator() ? bb.bottomLeft() : bb.bottomRight();
+	int firstRow = imageRowToCodewordIndex((int)top.value().y());
+	int lastRow = imageRowToCodewordIndex((int)bottom.value().y());
+	// We need to be careful using the average row height. Barcode could be skewed so that we have smaller and
+	// taller rows
+	//float averageRowHeight = (lastRow - firstRow) / (float)barcodeMetadata.rowCount();
+	int barcodeRow = -1;
+	int maxRowHeight = 1;
+	int currentRowHeight = 0;
+	int increment = 1;
+	for (int codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {
+		if (codewords[codewordsRow] == nullptr) {
+			continue;
+		}
+		Codeword codeword = codewords[codewordsRow];
+		if (barcodeRow == -1 && codeword.rowNumber() == barcodeMetadata.rowCount() - 1) {
+			increment = -1;
+			barcodeRow = barcodeMetadata.rowCount();
+		}
+		//      float expectedRowNumber = (codewordsRow - firstRow) / averageRowHeight;
+		//      if (Math.abs(codeword.getRowNumber() - expectedRowNumber) > 2) {
+		//        SimpleLog.log(LEVEL.WARNING,
+		//            "Removing codeword, rowNumberSkew too high, codeword[" + codewordsRow + "]: Expected Row: " +
+		//                expectedRowNumber + ", RealRow: " + codeword.getRowNumber() + ", value: " + codeword.getValue());
+		//        codewords[codewordsRow] = null;
+		//      }
+
+		int rowDifference = codeword.rowNumber() - barcodeRow;
+
+		if (rowDifference == 0) {
+			currentRowHeight++;
+		}
+		else if (rowDifference == increment) {
+			maxRowHeight = std::max(maxRowHeight, currentRowHeight);
+			currentRowHeight = 1;
+			barcodeRow = codeword.rowNumber();
+		}
+		else if (rowDifference < 0 ||
+			codeword.rowNumber() >= barcodeMetadata.rowCount() ||
+			rowDifference > codewordsRow) {
+			codewords[codewordsRow] = nullptr;
+		}
+		else {
+			int checkedRows;
+			if (maxRowHeight > 2) {
+				checkedRows = (maxRowHeight - 2) * rowDifference;
+			}
+			else {
+				checkedRows = rowDifference;
+			}
+			bool closePreviousCodewordFound = checkedRows >= codewordsRow;
+			for (int i = 1; i <= checkedRows && !closePreviousCodewordFound; i++) {
+				// there must be (height * rowDifference) number of codewords missing. For now we assume height = 1.
+				// This should hopefully get rid of most problems already.
+				closePreviousCodewordFound = codewords[codewordsRow - i] != nullptr;
+			}
+			if (closePreviousCodewordFound) {
+				codewords[codewordsRow] = nullptr;
+			}
+			else {
+				barcodeRow = codeword.rowNumber();
+				currentRowHeight = 1;
+			}
+		}
+	}
+	//return static_cast<int>(averageRowHeight + 0.5);
+}
+
+// TODO maybe we should add missing codewords to store the correct row number to make
+// finding row numbers for other columns easier
+// use row height count to make detection of invalid row numbers more reliable
+void
+DetectionResultColumn::adjustIncompleteIndicatorColumnRowNumbers(const BarcodeMetadata& barcodeMetadata)
+{
+	if (!isRowIndicator()) {
+		return;
+	}
+
+	const auto& bb = boundingBox();
+	auto top = isLeftRowIndicator() ? bb.topLeft() : bb.topRight();
+	auto bottom = isLeftRowIndicator() ? bb.bottomLeft() : bb.bottomRight();
+	int firstRow = imageRowToCodewordIndex((int)top.value().y());
+	int lastRow = imageRowToCodewordIndex((int)bottom.value().y());
+	//float averageRowHeight = (lastRow - firstRow) / (float)barcodeMetadata.rowCount();
+	auto& codewords = allCodewords();
+	int barcodeRow = -1;
+	int maxRowHeight = 1;
+	int currentRowHeight = 0;
+	for (int codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {
+		if (codewords[codewordsRow] == nullptr) {
+			continue;
+		}
+		auto& item = codewords[codewordsRow];
+
+		auto& codeword = item.value();
+		codeword.setRowNumberAsRowIndicatorColumn();
+
+		int rowDifference = codeword.rowNumber() - barcodeRow;
+
+		// TODO improve handling with case where first row indicator doesn't start with 0
+
+		if (rowDifference == 0) {
+			currentRowHeight++;
+		}
+		else if (rowDifference == 1) {
+			maxRowHeight = std::max(maxRowHeight, currentRowHeight);
+			currentRowHeight = 1;
+			barcodeRow = codeword.rowNumber();
+		}
+		else if (codeword.rowNumber() >= barcodeMetadata.rowCount()) {
+			item = nullptr;
+		}
+		else {
+			barcodeRow = codeword.rowNumber();
+			currentRowHeight = 1;
+		}
+	}
+	//return static_cast<int>(averageRowHeight + 0.5);
+}
+
+// This is example of bad design, a getter should not modify object's state
+bool
+DetectionResultColumn::getRowHeights(std::vector<int>& result)
+{
+	BarcodeMetadata barcodeMetadata;
+	if (!getBarcodeMetadata(barcodeMetadata)) {
+		return false;
+	}
+
+	adjustIncompleteIndicatorColumnRowNumbers(barcodeMetadata);
+	result.resize(barcodeMetadata.rowCount());
+	for (auto& item : allCodewords()) {
+		if (item != nullptr) {
+			size_t rowNumber = item.value().rowNumber();
+			if (rowNumber >= result.size()) {
+				// We have more rows than the barcode metadata allows for, ignore them.
+				continue;
+			}
+			result[rowNumber]++;
+		} // else throw exception?
+	}
+	return true;
+}
+
+
+// This is example of bad design, a getter should not modify object's state
+bool
+DetectionResultColumn::getBarcodeMetadata(BarcodeMetadata& result)
+{
+	if (!isRowIndicator()) {
+		return false;
+	}
+
+	auto& codewords = allCodewords();
+	BarcodeValue barcodeColumnCount;
+	BarcodeValue barcodeRowCountUpperPart;
+	BarcodeValue barcodeRowCountLowerPart;
+	BarcodeValue barcodeECLevel;
+	for (auto& item : codewords) {
+		if (item == nullptr) {
+			continue;
+		}
+		auto& codeword = item.value();
+		codeword.setRowNumberAsRowIndicatorColumn();
+		int rowIndicatorValue = codeword.value() % 30;
+		int codewordRowNumber = codeword.rowNumber();
+		if (!isLeftRowIndicator()) {
+			codewordRowNumber += 2;
+		}
+		switch (codewordRowNumber % 3) {
+		case 0:
+			barcodeRowCountUpperPart.setValue(rowIndicatorValue * 3 + 1);
+			break;
+		case 1:
+			barcodeECLevel.setValue(rowIndicatorValue / 3);
+			barcodeRowCountLowerPart.setValue(rowIndicatorValue % 3);
+			break;
+		case 2:
+			barcodeColumnCount.setValue(rowIndicatorValue + 1);
+			break;
+		}
+	}
+	// Maybe we should check if we have ambiguous values?
+	auto cc = barcodeColumnCount.value();
+	auto rcu = barcodeRowCountUpperPart.value();
+	auto rcl = barcodeRowCountLowerPart.value();
+	auto ec = barcodeECLevel.value();
+	if (cc.empty() || rcu.empty() || rcl.empty() || ec.empty() || cc[0] < 1 || rcu[0] + rcl[0] < MIN_ROWS_IN_BARCODE || rcu[0] + rcl[0] > MAX_ROWS_IN_BARCODE) {
+		return false;
+	}
+	result = { cc[0], rcu[0], rcl[0], ec[0] };
+	RemoveIncorrectCodewords(isLeftRowIndicator(), codewords, result);
+	return true;
+}
+
+
+} // Pdf417
+} // ZXing