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

package/cpp/zxing-core/core/src/JSON.h

@@ -0,0 +1,66 @@
+/*
+* Copyright 2025 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ZXAlgorithms.h"
+
+#include <cstring>
+#ifdef __cpp_lib_format // not available on gcc 12
+#include <format>
+#endif
+#include <optional>
+#include <string>
+#include <string_view>
+
+namespace ZXing {
+
+std::string JsonEscapeStr(std::string_view str);
+std::string JsonUnEscapeStr(std::string_view str);
+
+template<typename T>
+inline std::string JsonProp(std::string_view key, const T& val, const T& ignore = {})
+{
+	#define ZX_JSON_KEY_VAL(...) StrCat("\"", key, "\":", __VA_ARGS__, ',')
+#if !defined(__cpp_lib_to_chars) || !defined(__cpp_lib_format) // not available on older macOS / gcc 12
+	#define ZX_JSON_FMT_FLOAT(val) (std::to_string(int(val)) + '.' + std::to_string(int(val * 100) % 100))
+#else
+	#define ZX_JSON_FMT_FLOAT(val) std::format("{:.2f}", val)
+#endif
+
+	if constexpr (std::is_same_v<T, bool>)
+		return val != ignore ? ZX_JSON_KEY_VAL(val ? "true" : "false") : "";
+	else if constexpr (std::is_floating_point_v<T>)
+		return val != ignore ? ZX_JSON_KEY_VAL(ZX_JSON_FMT_FLOAT(val)) : "";
+	else if constexpr (std::is_integral_v<T>)
+		return val != ignore ? ZX_JSON_KEY_VAL(std::to_string(val)) : "";
+	else if constexpr (std::is_convertible_v<T, std::string_view>)
+		return std::string_view(val) != std::string_view(ignore) ? ZX_JSON_KEY_VAL("\"", JsonEscapeStr(val), "\"") : "";
+	else
+		static_assert("unsupported JSON value type");
+	#undef ZX_JSON_KEY_VAL
+}
+
+// Finds the (potentially escaped / raw) value of the provided key
+std::string_view JsonFind(std::string_view json, std::string_view key);
+
+template <typename T>
+inline std::optional<T> JsonGet(std::string_view json, std::string_view key)
+{
+	auto str = JsonFind(json, key);
+	if (!str.data())
+		return std::nullopt;
+
+	if constexpr (std::is_same_v<bool, T>)
+		return str.empty() || Contains("1tT", str.front()) ? std::optional(true) : std::nullopt;
+	else if constexpr (std::is_arithmetic_v<T>)
+		return str.empty() ? std::nullopt : std::optional(FromString<T>(str));
+	else if constexpr (std::is_same_v<std::string, T>)
+		return JsonUnEscapeStr(str);
+	else
+		static_assert("unsupported JSON value type");
+}
+
+} // ZXing

package/cpp/zxing-core/core/src/LocalGrid.cpp

@@ -0,0 +1,242 @@
+// Copyright 2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#include "LocalGrid.h"
+
+#include "LogMatrix.h"
+#include "StdGenerator.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <optional>
+#include <ranges>
+#include <span>
+#include <vector>
+
+#ifndef PRINT_DEBUG
+#define printf(...){}
+#endif
+
+namespace ZXing {
+
+// returns the average of the largest cluster of values where cluster is defined as values that are within threshold of each other
+double clusterAvg(std::ranges::range auto& v, double threshold)
+{
+	std::ranges::sort(v);
+	size_t bestStart = 0, bestLen = 0, start = 0;
+	for (size_t end = 0; end < v.size(); ++end) {
+		while (v[end] - v[start] >= threshold)
+			++start;
+		if (end - start + 1 > bestLen) {
+			bestLen = end - start + 1;
+			bestStart = start;
+		}
+	}
+	double sum = 0;
+	for (size_t i = bestStart; i < bestStart + bestLen; ++i)
+		sum += v[i];
+	sum /= bestLen;
+
+#ifdef PRINT_DEBUG
+	printf("ds: ");
+	for (auto d : v)
+		printf("%5.2f ", d);
+	printf(" -> len: %zu, avg: %5.2f\n", bestLen, sum);
+#endif
+	return sum;
+};
+
+void LocalGrid::adjustOriginAndStep(PointF& step, int radius, const std::span<const PointF> offsets)
+{
+	auto modSize = length(step);
+	int limit = int(6 * modSize);
+	auto dir = bresenhamDirection(step);
+	modSize /= length(dir); // mod size in terms of steps in the given direction
+	printf("step: (%.2f, %.2f) %.2f: ", step.x, step.y, modSize);
+
+	auto nearestHalfResidual = [](double n, double s) { return n - (std::round((n - s / 2) / s) * s + s / 2); };
+
+	struct DistMod {
+		double dist, modSize;
+	};
+	thread_local std::vector<DistMod> distMod;
+	distMod.clear();
+	distMod.reserve(offsets.size() * radius + 1);
+	for (int r = 0; r <= radius; ++r)
+		for (auto offset : offsets) {
+			auto start = origin + r * offset;
+			auto startC = centered(start);
+			int stepsPos = BitMatrixCursorF(*img, startC, dir).stepToEdge(1, limit);
+			int stepsNeg = BitMatrixCursorF(*img, startC, -dir).stepToEdge(1, limit);
+			auto distPos = stepsPos - dot(start - startC, dir) - 0.5; // +0.5 because the center of the pixel is at .5, .5
+			auto distNeg = stepsNeg - dot(start - startC, -dir) - 0.5;
+
+			if (stepsPos && stepsNeg) {
+				int blockSize = stepsPos + stepsNeg - 1;
+				auto localModSize = blockSize / std::max(1.0, std::round(blockSize / modSize));
+				distMod.emplace_back(distPos, blockSize / modSize < 5 ? localModSize : 0.0);
+				// if (r == 0 && (std::min(distNeg, distPos) < modSize / 4)) {
+				// 	origin += (distNeg < distPos ? 1 : -1) * modSize / 4 * dir;
+				// 	continue;
+				// }
+			}
+			else if (stepsPos)
+				distMod.emplace_back(distPos, 0.0);
+			else if (stepsNeg)
+				distMod.emplace_back(-distNeg, 0.0);
+
+			printf("+%.2f -%.2f (%.1f) | ", distPos, distNeg, distMod.empty() ? 0.0 : distMod.back().modSize);
+
+			if (r == 0)
+				break; // only do the center point once
+		}
+
+	// calcuate the average local module size from the points where we found one...
+	double localModSize = 0.0;
+	int n = 0;
+	for (const auto& t : distMod | std::views::filter([](const DistMod& t) { return t.modSize > 0; }))
+		localModSize += t.modSize, ++n;
+	if (n == 0)
+		return;
+	localModSize /= n;
+	printf("\nlocal mod size: %.2f\n", localModSize);
+
+	// ... and use it for the points where we didn't find one
+	thread_local std::vector<double> d;
+	d.clear();
+	d.reserve(distMod.size());
+	for (auto& t : distMod) {
+		if (t.modSize == 0.0)
+			t.modSize = localModSize;
+		d.push_back(t.dist < 0 ? -nearestHalfResidual(-t.dist, t.modSize) : nearestHalfResidual(t.dist, t.modSize));
+		printf("%.2f (%.1f) -> %.2f | ", t.dist, t.modSize, d.back());
+	}
+	printf("\n");
+
+	origin += clusterAvg(d, modSize / 2) * dir;
+
+	// if we found local mod sizes for each point (hopefully at the timing pattern crosses), we update the step size
+	if (n == Size(distMod) && std::abs(localModSize - modSize) > modSize * 0.1) {
+		step = localModSize / modSize * step;
+		printf("   adjusted mod size from %.2f to %.2f\n", modSize, localModSize);
+	}
+}
+
+LocalGrid::LocalGrid(const BitMatrix& image, const PerspectiveTransform& mod2Pix, PointI p, PointI dim, PointI offset)
+	: img(&image), dim(dim), center(p)
+{
+	origin = mod2Pix(centered(p));
+	stepX = mod2Pix(centered(p) + PointF{1, 0}) - origin;
+	stepY = mod2Pix(centered(p) + PointF{0, 1}) - origin;
+
+	printf("LocalGrid @ (%d, %d), initial origin: (%.2f, %.2f), offset: (%d, %d), stepX: (%.2f, %.2f), stepY: (%.2f, %.2f)\n",
+		   center.x, center.y, origin.x, origin.y, offset.x, offset.y, stepX.x, stepX.y, stepY.x, stepY.y);
+	log(origin, 3);
+
+	auto offsets = std::array{-stepX, -stepY, stepX, stepY}; // works better for DataMatrix (especially near the symbol edges)
+	// auto offsets = std::array{-stepX - stepY, stepX - stepY, stepX + stepY, -stepX + stepY};
+	// auto offsets = std::array{-stepX, -stepY, stepX, stepY, -stepX - stepY, stepX - stepY, stepX + stepY, -stepX + stepY};
+
+	// evaluate the image at origin + offset (allows to effectively work near the border of the symbol)
+	origin = getPos(PointF(offset));
+	for (int i = 0; i < 2; ++i) {
+		adjustOriginAndStep(stepX, 2, offsets);
+		adjustOriginAndStep(stepY, 2, offsets);
+		printf("\n");
+	}
+	origin = getPos(PointF(-offset));
+}
+
+bool LocalGrid::isTimingPatternCross(PointI p, bool isBlack, int radius, int errorThreshold)
+{
+	// TODO: look into replacing this with something along the lines of CheckSymmetricAztecCenterPattern
+	auto wrapOffset = [&](int center, int offset, int dim) {
+		int pos = center + offset;
+		return pos < 0 ? radius - pos : (pos >= dim ? -(radius + (pos - dim) + 1) : offset);
+	};
+
+	int errors = 0;
+	for (int r = 0; r <= radius; ++r) {
+		auto check = [&](int x, int y) {
+			x = wrapOffset(center.x, x, dim.x);
+			y = wrapOffset(center.y, y, dim.y);
+			auto d = PointI(x, y);
+			errors += !findValue(p + d, d, Value((x + y) % 2 == (isBlack ? 0 : 1)));
+		};
+		check(-r, 0);
+		check(r, 0);
+		check(0, -r);
+		check(0, r);
+		if (errors > errorThreshold)
+			return false;
+	}
+	return errors <= errorThreshold;
+};
+
+std::optional<PointF> LocalGrid::findTimingPatternCross(bool isBlack, int radius)
+{
+	for (auto p : Spiral(3)) {
+		// check if there is a timing pattern cross candidate centered at p with half the radius
+		if (isTimingPatternCross(p, isBlack, radius / 2)) {
+			auto original = origin;
+			origin = getPos(p);
+			// adjust origin and step with full radius and only in the direction of the timing pattern
+			printf("timing pattern:\n");
+			adjustOriginAndStep(stepX, radius, std::array{-stepX, stepX});
+			adjustOriginAndStep(stepY, radius, std::array{-stepY, stepY});
+
+			// check again, now with the full radius, to make sure we are correctly aligned to the timing pattern
+			if (isTimingPatternCross(PointI{0, 0}, isBlack, radius))
+				return origin;
+
+			origin = original;
+		}
+	}
+	return {};
+}
+
+bool LocalGrid::findPattern(int radius, PointI timingStart, Directions timingDirs, PointI blackStart, Directions blackDirs,
+							PointI whiteStart, Directions whiteDirs)
+{
+	auto isPatternAt = [&](PointI p) {
+		for (int r = 0; r <= radius; ++r) {
+			for (auto d : timingDirs)
+				if (!findValue(p + timingStart + r * d, d, Value(r % 2 == 1)))
+					return false;
+			for (auto d : blackDirs)
+				if (!findValue(p + blackStart + r * d, d, Value(true)))
+					return false;
+			for (auto d : whiteDirs)
+				if (!findValue(p + whiteStart + r * d, d, Value(false)))
+					return false;
+		}
+		return true;
+	};
+
+	for (auto p : Spiral(3)) {
+		if (isPatternAt(p)) {
+			auto original = origin;
+			origin = getPos(PointF(p));
+			// adjust origin and step with full radius and only in the direction of the timing pattern
+			printf("found pattern at (%.2f, %.2f)\n", origin.x, origin.y);
+			std::vector<PointF> stepsX, stepsY;
+			for (auto d : timingDirs)
+				d.y == 0 ? stepsX.push_back(d.x * stepX) : stepsY.push_back(d.y * stepY);
+
+			if (!stepsX.empty())
+				adjustOriginAndStep(stepX, radius, stepsX);
+			if (!stepsY.empty())
+				adjustOriginAndStep(stepY, radius, stepsY);
+			if ((!stepsX.empty() || !stepsY.empty()) && !isPatternAt(PointI{0, 0})) {
+				origin = original;
+				printf("pattern lost after adjusting for timing pattern, reverting origin\n");
+			}
+			printf("\n");
+			return true;
+		}
+	}
+	printf("\n");
+	return false;
+}
+
+} // namespace ZXing

package/cpp/zxing-core/core/src/LocalGrid.h

@@ -0,0 +1,91 @@
+// Copyright 2026 Axel Waggershauser
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrixCursor.h"
+#include "BitMatrix.h"
+#include "LogMatrix.h"
+#include "Point.h"
+#include "PerspectiveTransform.h"
+
+#include <optional>
+#include <span>
+
+namespace ZXing {
+
+/**
+ * @brief Represents a local grid for sampling and analyzing regions within a BitMatrix image.
+ *
+ * The LocalGrid class tries to find the center of a module and step vectors that point to the next module in x and y direction.
+ * It provides methods to get the position of a point in the grid and to sample values from the image at those positions.
+ * It supports searching for timing pattern crosses and specific (alignment) patterns within the grid, which updates the origin and
+ * step vectors accordingly.
+ */
+class LocalGrid
+{
+	const BitMatrix* img;
+	PointF origin, stepX, stepY;
+	PointI dim, center;
+
+	using Value = BitMatrixCursorF::Value;
+
+	void adjustOriginAndStep(PointF& dir, int radius, std::span<const PointF> offsets);
+	bool isTimingPatternCross(PointI p, bool isBlack, int radius, int errorThreshold = 0);
+	bool findValue(PointI p, PointI dir, Value v)
+	{
+		// check if there is a value v at p or a quarter module before or after p or p is outside the image
+		auto d = PointF(dir.x ? 0.25 : 0.0, dir.y ? 0.25 : 0.0);
+		return !img->isIn(getPos(p)) || get(p) == v || get(p + d) == v || get(p - d) == v;
+	};
+
+public:
+
+	/**
+	 * @brief Constructs a LocalGrid object for mapping a region of a BitMatrix using a perspective transform.
+	 *
+	 * @param image The source BitMatrix representing the image data.
+	 * @param mod2Pix The (global) PerspectiveTransform used to map module coordinates to pixel coordinates.
+	 * @param p The logical position of the grid origin in module coordinates.
+	 * @param dim The dimensions (width and height) of the (global) grid in modules.
+	 * @param offset Optional offset in modules to specify the starting position of the search for the module center.
+	 */
+	LocalGrid(const BitMatrix& image, const PerspectiveTransform& mod2Pix, PointI p, PointI dim, PointI offset = {});
+
+	inline PointF getPos(PointF p = {}) const { return origin + p.x * stepX + p.y * stepY; }
+	inline PointF getPos(PointI p) const { return getPos(PointF(p.x, p.y)); }
+
+	inline Value get(PointF p) const
+	{
+		auto q = getPos(p);
+		log(q, 4);
+		return img->isIn(q) ? Value{img->get(q)} : Value{};
+	}
+
+	inline Value get(PointI p) const { return get(PointF(p.x, p.y)); }
+
+	/**
+	 * @brief Finds the center of a timing pattern cross in the local grid.
+	 *
+	 * This function searches for the center point of a timing pattern cross, which is a key feature in Aztec code detection, within a
+	 * specified radius.
+	 *
+	 * @param isBlack Indicates whether the central module of the timing pattern cross is expected to be black or white.
+	 * @param radius The length of the timing pattern cross arms.
+	 * @return An optional PointF representing the center of the timing pattern cross if found; std::nullopt otherwise.
+	 */
+	std::optional<PointF> findTimingPatternCross(bool isBlack, int radius);
+
+	using Directions = std::span<const PointI>;
+
+	/**
+	 * @brief Searches for a specific pattern within a grid based on provided parameters.
+	 *
+	 * This function attempts to locate a pattern in the grid by starting from given points
+	 * and following specified directions for timing, black, and white modules.
+	 */
+	bool findPattern(int radius, PointI timingStart, Directions timingDirs, PointI blackStart, Directions blackDirs, PointI whiteStart,
+					 Directions whiteDirs);
+};
+
+} // namespace ZXing

package/cpp/zxing-core/core/src/LogMatrix.h

@@ -0,0 +1,105 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrix.h"
+#include "Matrix.h"
+#include "Point.h"
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+
+namespace ZXing {
+
+#ifdef PRINT_DEBUG
+
+class LogMatrix
+{
+	using LogBuffer = Matrix<int8_t>;
+	LogBuffer _log;
+	const BitMatrix* _image = nullptr;
+	int _scale = 1;
+
+public:
+	void init(const BitMatrix* image, int scale = 1)
+	{
+		_image = image;
+		_scale = scale;
+		_log = LogBuffer(_image->width() * _scale, _image->height() * _scale);
+	}
+
+	void write(const char* fn)
+	{
+		assert(_image);
+		FILE* f = fopen(fn, "wb");
+
+		// Write PPM header, P5 == grey, P6 == rgb
+		fprintf(f, "P6\n%d %d\n255\n", _log.width(), _log.height());
+
+		// Write pixels
+		for (int y = 0; y < _log.height(); ++y)
+			for (int x = 0; x < _log.width(); ++x) {
+				unsigned char pix[3];
+				unsigned char &r = pix[0], &g = pix[1], &b = pix[2];
+				r = g = b = _image->get(x / _scale, y / _scale) ? 0 : 255;
+				if (_scale > 1 && x % _scale == _scale / 2 && y % _scale == _scale / 2)
+					r = g = b = r ? 240 : 45;
+				switch (_log.get(x, y)) {
+				case -1: r = g = b = _scale > 1 ? 255 - r : (r ? 50 : 230); break;
+				case 1: r = g = b = _scale > 1 ? 128 : (r ? 230 : 50); break;
+				case 2: r = b = 50, g = 220; break;
+				case 3: g = r = 100, b = 250; break;
+				case 4: g = b = 100, r = 250; break;
+				}
+				fwrite(&pix, 3, 1, f);
+			}
+		fclose(f);
+	}
+
+	template <typename T>
+	void operator()(const PointT<T>& p, int color = 1)
+	{
+		if (_image && _image->isIn(p))
+			_log.set(static_cast<int>(p.x * _scale), static_cast<int>(p.y * _scale), color);
+	}
+
+	void operator()(const PointT<int>& p, int color)
+	{
+		operator()(centered(p), color);
+	}
+
+	template <typename T>
+	void operator()(const std::vector<PointT<T>>& points, int color = 2)
+	{
+		for (auto p : points)
+			operator()(p, color);
+	}
+};
+
+extern LogMatrix log;
+
+class LogMatrixWriter
+{
+	LogMatrix &log;
+	std::string fn;
+
+public:
+	LogMatrixWriter(LogMatrix& log, const BitMatrix& image, int scale, std::string fn) : log(log), fn(fn)
+	{
+		log.init(&image, scale);
+	}
+	~LogMatrixWriter() { log.write(fn.c_str()); }
+};
+
+#else
+
+template<typename T> void log(PointT<T>, int = 0) {}
+
+#endif
+
+} // namespace ZXing

package/cpp/zxing-core/core/src/Matrix.h

@@ -0,0 +1,125 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Point.h"
+
+#include <stdexcept>
+#include <algorithm>
+#include <cassert>
+#include <vector>
+
+namespace ZXing {
+
+template <class T>
+class Matrix
+{
+public:
+	using value_t = T;
+
+private:
+	int _width = 0;
+	int _height = 0;
+	std::vector<value_t> _data;
+
+	// Nothing wrong to support it, just to make it explicit, instead of by mistake.
+	// Use copy() below.
+	Matrix(const Matrix &) = default;
+
+public:
+	Matrix() = default;
+
+#if defined(__llvm__) || (defined(__GNUC__) && (__GNUC__ > 7))
+	__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+	Matrix(int width, int height, value_t val = {}) : _width(width), _height(height), _data(_width * _height, val) {
+		if (width != 0 && int(_data.size()) / width != height)
+			throw std::invalid_argument("Invalid size: width * height is too big");
+	}
+
+	Matrix(Matrix&&) noexcept = default;
+	Matrix& operator=(Matrix&&) noexcept = default;
+	Matrix& operator=(const Matrix &) = delete;
+
+	Matrix copy() const {
+		return *this;
+	}
+
+	int height() const {
+		return _height;
+	}
+
+	int width() const {
+		return _width;
+	}
+
+	int size() const {
+		return int(_data.size());
+	}
+
+	value_t& operator()(int x, int y)
+	{
+		assert(x >= 0 && x < _width && y >= 0 && y < _height);
+		return _data[y * _width + x];
+	}
+
+	const T& operator()(int x, int y) const
+	{
+		assert(x >= 0 && x < _width && y >= 0 && y < _height);
+		return _data[y * _width + x];
+	}
+
+	value_t& operator()(PointI p) {
+		return operator()(p.x, p.y);
+	}
+
+	const T& operator()(PointI p) const {
+		return operator()(p.x, p.y);
+	}
+
+	const value_t& get(int x, int y) const {
+		return operator()(x, y);
+	}
+
+	value_t& set(int x, int y, value_t value) {
+		return operator()(x, y) = value;
+	}
+
+	const value_t& get(PointI p) const {
+		return operator()(p.x, p.y);
+	}
+
+	value_t& set(PointI p, value_t value) {
+		return operator()(p.x, p.y) = value;
+	}
+
+	const value_t* data() const {
+		return _data.data();
+	}
+
+	const value_t* begin() const {
+		return _data.data();
+	}
+
+	const value_t* end() const {
+		return _data.data() + _width * _height;
+	}
+
+	value_t* begin() {
+		return _data.data();
+	}
+
+	value_t* end() {
+		return _data.data() + _width * _height;
+	}
+
+	void clear(value_t value = {}) {
+		std::fill(_data.begin(), _data.end(), value);
+	}
+};
+
+} // ZXing