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

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

@@ -0,0 +1,253 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitMatrix.h"
+#include "Point.h"
+#include "StdGenerator.h"
+
+#include <climits>
+
+namespace ZXing {
+
+enum class Direction { LEFT = -1, RIGHT = 1 };
+
+inline Direction opposite(Direction dir) noexcept
+{
+	return dir == Direction::LEFT ? Direction::RIGHT : Direction::LEFT;
+}
+
+/**
+ * @brief The BitMatrixCursor represents a current position inside an image and current direction it can advance towards.
+ *
+ * The current position and direction is a PointT<T>. So depending on the type it can be used to traverse the image
+ * in a Bresenham style (PointF) or in a discrete way (step only horizontal/vertical/diagonal (PointI)).
+ */
+template<typename POINT>
+class BitMatrixCursor
+{
+	using this_t = BitMatrixCursor<POINT>;
+
+public:
+	const BitMatrix* img;
+
+	POINT p; // current position
+	POINT d; // current direction
+
+	BitMatrixCursor(const BitMatrix& image, POINT p, POINT d) : img(&image), p(p) { setDirection(d); }
+
+	class Value
+	{
+		enum { INVALID = -1, WHITE = 0, BLACK = 1 };
+		int v = INVALID;
+	public:
+		Value() = default;
+		Value(bool isBlack) : v(isBlack) {}
+		bool isValid() const noexcept { return v != INVALID; }
+		bool isWhite() const noexcept { return v == WHITE; }
+		bool isBlack() const noexcept { return v == BLACK; }
+
+		operator bool() const noexcept { return isValid(); }
+
+		bool operator==(Value o) const { return v == o.v; }
+	};
+
+	template <typename T>
+	Value testAt(PointT<T> p) const
+	{
+		return img->isIn(p) ? Value{img->get(p)} : Value{};
+	}
+
+	bool blackAt(POINT pos) const noexcept { return testAt(pos).isBlack(); }
+	bool whiteAt(POINT pos) const noexcept { return testAt(pos).isWhite(); }
+
+	bool isIn(POINT p) const noexcept { return img->isIn(p); }
+	bool isIn() const noexcept { return isIn(p); }
+	bool isBlack() const noexcept { return blackAt(p); }
+	bool isWhite() const noexcept { return whiteAt(p); }
+
+	POINT front() const noexcept { return d; }
+	POINT back() const noexcept { return -d; }
+	POINT left() const noexcept { return ZXing::left(d); }
+	POINT right() const noexcept { return ZXing::right(d); }
+	POINT direction(Direction dir) const noexcept { return static_cast<int>(dir) * right(); }
+
+	void turnBack() noexcept { d = back(); }
+	void turnLeft() noexcept { d = left(); }
+	void turnRight() noexcept { d = right(); }
+	void turn(Direction dir) noexcept { d = direction(dir); }
+
+	Value edgeAt(POINT d) const noexcept
+	{
+		Value v = testAt(p);
+		return testAt(p + d) != v ? v : Value();
+	}
+
+	Value edgeAtFront() const noexcept { return edgeAt(front()); }
+	Value edgeAtBack() const noexcept { return edgeAt(back()); }
+	Value edgeAtLeft() const noexcept { return edgeAt(left()); }
+	Value edgeAtRight() const noexcept { return edgeAt(right()); }
+	Value edgeAt(Direction dir) const noexcept { return edgeAt(direction(dir)); }
+
+	this_t& setDirection(PointF dir) { return d = bresenhamDirection(dir), *this; }
+	this_t& setDirection(PointI dir) { return d = dir, *this; }
+
+	bool step(typename POINT::value_t s = 1)
+	{
+		p += s * d;
+		return isIn(p);
+	}
+
+	this_t movedBy(POINT o) const noexcept { return {*img, p + o, d}; }
+	this_t turnedBack() const noexcept { return {*img, p, back()}; }
+
+	/**
+	 * @brief stepToEdge advances cursor to one step behind the next (or n-th) edge.
+	 * @param nth number of edges to pass
+	 * @param range max number of steps to take
+	 * @param backup whether or not to backup one step so we land in front of the edge
+	 * @return number of steps taken or 0 if moved outside of range/image
+	 */
+	int stepToEdge(int nth = 1, int range = 0, bool backup = false)
+	{
+		int steps = 0;
+		auto lv = testAt(p);
+
+		while (nth && (!range || steps < range) && lv.isValid()) {
+			++steps;
+			auto v = testAt(p + steps * d);
+			if (lv != v) {
+				lv = v;
+				--nth;
+			}
+		}
+		if (backup)
+			--steps;
+		p += steps * d;
+		return steps * (nth == 0);
+	}
+
+	bool stepAlongEdge(Direction dir, bool skipCorner = false)
+	{
+		if (!edgeAt(dir))
+			turn(dir);
+		else if (edgeAtFront()) {
+			turn(opposite(dir));
+			if (edgeAtFront()) {
+				turn(opposite(dir));
+				if (edgeAtFront())
+					return false;
+			}
+		}
+
+		bool ret = step();
+
+		if (ret && skipCorner && !edgeAt(dir)) {
+			turn(dir);
+			ret = step();
+		}
+
+		return ret;
+	}
+
+	int countEdges(int range)
+	{
+		int res = 0;
+
+		while (int steps = range ? stepToEdge(1, range) : 0) {
+			range -= steps;
+			++res;
+		}
+
+		return res;
+	}
+
+	template<typename ARRAY>
+	ARRAY readPattern(int max = 0, int min = 0)
+	{
+		ARRAY res = {};
+		for (auto& i : res) {
+			i = stepToEdge(1, max);
+			if (!i)
+				return res;
+			if (max)
+				max -= i;
+		}
+		if (min && max) {
+			min -= Reduce(res);
+			int steps = -1;
+			while (min > 0 && max && (steps = stepToEdge(2, max))) {
+				max -= steps;
+				min -= steps;
+			}
+		}
+		return res;
+	}
+
+	template<typename ARRAY>
+	ARRAY readPatternFromBlack(int maxWhitePrefix, int max = 0, int min = 0)
+	{
+		if (maxWhitePrefix && isWhite() && !stepToEdge(1, maxWhitePrefix))
+			return {};
+		return readPattern<ARRAY>(max, min);
+	}
+};
+
+using BitMatrixCursorF = BitMatrixCursor<PointF>;
+using BitMatrixCursorI = BitMatrixCursor<PointI>;
+
+class FastEdgeToEdgeCounter
+{
+	const uint8_t* p = nullptr;
+	int stride = 0;
+	int stepsToBorder = 0;
+
+public:
+	FastEdgeToEdgeCounter(const BitMatrixCursorI& cur)
+	{
+		stride = cur.d.y * cur.img->width() + cur.d.x;
+		p = cur.img->row(cur.p.y).begin() + cur.p.x;
+
+		int maxStepsX = cur.d.x ? (cur.d.x > 0 ? cur.img->width() - 1 - cur.p.x : cur.p.x) : INT_MAX;
+		int maxStepsY = cur.d.y ? (cur.d.y > 0 ? cur.img->height() - 1 - cur.p.y : cur.p.y) : INT_MAX;
+		stepsToBorder = std::min(maxStepsX, maxStepsY);
+	}
+
+	int stepToNextEdge(int range)
+	{
+		int maxSteps = std::min(stepsToBorder, range);
+		int steps = 0;
+		do {
+			if (++steps > maxSteps) {
+				if (maxSteps == stepsToBorder)
+					break;
+				else
+					return 0;
+			}
+		} while (p[steps * stride] == p[0]);
+
+		p += steps * stride;
+		stepsToBorder -= steps;
+
+		return steps;
+	}
+};
+
+// Generate points in a spiral pattern around the center
+inline std::generator<PointI> Spiral(int radius)
+{
+	co_yield{0, 0};
+	for (int r = 1; r <= radius; ++r) {
+		// clang-format off
+		for (int k = 0; k < 2 * r; ++k) co_yield{           r, -(r - 1) + k}; // right -> down
+		for (int k = 0; k < 2 * r; ++k)	co_yield{ (r - 1) - k,            r}; // bottom -> left
+		for (int k = 0; k < 2 * r; ++k)	co_yield{          -r,  (r - 1) - k}; // left -> up
+		for (int k = 0; k < 2 * r; ++k)	co_yield{-(r - 1) + k,           -r}; // top -> right
+		// clang-format on
+	}
+}
+
+} // ZXing

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

@@ -0,0 +1,101 @@
+/*
+* Copyright 2017 Huy Cuong Nguyen
+* Copyright 2017 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BitMatrixIO.h"
+
+#include <array>
+#include <fstream>
+#include <sstream>
+
+namespace ZXing {
+
+std::string ToString(const BitMatrix& matrix, char one, char zero, bool addSpace, bool printAsCString)
+{
+	std::string result;
+	result.reserve((addSpace ? 2 : 1) * (matrix.width() * matrix.height()) + matrix.height());
+	for (int y = 0; y < matrix.height(); ++y) {
+		if (printAsCString)
+			result += '"';
+		for (auto bit : matrix.row(y)) {
+			result += bit ? one : zero;
+			if (addSpace)
+				result += ' ';
+		}
+		if (printAsCString)
+			result += "\\n\"";
+		result += '\n';
+	}
+	return result;
+}
+
+std::string ToString(const BitMatrix& matrix, bool inverted)
+{
+	constexpr auto map = std::array{" ", "▀", "▄", "█"};
+	std::string res;
+
+	for (int y = 0; y < matrix.height(); y += 2) {
+		for (int x = 0; x < matrix.width(); ++x) {
+			int tp = matrix.get(x, y) ^ inverted;
+			int bt = (matrix.height() == 1 && tp) || (y + 1 < matrix.height() && (matrix.get(x, y + 1) ^ inverted));
+			res += map[tp | (bt << 1)];
+		}
+		res.push_back('\n');
+	}
+
+	return res;
+}
+
+std::string ToSVG(const BitMatrix& matrix)
+{
+	// see https://stackoverflow.com/questions/10789059/create-qr-code-in-vector-image/60638350#60638350
+
+	const int width = matrix.width();
+	const int height = matrix.height();
+	std::ostringstream out;
+
+	out << R"(<?xml version="1.0" encoding="UTF-8"?>)" << "\n"
+		<< R"(<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 )" << width << ' ' << height << R"(" stroke="none">)"
+		<< "\n<path d=\"";
+
+	for (int y = 0; y < height; ++y)
+		for (int x = 0; x < width; ++x)
+			if (matrix.get(x, y))
+				out << "M" << x << "," << y << "h1v1h-1z";
+
+	out << "\"/>\n</svg>";
+
+	return out.str();
+}
+
+BitMatrix ParseBitMatrix(const std::string& str, char one, bool expectSpace)
+{
+	auto lineLength = str.find('\n');
+	if (lineLength == std::string::npos)
+		return {};
+
+	int strStride = expectSpace ? 2 : 1;
+	int height = narrow_cast<int>(str.length() / (lineLength + 1));
+	int width = narrow_cast<int>(lineLength / strStride);
+	BitMatrix mat(width, height);
+	for (int y = 0; y < height; ++y) {
+		size_t offset = y * (lineLength + 1);
+		for (int x = 0; x < width; ++x, offset += strStride) {
+			if (str[offset] == one)
+				mat.set(x, y);
+		}
+	}
+	return mat;
+}
+
+void SaveAsPBM(const BitMatrix& matrix, const std::string& filename, int quietZone)
+{
+	auto out = ToMatrix<uint8_t>(Inflate(matrix.copy(), 0, 0, quietZone));
+	std::ofstream file(filename);
+	file << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file.write(reinterpret_cast<const char*>(out.data()), out.size());
+}
+
+} // ZXing

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

@@ -0,0 +1,21 @@
+/*
+* Copyright 2017 Huy Cuong Nguyen
+* Copyright 2017 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+#include "BitMatrix.h"
+
+namespace ZXing {
+
+std::string ToString(const BitMatrix& matrix, bool inverted = false);
+std::string ToString(const BitMatrix& matrix, char one, char zero = ' ', bool addSpace = true, bool printAsCString = false);
+std::string ToSVG(const BitMatrix& matrix);
+BitMatrix ParseBitMatrix(const std::string& str, char one = 'X', bool expectSpace = true);
+void SaveAsPBM(const BitMatrix& matrix, const std::string& filename, int quietZone = 0);
+
+} // ZXing

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

@@ -0,0 +1,77 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BitSource.h"
+
+#include "ByteArray.h"
+#include "ZXAlgorithms.h"
+
+#include <stdexcept>
+
+namespace ZXing {
+
+int
+BitSource::available() const
+{
+	return 8 * (Size(_bytes) - _byteOffset) - _bitOffset;
+}
+
+static int ReadBitsImpl(int numBits, const ByteArray& _bytes, int available, int& _byteOffset, int& _bitOffset)
+{
+	if (numBits < 1 || numBits > 32 || numBits > available) {
+		throw std::out_of_range("BitSource::readBits: out of range");
+	}
+
+	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];
+			_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::readBits(int numBits)
+{
+	return ReadBitsImpl(numBits, _bytes, available(), _byteOffset, _bitOffset);
+}
+
+int BitSource::peekBits(int numBits) const
+{
+	int bitOffset = _bitOffset;
+	int byteOffset = _byteOffset;
+	return ReadBitsImpl(numBits, _bytes, available(), byteOffset, bitOffset);
+}
+
+} // ZXing

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

@@ -0,0 +1,72 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing {
+
+class ByteArray;
+
+/**
+* <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+* number of bits read is not often a multiple of 8.</p>
+*
+* <p>This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
+* it passed in, in which case all bets are off.</p>
+*
+* @author Sean Owen
+*/
+class BitSource
+{
+	const ByteArray& _bytes;
+	int _byteOffset = 0;
+	int _bitOffset = 0;
+
+public:
+	/**
+	* @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+	* Bits are read within a byte from most-significant to least-significant bit.
+	* IMPORTANT: Bit source DOES NOT copy data byte, thus make sure that the bytes outlive the bit source object.
+	*/
+	explicit BitSource(const ByteArray& bytes) : _bytes(bytes) {}
+	
+	BitSource(BitSource &) = delete;
+	BitSource& operator=(const BitSource &) = delete;
+
+	/**
+	* @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.
+	*/
+	int bitOffset() const {
+		return _bitOffset;
+	}
+
+	/**
+	* @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.
+	*/
+	int byteOffset() const {
+		return _byteOffset;
+	}
+
+	/**
+	* @param numBits number of bits to read
+	* @return int representing the bits read. The bits will appear as the least-significant bits of the int
+	*/
+	int readBits(int numBits);
+
+	/**
+	* @param numBits number of bits to peek at
+	* @return int representing the bits peeked at.  The bits will appear as the least-significant
+	*         bits of the int
+	*/
+	int peekBits(int numBits) const;
+
+	/**
+	* @return number of bits that can be read successfully
+	*/
+	int available() const;
+};
+
+} // ZXing

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

@@ -0,0 +1,42 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2022 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Range.h"
+
+#include <cstdint>
+#include <string_view>
+#include <vector>
+
+namespace ZXing {
+
+/**
+	ByteArray is an extension of std::vector<uint8_t>.
+*/
+class ByteArray : public std::vector<uint8_t>
+{
+public:
+	ByteArray() = default;
+	ByteArray(std::initializer_list<uint8_t> list) : std::vector<uint8_t>(list) {}
+	explicit ByteArray(int len) : std::vector<uint8_t>(len, 0) {}
+	explicit ByteArray(std::string_view str) : std::vector<uint8_t>(str.begin(), str.end()) {}
+
+	void append(ByteView other) { insert(end(), other.begin(), other.end()); }
+	void append(std::string_view other) { insert(end(), other.begin(), other.end()); }
+
+	std::string_view asString(size_t pos = 0, size_t len = std::string_view::npos) const
+	{
+		return std::string_view(reinterpret_cast<const char*>(data()), size()).substr(pos, len);
+	}
+
+	ByteView asView(size_t pos = 0, size_t len = size_t(-1)) const
+	{
+		return ByteView(*this).subview(pos, len);
+	}
+};
+
+} // ZXing

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

@@ -0,0 +1,78 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "CharacterSet.h"
+
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+
+namespace ZXing {
+
+struct CharacterSetName
+{
+	std::string_view name;
+	CharacterSet cs;
+};
+
+static CharacterSetName NAME_TO_CHARSET[] = {
+	{"Cp437",		CharacterSet::Cp437},
+	{"ISO-8859-1",	CharacterSet::ISO8859_1},
+	{"ISO-8859-2",	CharacterSet::ISO8859_2},
+	{"ISO-8859-3",	CharacterSet::ISO8859_3},
+	{"ISO-8859-4",	CharacterSet::ISO8859_4},
+	{"ISO-8859-5",	CharacterSet::ISO8859_5},
+	{"ISO-8859-6",	CharacterSet::ISO8859_6},
+	{"ISO-8859-7",	CharacterSet::ISO8859_7},
+	{"ISO-8859-8",	CharacterSet::ISO8859_8},
+	{"ISO-8859-9",	CharacterSet::ISO8859_9},
+	{"ISO-8859-10",	CharacterSet::ISO8859_10},
+	{"ISO-8859-11",	CharacterSet::ISO8859_11},
+	{"ISO-8859-13",	CharacterSet::ISO8859_13},
+	{"ISO-8859-14",	CharacterSet::ISO8859_14},
+	{"ISO-8859-15",	CharacterSet::ISO8859_15},
+	{"ISO-8859-16",	CharacterSet::ISO8859_16},
+	{"SJIS",		CharacterSet::Shift_JIS},
+	{"Shift_JIS",	CharacterSet::Shift_JIS},
+	{"Cp1250",		CharacterSet::Cp1250},
+	{"windows-1250",CharacterSet::Cp1250},
+	{"Cp1251",		CharacterSet::Cp1251},
+	{"windows-1251",CharacterSet::Cp1251},
+	{"Cp1252",		CharacterSet::Cp1252},
+	{"windows-1252",CharacterSet::Cp1252},
+	{"Cp1256",		CharacterSet::Cp1256},
+	{"windows-1256",CharacterSet::Cp1256},
+	{"UTF-16BE",	CharacterSet::UTF16BE},
+	{"UTF-16LE",	CharacterSet::UTF16LE},
+	{"UTF-32BE",	CharacterSet::UTF32BE},
+	{"UTF-32LE",	CharacterSet::UTF32LE},
+	{"UnicodeBigUnmarked", CharacterSet::UTF16BE},
+	{"UnicodeBig",	CharacterSet::UTF16BE},
+	{"UTF-8",		CharacterSet::UTF8},
+	{"ASCII",		CharacterSet::ASCII},
+	{"US-ASCII",	CharacterSet::ASCII},
+	{"Big5",		CharacterSet::Big5},
+	{"GB2312",		CharacterSet::GB2312},
+	{"GB18030",		CharacterSet::GB18030},
+	{"EUC-CN",		CharacterSet::GB18030},
+	{"GBK",			CharacterSet::GB18030},
+	{"EUC-KR",		CharacterSet::EUC_KR},
+	{"BINARY",		CharacterSet::BINARY},
+};
+
+CharacterSet CharacterSetFromString(std::string_view name)
+{
+	auto i = FindIf(NAME_TO_CHARSET, [name](auto& v) { return IsEqualIgnoreCaseAnd(v.name, name, "_- "); });
+	return i == std::end(NAME_TO_CHARSET) ? CharacterSet::Unknown : i->cs;
+}
+
+std::string ToString(CharacterSet cs)
+{
+	auto i = FindIf(NAME_TO_CHARSET, [cs](auto& v) { return v.cs == cs; });
+	return i == std::end(NAME_TO_CHARSET) ? "" : std::string(i->name);
+}
+
+} // namespace ZXing

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

@@ -0,0 +1,58 @@
+/*
+* Copyright 2016 Nu-book Inc.
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <string_view>
+
+namespace ZXing {
+
+enum class CharacterSet : unsigned char
+{
+	Unknown,
+	ASCII,
+	ISO8859_1,
+	ISO8859_2,
+	ISO8859_3,
+	ISO8859_4,
+	ISO8859_5,
+	ISO8859_6,
+	ISO8859_7,
+	ISO8859_8,
+	ISO8859_9,
+	ISO8859_10,
+	ISO8859_11,
+	ISO8859_13,
+	ISO8859_14,
+	ISO8859_15,
+	ISO8859_16,
+	Cp437,
+	Cp1250,
+	Cp1251,
+	Cp1252,
+	Cp1256,
+
+	Shift_JIS,
+	Big5,
+	GB2312,
+	GB18030,
+	EUC_JP,
+	EUC_KR,
+	UTF16BE,
+	UTF8,
+	UTF16LE,
+	UTF32BE,
+	UTF32LE,
+
+	BINARY,
+
+	CharsetCount
+};
+
+CharacterSet CharacterSetFromString(std::string_view name);
+std::string ToString(CharacterSet cs);
+
+} // ZXing