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

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

@@ -0,0 +1,23 @@
+/*
+* Copyright 2026 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Reader.h"
+
+namespace ZXing::MicroPdf417 {
+
+/**
+* This implementation can detect and decode Micro PDF417 codes in an image.
+*/
+class Reader : public ZXing::Reader
+{
+public:
+	using ZXing::Reader::Reader;
+
+	BarcodesData read(const BinaryBitmap& image, int maxSymbols) const override;
+};
+
+} // namespace ZXing::MicroPdf417

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

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "PDF417.h"
+
+#include "LogMatrix.h"
+#include "PDFCodewordDecoder.h"
+
+namespace ZXing::PDF417 {
+
+#if 0
+// upstream PDF417 PatternView -> codeword implementation (uses "pick the closest pattern" approach and is worse than the below implementation)
+using Pattern417I = std::array<int, Pdf417::CodewordDecoder::BARS_IN_MODULE>;
+static Pattern417I GetPdf417PatternFromBits(uint32_t value)
+{
+	Pattern417I result{};
+	for (int i = 7; i >= 0; --i)
+		value >>= (result[i] = std::countr_one(value) + std::countr_zero(value));
+	return result;
+}
+
+Codeword ReadCodeword(BitMatrixModuleCursorF& cur)
+{
+	auto pattern = cur.template readPatternFromBlack<Pattern417I>(cur.ms / 2, cur.ms * (17 + MS_THR), cur.ms * (17 - MS_THR));
+	auto symbol = Pdf417::CodewordDecoder::GetDecodedValue(pattern);
+	int cluster = CodewordCluster(GetPdf417PatternFromBits(symbol));
+	int codeword = Pdf417::CodewordDecoder::GetCodeword(symbol);
+	return {cluster, codeword};
+}
+#else
+Codeword ReadCodeword(BitMatrixModuleCursorF& cur)
+{
+    auto start = cur.p;
+	auto pattern = cur.template readPatternFromBlack<Pattern417>(cur.ms / 2, cur.ms * (17 + MS_THR), cur.ms * (17 - MS_THR));
+	auto np = NormalizedPattern<8, 17>(pattern);
+    int cluster = CodewordCluster(np);
+#if 0
+	int codeword = Pdf417::CodewordDecoder::GetCodeword(ToInt(np));
+#else
+	int codeword = Pdf417::CodewordDecoder::GetCodeword(NormalizedE2EPattern<8, 17>(pattern));
+#endif
+	return {codeword, cluster, 1, PointT<float>(start), PointT<float>(cur.p)};
+}
+#endif
+
+Codeword ReadCodeword(BitMatrixModuleCursorF& cur, int expectedCluster)
+{
+	log(cur.p, 4);
+	auto start = cur;
+	auto cw = ReadCodeword(cur);
+	if (!cw || cw.cluster != expectedCluster) {
+		for (auto offset : {start.left(), start.right()}) {
+			auto curAlt = start.movedBy(cur.ms / 2 * offset);
+			if (auto cwAlt = ReadCodeword(curAlt)) {
+				if (!cw || cwAlt.cluster == expectedCluster) {
+					cw = cwAlt;
+					if (cwAlt.cluster == expectedCluster)
+						break;
+				}
+			}
+		}
+	}
+	if (cw)
+		cur.ms = dot(cur.p - start.p, mainDirection(cur.d)) / 17.f;
+	printf("%3d/%d, ms: %.1f, @ %5.1fx%5.1f | ", cw.codeword, cw.cluster, cur.ms, cur.p.x, cur.p.y);
+
+	return cw;
+}
+
+bool SkipCodeword(BitMatrixModuleCursorF& cur)
+{
+	int min = cur.ms * (17 - MS_THR), max = cur.ms * (17 + MS_THR);
+	int steps = cur.stepToEdge(8, max);
+	int totalSteps = steps;
+	while (totalSteps < min && steps) {
+		steps = cur.stepToEdge(2, max - totalSteps);
+		totalSteps += steps;
+	}
+	cur.ms = totalSteps / 17.f;
+	return totalSteps >= min && max > 0;
+}
+
+} // namespace ZXing::PDF417

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2026 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrixCursor.h"
+#include "Pattern.h"
+#include "Point.h"
+#include "ZXAlgorithms.h"
+
+#ifndef PRINT_DEBUG
+#define printf(...){}
+#define printv(...){}
+#else
+#define printv(prefix, fmt, postfix, ...) \
+printf("%s", prefix); \
+for (auto v : __VA_ARGS__) \
+	printf(fmt, v); \
+printf("%s", postfix);
+#endif
+
+namespace ZXing::PDF417 {
+
+constexpr int MS_THR = 2; // tolerance of pattern size in modules
+
+using Pattern417 = std::array<uint16_t, 8>;
+
+struct Codeword
+{
+	int codeword : 12 = -1;
+	int cluster  : 4 = -1;
+	int count    : 16 = 0;
+	PointT<float> left, right;
+
+	constexpr operator bool() const noexcept { return codeword != -1 && cluster % 3 == 0; }
+	constexpr bool operator==(const Codeword& other) const noexcept { return codeword == other.codeword; }
+	PointF leftPos() const noexcept { return PointF(left / count); }
+	PointF rightPos() const noexcept { return PointF(right / count); }
+};
+
+struct CodewordPattern
+{
+	int codeword  : 11 = 0;    // 11 is enough for [-1..929)
+	unsigned bits : 7 * 3 = 0; // 6/7 slots of 3 bits each for the normalized e2e pattern
+
+	constexpr bool operator<(const CodewordPattern& other) const noexcept { return bits < other.bits; }
+	constexpr int pattern(int i) const noexcept { return (bits >> ((6 - i - 1) * 3)) & 0b111; }
+	constexpr int cluster() const noexcept { return (pattern(0) - pattern(1) + pattern(4) - pattern(5) + 9) % 9; }
+};
+
+constexpr int CodewordCluster(const std::array<int, 8>& np)
+{
+	return (np[0] - np[2] + np[4] - np[6] + 9) % 9;
+}
+
+constexpr int CodewordCluster(const std::array<int, 6>& np)
+{
+	return (np[0] - np[1] + np[4] - np[5] + 9) % 9;
+}
+
+template <typename POINT>
+class BitMatrixModuleCursor : public BitMatrixCursor<POINT>
+{
+public:
+	float ms;
+
+	BitMatrixModuleCursor(const BitMatrix& image, POINT p, POINT d, float ms) : BitMatrixCursor<POINT>(image, p, d), ms(ms) {}
+
+	BitMatrixModuleCursor movedBy(POINT o) const noexcept { return {*this->img, this->p + o, this->d, ms}; }
+};
+
+using BitMatrixModuleCursorF = BitMatrixModuleCursor<PointF>;
+
+Codeword ReadCodeword(BitMatrixModuleCursorF& cur);
+Codeword ReadCodeword(BitMatrixModuleCursorF& cur, int expectedCluster);
+
+bool SkipCodeword(BitMatrixModuleCursorF& cur);
+
+} // namespace ZXing::PDF417

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

@@ -0,0 +1,53 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing {
+namespace Pdf417 {
+
+/**
+* @author Guenther Grau
+*/
+class BarcodeMetadata
+{
+	int _columnCount = 0;
+	int _errorCorrectionLevel = 0;
+	int _rowCountUpperPart = 0;
+	int _rowCountLowerPart = 0;
+
+public:
+	BarcodeMetadata() = default;
+	BarcodeMetadata(int columnCount, int rowCountUpperPart, int rowCountLowerPart, int errorCorrectionLevel)
+	    : _columnCount(columnCount), _errorCorrectionLevel(errorCorrectionLevel), _rowCountUpperPart(rowCountUpperPart),
+	      _rowCountLowerPart(rowCountLowerPart)
+	{
+	}
+
+	int columnCount() const {
+		return _columnCount;
+	}
+
+	int errorCorrectionLevel() const {
+		return _errorCorrectionLevel;
+	}
+
+	int rowCount() const {
+		return _rowCountUpperPart + _rowCountLowerPart;
+	}
+
+	int rowCountUpperPart() const {
+		return _rowCountUpperPart;
+	}
+
+	int rowCountLowerPart() const {
+		return _rowCountLowerPart;
+	}
+
+};
+
+} // Pdf417
+} // ZXing

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

@@ -0,0 +1,48 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "PDFBarcodeValue.h"
+
+#include <algorithm>
+
+namespace ZXing {
+namespace Pdf417 {
+
+/**
+* Add an occurrence of a value
+*/
+void
+BarcodeValue::setValue(int value)
+{
+	_values[value] += 1;
+}
+
+/**
+* Determines the maximum occurrence of a set value and returns all values which were set with this occurrence.
+* @return an array of int, containing the values with the highest occurrence, or null, if no value was set
+*/
+std::vector<int>
+BarcodeValue::value() const
+{
+	std::vector<int> result;
+	if (!_values.empty()) {
+		int maxConfidence = std::max_element(_values.begin(), _values.end(), [](auto& l, auto& r) { return l.second < r.second; })->second;
+		for (auto [value, count] : _values)
+			if (count == maxConfidence)
+				result.push_back(value);
+	}
+	return result;
+}
+
+int
+BarcodeValue::confidence(int value) const
+{
+	auto it = _values.find(value);
+	return it != _values.end() ? it->second : 0;
+}
+
+} // Pdf417
+} // ZXing

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

@@ -0,0 +1,38 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <map>
+#include <vector>
+
+namespace ZXing {
+namespace Pdf417 {
+
+/**
+* @author Guenther Grau
+*/
+class BarcodeValue
+{
+	std::map<int, int> _values;
+
+public:
+	/**
+	* Add an occurrence of a value
+	*/
+	void setValue(int value);
+
+	/**
+	* Determines the maximum occurrence of a set value and returns all values which were set with this occurrence.
+	* @return an array of int, containing the values with the highest occurrence, or null, if no value was set
+	*/
+	std::vector<int> value() const;
+
+	int confidence(int value) const;
+};
+
+} // Pdf417
+} // ZXing

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

@@ -0,0 +1,116 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "PDFBoundingBox.h"
+
+#include <algorithm>
+
+namespace ZXing {
+namespace Pdf417 {
+
+BoundingBox::BoundingBox() {
+	_imgWidth = _imgHeight = _minX = _maxX = _minY = _maxY = 0;
+}
+
+bool
+BoundingBox::Create(int imgWidth, int imgHeight, const Nullable<ResultPoint>& topLeft, const Nullable<ResultPoint>& bottomLeft, const Nullable<ResultPoint>& topRight, const Nullable<ResultPoint>& bottomRight, BoundingBox& result)
+{
+	if ((topLeft == nullptr && topRight == nullptr) ||
+		(bottomLeft == nullptr && bottomRight == nullptr) ||
+		(topLeft != nullptr && bottomLeft == nullptr) ||
+		(topRight != nullptr && bottomRight == nullptr)) {
+		return false;
+	}
+	result._imgWidth = imgWidth;
+	result._imgHeight = imgHeight;
+	result._topLeft = topLeft;
+	result._bottomLeft = bottomLeft;
+	result._topRight = topRight;
+	result._bottomRight = bottomRight;
+	result.calculateMinMaxValues();
+	return true;
+}
+
+void
+BoundingBox::calculateMinMaxValues()
+{
+	if (_topLeft == nullptr) {
+		_topLeft = ResultPoint(0.f, _topRight.value().y());
+		_bottomLeft = ResultPoint(0.f, _bottomRight.value().y());
+	}
+	else if (_topRight == nullptr) {
+		_topRight = ResultPoint(static_cast<float>(_imgWidth - 1), _topLeft.value().y());
+		_bottomRight = ResultPoint(static_cast<float>(_imgWidth - 1), _bottomLeft.value().y());
+	}
+
+	_minX = static_cast<int>(std::min(_topLeft.value().x(), _bottomLeft.value().x()));
+	_maxX = static_cast<int>(std::max(_topRight.value().x(), _bottomRight.value().x()));
+	_minY = static_cast<int>(std::min(_topLeft.value().y(), _topRight.value().y()));
+	_maxY = static_cast<int>(std::max(_bottomLeft.value().y(), _bottomRight.value().y()));
+}
+
+bool
+BoundingBox::Merge(const Nullable<BoundingBox>& leftBox, const Nullable<BoundingBox>& rightBox, Nullable<BoundingBox>& result)
+{
+	if (leftBox == nullptr) {
+		result = rightBox;
+		return true;
+	}
+	if (rightBox == nullptr) {
+		result = leftBox;
+		return true;
+	}
+	BoundingBox box;
+	if (Create(leftBox.value()._imgWidth, leftBox.value()._imgHeight, leftBox.value()._topLeft, leftBox.value()._bottomLeft, rightBox.value()._topRight, rightBox.value()._bottomRight, box)) {
+		result = box;
+		return true;
+	}
+	return false;
+}
+
+bool
+BoundingBox::AddMissingRows(const BoundingBox& box, int missingStartRows, int missingEndRows, bool isLeft, BoundingBox& result)
+{
+	auto newTopLeft = box._topLeft;
+	auto newBottomLeft = box._bottomLeft;
+	auto newTopRight = box._topRight;
+	auto newBottomRight = box._bottomRight;
+
+	if (missingStartRows > 0) {
+		auto top = isLeft ? box._topLeft : box._topRight;
+		int newMinY = static_cast<int>(top.value().y()) - missingStartRows;
+		if (newMinY < 0) {
+			newMinY = 0;
+		}
+		ResultPoint newTop(top.value().x(), static_cast<float>(newMinY));
+		if (isLeft) {
+			newTopLeft = newTop;
+		}
+		else {
+			newTopRight = newTop;
+		}
+	}
+
+	if (missingEndRows > 0) {
+		auto bottom = isLeft ? box._bottomLeft : box._bottomRight;
+		int newMaxY = (int)bottom.value().y() + missingEndRows;
+		if (newMaxY >= box._imgHeight) {
+			newMaxY = box._imgHeight - 1;
+		}
+		ResultPoint newBottom(bottom.value().x(), static_cast<float>(newMaxY));
+		if (isLeft) {
+			newBottomLeft = newBottom;
+		}
+		else {
+			newBottomRight = newBottom;
+		}
+	}
+
+	return Create(box._imgWidth, box._imgHeight, newTopLeft, newBottomLeft, newTopRight, newBottomRight, result);
+}
+
+} // Pdf417
+} // ZXing

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

@@ -0,0 +1,75 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ZXNullable.h"
+#include "ResultPoint.h"
+
+namespace ZXing {
+namespace Pdf417 {
+
+/**
+* @author Guenther Grau
+*/
+class BoundingBox
+{
+	int _imgWidth;
+	int _imgHeight;
+	Nullable<ResultPoint> _topLeft;
+	Nullable<ResultPoint> _bottomLeft;
+	Nullable<ResultPoint> _topRight;
+	Nullable<ResultPoint> _bottomRight;
+	int _minX;
+	int _maxX;
+	int _minY;
+	int _maxY;
+
+public:
+	BoundingBox();
+
+	int minX() const {
+		return _minX;
+	}
+
+	int maxX() const {
+		return _maxX;
+	}
+
+	int minY() const {
+		return _minY;
+	}
+
+	int maxY() const {
+		return _maxY;
+	}
+
+	Nullable<ResultPoint> topLeft() const {
+		return _topLeft;
+	}
+
+	Nullable<ResultPoint> topRight() const {
+		return _topRight;
+	}
+
+	Nullable<ResultPoint> bottomLeft() const {
+		return _bottomLeft;
+	}
+
+	Nullable<ResultPoint> bottomRight() const {
+		return _bottomRight;
+	}
+
+	static bool Create(int imgWidth, int imgHeight, const Nullable<ResultPoint>& topLeft, const Nullable<ResultPoint>& bottomLeft, const Nullable<ResultPoint>& topRight, const Nullable<ResultPoint>& bottomRight, BoundingBox& result);
+	static bool Merge(const Nullable<BoundingBox>& leftBox, const Nullable<BoundingBox>& rightBox, Nullable<BoundingBox>& result);
+	static bool AddMissingRows(const BoundingBox&box, int missingStartRows, int missingEndRows, bool isLeft, BoundingBox& result);
+
+private:
+	void calculateMinMaxValues();
+};
+
+} // Pdf417
+} // ZXing

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

@@ -0,0 +1,71 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing {
+namespace Pdf417 {
+
+/**
+* @author Guenther Grau
+*/
+class Codeword
+{
+	static const int BARCODE_ROW_UNKNOWN = -1;
+
+	int _startX = 0;
+	int _endX = 0;
+	int _bucket = 0;
+	int _value = 0;
+	int _rowNumber = BARCODE_ROW_UNKNOWN;
+
+public:
+	Codeword() = default;
+	Codeword(int startX, int endX, int bucket, int value) : _startX(startX), _endX(endX), _bucket(bucket), _value(value) {}
+
+	bool hasValidRowNumber() const {
+		return isValidRowNumber(_rowNumber);
+	}
+
+	bool isValidRowNumber(int rowNumber) const {
+		return rowNumber != BARCODE_ROW_UNKNOWN && _bucket == (rowNumber % 3) * 3;
+	}
+
+	void setRowNumberAsRowIndicatorColumn() {
+		_rowNumber = (_value / 30) * 3 + _bucket / 3;
+	}
+
+	int width() const {
+		return _endX - _startX;
+	}
+
+	int startX() const {
+		return _startX;
+	}
+
+	int endX() const {
+		return _endX;
+	}
+
+	int bucket() const {
+		return _bucket;
+	}
+
+	int value() const {
+		return _value;
+	}
+
+	int rowNumber() const {
+		return _rowNumber;
+	}
+
+	void setRowNumber(int rowNumber) {
+		_rowNumber = rowNumber;
+	}
+};
+
+} // Pdf417
+} // ZXing