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

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

@@ -0,0 +1,66 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2021 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ImageView.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace ZXing {
+
+class BitMatrix;
+
+using PatternRow = std::vector<uint16_t>;
+
+/**
+* This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
+* accept a BinaryBitmap and attempt to decode it.
+*/
+class BinaryBitmap
+{
+	struct Cache;
+	std::unique_ptr<Cache> _cache;
+	bool _inverted = false;
+	bool _closed = false;
+
+protected:
+	const ImageView _buffer;
+
+	/**
+	* Converts a 2D array of luminance data to 1 bit (true means black).
+	*
+	* @return The 2D array of bits for the image, nullptr on error.
+	*/
+	virtual std::shared_ptr<const BitMatrix> getBlackMatrix() const = 0;
+
+	BitMatrix binarize(uint8_t threshold) const;
+
+public:
+	BinaryBitmap(const ImageView& buffer);
+	virtual ~BinaryBitmap();
+
+	int width() const { return _buffer.width(); }
+	int height() const { return _buffer.height(); }
+
+	/**
+	* Converts one row of luminance data to a vector of ints denoting the widths of the bars and spaces.
+	*/
+	virtual bool getPatternRow(int row, int rotation, PatternRow& res) const = 0;
+
+	const BitMatrix* getBitMatrix(bool transposed = false) const;
+
+	void invert();
+	bool inverted() const { return _inverted; }
+
+	void close();
+	bool closed() const { return _closed; }
+};
+
+} // ZXing

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

@@ -0,0 +1,38 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BitArray.h"
+
+#include "ByteArray.h"
+
+#include <cstddef>
+#include <stdexcept>
+
+namespace ZXing {
+
+void
+BitArray::bitwiseXOR(const BitArray& other)
+{
+	if (size() != other.size()) {
+		throw std::invalid_argument("BitArray::xor(): Sizes don't match");
+	}
+	for (size_t i = 0; i < _bits.size(); i++) {
+		// The last int could be incomplete (i.e. not have 32 bits in
+		// it) but there is no problem since 0 XOR 0 == 0.
+		_bits[i] ^= other._bits[i];
+	}
+}
+
+ByteArray BitArray::toBytes(int bitOffset, int numBytes) const
+{
+	ByteArray res(numBytes == -1 ? (size() - bitOffset + 7) / 8 : numBytes);
+	for (int i = 0; i < Size(res); i++)
+		for (int j = 0; j < 8; j++)
+			AppendBit(res[i], (numBytes != -1 || bitOffset < size()) ? get(bitOffset++) : false);
+	return res;
+}
+
+} // ZXing

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

@@ -0,0 +1,181 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2017 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Range.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+namespace ZXing {
+
+class ByteArray;
+
+/**
+* A simple, fast array of bits.
+*/
+class BitArray
+{
+	std::vector<uint8_t> _bits;
+
+	friend class BitMatrix;
+
+	// Nothing wrong to support it, just to make it explicit, instead of by mistake.
+	// Use copy() below.
+	BitArray(const BitArray &) = default;
+
+public:
+
+	using Iterator = std::vector<uint8_t>::const_iterator;
+
+	BitArray() = default;
+
+	explicit BitArray(int size) : _bits(size, 0) {}
+
+	BitArray(BitArray&& other) noexcept = default;
+	BitArray& operator=(BitArray&& other) noexcept = default;
+	BitArray& operator=(const BitArray &) = delete;
+
+	BitArray copy() const { return *this; }
+
+	int size() const noexcept { return Size(_bits); }
+
+	int sizeInBytes() const noexcept { return (size() + 7) / 8; }
+
+	bool get(int i) const { return _bits.at(i) != 0; }
+	void set(int i, bool val) { _bits.at(i) = val; }
+
+	// If you know exactly how may bits you are going to iterate
+	// and that you access bit in sequence, iterator is faster than get().
+	// However, be extremely careful since there is no check whatsoever.
+	// (Performance is the reason for the iterator to exist in the first place.)
+	Iterator iterAt(int i) const noexcept { return {_bits.cbegin() + i}; }
+	Iterator begin() const noexcept { return _bits.cbegin(); }
+	Iterator end() const noexcept { return _bits.cend(); }
+
+	/**
+	* Appends the least-significant bits, from value, in order from most-significant to
+	* least-significant. For example, appending 6 bits from 0x000001E will append the bits
+	* 0, 1, 1, 1, 1, 0 in that order.
+	*
+	* @param value {@code int} containing bits to append
+	* @param numBits bits from value to append
+	*/
+	void appendBits(int value, int numBits)
+	{
+		assert(numBits >= 1 && numBits <= 32);
+
+		for (; numBits; --numBits)
+			_bits.push_back((value >> (numBits-1)) & 1);
+	}
+
+	void appendBits(uint32_t value, int numBits)
+	{
+		appendBits(static_cast<int>(value), numBits);
+	}
+
+	void appendBit(bool bit) { _bits.push_back(bit); }
+
+	void appendBitArray(const BitArray& other) { _bits.insert(_bits.end(), other.begin(), other.end()); }
+
+	/**
+	* Reverses all bits in the array.
+	*/
+	void reverse() { std::reverse(_bits.begin(), _bits.end()); }
+
+	void bitwiseXOR(const BitArray& other);
+
+	/**
+	* @param bitOffset first bit to extract
+	* @param numBytes how many bytes to extract (-1 == until the end, padded with '0')
+	* @return Bytes are written most-significant bit first.
+	*/
+	ByteArray toBytes(int bitOffset = 0, int numBytes = -1) const;
+
+	using Range = ZXing::Range<Iterator>;
+	Range range() const { return {begin(), end()}; }
+
+	friend bool operator==(const BitArray& a, const BitArray& b) { return a._bits == b._bits; }
+};
+
+template <typename T = int, typename = std::enable_if_t<std::is_integral_v<T>>>
+T ToInt(const BitArray& bits, int pos = 0, int count = 8 * sizeof(T))
+{
+	assert(0 <= count && count <= 8 * (int)sizeof(T));
+	assert(0 <= pos && pos + count <= bits.size());
+
+	count = std::min(count, bits.size());
+	int res = 0;
+	auto it = bits.iterAt(pos);
+	for (int i = 0; i < count; ++i, ++it)
+		AppendBit(res, *it);
+
+	return res;
+}
+
+template <typename T = int, typename = std::enable_if_t<std::is_integral_v<T>>>
+std::vector<T> ToInts(const BitArray& bits, int wordSize, int totalWords, int offset = 0)
+{
+	assert(totalWords >= bits.size() / wordSize);
+	assert(wordSize <= 8 * (int)sizeof(T));
+
+	std::vector<T> res(totalWords, 0);
+	for (int i = offset; i < bits.size(); i += wordSize)
+		res[(i - offset) / wordSize] = ToInt(bits, i, wordSize);
+
+	return res;
+}
+
+class BitArrayView
+{
+	const BitArray& bits;
+	BitArray::Iterator cur;
+
+public:
+	BitArrayView(const BitArray& bits) : bits(bits), cur(bits.begin()) {}
+
+	BitArrayView& skipBits(int n)
+	{
+		if (cur + n > bits.end())
+			throw std::out_of_range("BitArrayView::skipBits() out of range.");
+		cur += n;
+		return *this;
+	}
+
+	int peekBits(int n) const
+	{
+		assert(n <= 32);
+		if (cur + n > bits.end())
+			throw std::out_of_range("BitArrayView::peekBits() out of range.");
+		int res = 0;
+		for (auto i = cur; n > 0; --n, i++)
+			AppendBit(res, *i);
+		return res;
+	}
+
+	int readBits(int n)
+	{
+		int res = peekBits(n);
+		cur += n;
+		return res;
+	}
+
+	int size() const
+	{
+		return narrow_cast<int>(bits.end() - cur);
+	}
+
+	explicit operator bool() const { return size(); }
+};
+
+} // ZXing

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

@@ -0,0 +1,175 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "BitMatrix.h"
+
+#include "Pattern.h"
+
+#include <algorithm>
+#include <stdexcept>
+#include <utility>
+
+namespace ZXing {
+
+void
+BitMatrix::setRegion(int left, int top, int width, int height)
+{
+	if (top < 0 || left < 0) {
+		throw std::invalid_argument("BitMatrix::setRegion(): Left and top must be nonnegative");
+	}
+	if (height < 1 || width < 1) {
+		throw std::invalid_argument("BitMatrix::setRegion(): Height and width must be at least 1");
+	}
+	int right = left + width;
+	int bottom = top + height;
+	if (bottom > _height || right > _width) {
+		throw std::invalid_argument("BitMatrix::setRegion(): The region must fit inside the matrix");
+	}
+	for (int y = top; y < bottom; y++) {
+		auto offset = y * _width;
+		for (int x = left; x < right; x++) {
+			_bits[offset + x] = SET_V;
+		}
+	}
+}
+
+void
+BitMatrix::rotate90()
+{
+	BitMatrix result(height(), width());
+	for (int x = 0; x < width(); ++x) {
+		for (int y = 0; y < height(); ++y) {
+			if (get(x, y)) {
+				result.set(y, width() - x - 1);
+			}
+		}
+	}
+	*this = std::move(result);
+}
+
+void
+BitMatrix::rotate180()
+{
+	std::reverse(_bits.begin(), _bits.end());
+}
+
+void
+BitMatrix::mirror()
+{
+	for (int x = 0; x < _width; x++) {
+		for (int y = x + 1; y < _height; y++) {
+			if (get(x, y) != get(y, x)) {
+				flip(y, x);
+				flip(x, y);
+			}
+		}
+	}
+}
+
+bool
+BitMatrix::findBoundingBox(int &left, int& top, int& width, int& height, int minSize) const
+{
+	int right, bottom;
+	if (!getTopLeftOnBit(left, top) || !getBottomRightOnBit(right, bottom) || bottom - top + 1 < minSize)
+		return false;
+
+	for (int y = top; y <= bottom; y++ ) {
+		for (int x = 0; x < left; ++x)
+			if (get(x, y)) {
+				left = x;
+				break;
+			}
+		for (int x = _width-1; x > right; x--)
+			if (get(x, y)) {
+				right = x;
+				break;
+			}
+	}
+
+	width = right - left + 1;
+	height = bottom - top + 1;
+	return width >= minSize && height >= minSize;
+}
+
+static auto isSet = [](auto v) { return bool(v); };
+
+bool
+BitMatrix::getTopLeftOnBit(int& left, int& top) const
+{
+	int bitsOffset = (int)std::distance(_bits.begin(), std::find_if(_bits.begin(), _bits.end(), isSet));
+	if (bitsOffset == Size(_bits)) {
+		return false;
+	}
+	top = bitsOffset / _width;
+	left = (bitsOffset % _width);
+	return true;
+}
+
+bool
+BitMatrix::getBottomRightOnBit(int& right, int& bottom) const
+{
+	int bitsOffset = Size(_bits) - 1 - (int)std::distance(_bits.rbegin(), std::find_if(_bits.rbegin(), _bits.rend(), isSet));
+	if (bitsOffset < 0) {
+		return false;
+	}
+
+	bottom = bitsOffset / _width;
+	right = (bitsOffset % _width);
+	return true;
+}
+
+void GetPatternRow(const BitMatrix& matrix, int r, std::vector<uint16_t>& pr, bool transpose)
+{
+	if (transpose)
+		GetPatternRow(matrix.col(r), pr);
+	else
+		GetPatternRow(matrix.row(r), pr);
+}
+
+BitMatrix Inflate(BitMatrix&& input, int width, int height, int quietZone)
+{
+	const int codeWidth = input.width();
+	const int codeHeight = input.height();
+	const int outputWidth = std::max(width, codeWidth + 2 * quietZone);
+	const int outputHeight = std::max(height, codeHeight + 2 * quietZone);
+
+	if (input.width() == outputWidth && input.height() == outputHeight)
+		return std::move(input);
+
+	const int scale = std::min((outputWidth - 2*quietZone) / codeWidth, (outputHeight - 2*quietZone) / codeHeight);
+	// Padding includes both the quiet zone and the extra white pixels to
+	// accommodate the requested dimensions.
+	const int leftPadding = (outputWidth - (codeWidth * scale)) / 2;
+	const int topPadding = (outputHeight - (codeHeight * scale)) / 2;
+
+	BitMatrix result(outputWidth, outputHeight);
+
+	for (int inputY = 0, outputY = topPadding; inputY < input.height(); ++inputY, outputY += scale) {
+		for (int inputX = 0, outputX = leftPadding; inputX < input.width(); ++inputX, outputX += scale) {
+			if (input.get(inputX, inputY))
+				result.setRegion(outputX, outputY, scale, scale);
+		}
+	}
+
+	return result;
+}
+
+BitMatrix Deflate(const BitMatrix& input, int width, int height, float top, float left, float subSampling)
+{
+	BitMatrix result(width, height);
+
+	for (int y = 0; y < result.height(); y++) {
+		auto yOffset = top + y * subSampling;
+		for (int x = 0; x < result.width(); x++) {
+			if (input.get(PointF(left + x * subSampling, yOffset)))
+				result.set(x, y);
+		}
+	}
+
+	return result;
+}
+
+} // ZXing

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

@@ -0,0 +1,199 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2022 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Matrix.h"
+#include "Point.h"
+
+#ifdef ZXING_INTERNAL
+#include "Range.h"
+#endif
+
+#include <cstdint>
+#include <stdexcept>
+#include <vector>
+
+namespace ZXing {
+
+class BitArray;
+
+/**
+ * @brief A simple, fast 2D array of bits.
+ */
+class BitMatrix
+{
+	int _width = 0;
+	int _height = 0;
+	using data_t = uint8_t;
+
+	std::vector<data_t> _bits;
+	// There is nothing wrong to support this but disable to make it explicit since we may copy something very big here.
+	// Use copy() below.
+	BitMatrix(const BitMatrix&) = default;
+
+	const data_t& get(int i) const
+	{
+#if 1
+		return _bits.at(i);
+#else
+		return _bits[i];
+#endif
+	}
+
+	data_t& get(int i) { return const_cast<data_t&>(static_cast<const BitMatrix*>(this)->get(i)); }
+
+	bool getTopLeftOnBit(int &left, int& top) const;
+	bool getBottomRightOnBit(int &right, int& bottom) const;
+
+public:
+	static constexpr data_t SET_V = 0xff; // allows playing with SIMD binarization
+	static constexpr data_t UNSET_V = 0;
+	static_assert(bool(SET_V) && !bool(UNSET_V), "SET_V needs to evaluate to true, UNSET_V to false, see iterator usage");
+
+	BitMatrix() = default;
+
+#if defined(__llvm__) || (defined(__GNUC__) && (__GNUC__ > 7))
+	__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+	BitMatrix(int width, int height) : _width(width), _height(height), _bits(width * height, UNSET_V)
+	{
+		if (width != 0 && int(_bits.size()) / width != height)
+			throw std::invalid_argument("Invalid size: width * height is too big");
+	}
+
+	explicit BitMatrix(int dimension) : BitMatrix(dimension, dimension) {} // Construct a square matrix.
+
+	BitMatrix(BitMatrix&& other) noexcept = default;
+	BitMatrix& operator=(BitMatrix&& other) noexcept = default;
+	BitMatrix& operator=(const BitMatrix&) = delete;
+
+	BitMatrix copy() const { return *this; }
+
+#ifdef ZXING_INTERNAL
+	Range<data_t*> row(int y) { return {_bits.data() + y * _width, _bits.data() + (y + 1) * _width}; }
+	Range<const data_t*> row(int y) const { return {_bits.data() + y * _width, _bits.data() + (y + 1) * _width}; }
+
+	Range<StrideIter<const data_t*>> col(int x) const
+	{
+		return {{_bits.data() + x + (_height - 1) * _width, -_width}, {_bits.data() + x - _width, -_width}};
+	}
+#endif
+
+	bool get(int x, int y) const { return get(y * _width + x); }
+	void set(int x, int y, bool val = true) { get(y * _width + x) = val * SET_V; }
+
+	/**
+	* <p>Flips the given bit.</p>
+	*
+	* @param x The horizontal component (i.e. which column)
+	* @param y The vertical component (i.e. which row)
+	*/
+	void flip(int x, int y)
+	{
+		auto& v = get(y * _width + x);
+		v = !v;
+	}
+
+	void flipAll()
+	{
+		for (auto& i : _bits)
+			i = !i * SET_V;
+	}
+
+	/**
+	* <p>Sets a square region of the bit matrix to true.</p>
+	*
+	* @param left The horizontal position to begin at (inclusive)
+	* @param top The vertical position to begin at (inclusive)
+	* @param width The width of the region
+	* @param height The height of the region
+	*/
+	void setRegion(int left, int top, int width, int height);
+
+	void rotate90();
+
+	void rotate180();
+
+	void mirror();
+
+	/**
+	* Find the rectangle that contains all non-white pixels. Useful for detection of 'pure' barcodes.
+	*
+	* @return True iff this rectangle is at least minWidth x minHeight pixels big
+	*/
+	bool findBoundingBox(int &left, int& top, int& width, int& height, int minSize = 1) const;
+
+	int width() const { return _width; }
+
+	int height() const { return _height; }
+
+	bool empty() const { return _bits.empty(); }
+
+	friend bool operator==(const BitMatrix& a, const BitMatrix& b)
+	{
+		return a._width == b._width && a._height == b._height && a._bits == b._bits;
+	}
+
+	template <typename T>
+	bool isIn(PointT<T> p, int b = 0) const noexcept
+	{
+		return b <= p.x && p.x < width() - b && b <= p.y && p.y < height() - b;
+	}
+
+	bool get(PointI p) const { return get(p.x, p.y); }
+	bool get(PointF p) const { return get(PointI(p)); }
+	void set(PointI p, bool v = true) { set(p.x, p.y, v); }
+	void set(PointF p, bool v = true) { set(PointI(p), v); }
+};
+
+void GetPatternRow(const BitMatrix& matrix, int r, std::vector<uint16_t>& pr, bool transpose);
+
+/**
+ * @brief Inflate scales a BitMatrix up and adds a quiet Zone plus padding
+ * @param input matrix to be expanded
+ * @param width new width in bits (pixel)
+ * @param height new height in bits (pixel)
+ * @param quietZone size of quiet zone to add in modules
+ * @return expanded BitMatrix, maybe move(input) if size did not change
+ */
+BitMatrix Inflate(BitMatrix&& input, int width, int height, int quietZone);
+
+/**
+ * @brief Deflate (crop + subsample) a bit matrix
+ * @param input matrix to be shrunk
+ * @param width new width
+ * @param height new height
+ * @param top cropping starts at top row
+ * @param left cropping starts at left col
+ * @param subSampling typically the module size
+ * @return deflated input
+ */
+BitMatrix Deflate(const BitMatrix& input, int width, int height, float top, float left, float subSampling);
+
+template<typename T>
+BitMatrix ToBitMatrix(const Matrix<T>& in, T trueValue = {true})
+{
+	BitMatrix out(in.width(), in.height());
+	for (int y = 0; y < in.height(); ++y)
+		for (int x = 0; x < in.width(); ++x)
+			if (in.get(x, y) == trueValue)
+				out.set(x, y);
+	return out;
+}
+
+template<typename T>
+Matrix<T> ToMatrix(const BitMatrix& in, T black = 0, T white = ~0)
+{
+	Matrix<T> res(in.width(), in.height());
+	for (int y = 0; y < in.height(); ++y)
+		for (int x = 0; x < in.width(); ++x)
+			res.set(x, y, in.get(x, y) ? black : white);
+	return res;
+}
+
+} // ZXing