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

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

@@ -0,0 +1,185 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+
+namespace ZXing {
+
+/**
+ * @brief A simple 2D point class template.
+ *
+ * PointT is a simple 2D point class template with direct access to its x and y coordinate members.
+ */
+template <typename T>
+struct PointT
+{
+	using value_t = T;
+	T x = 0, y = 0;
+
+	constexpr PointT() = default;
+	constexpr PointT(T xx, T yy) : x(xx), y(yy) {}
+
+	template <typename U>
+	constexpr explicit PointT(const PointT<U>& p) : x(static_cast<T>(p.x)), y(static_cast<T>(p.y))
+	{}
+
+	template <typename U>
+	PointT& operator+=(const PointT<U>& b)
+	{
+		x += b.x;
+		y += b.y;
+		return *this;
+	}
+};
+
+using PointI = PointT<int>;
+using PointF = PointT<double>;
+
+/// @cond INTERNAL
+
+template <typename T>
+bool operator==(const PointT<T>& a, const PointT<T>& b)
+{
+	return a.x == b.x && a.y == b.y;
+}
+
+template <typename T>
+bool operator!=(const PointT<T>& a, const PointT<T>& b)
+{
+	return !(a == b);
+}
+
+template <typename T>
+auto operator-(const PointT<T>& a) -> PointT<T>
+{
+	return {-a.x, -a.y};
+}
+
+template <typename T, typename U>
+auto operator+(const PointT<T>& a, const PointT<U>& b) -> PointT<decltype(a.x + b.x)>
+{
+	return {a.x + b.x, a.y + b.y};
+}
+
+template <typename T, typename U>
+auto operator-(const PointT<T>& a, const PointT<U>& b) -> PointT<decltype(a.x - b.x)>
+{
+	return {a.x - b.x, a.y - b.y};
+}
+
+template <typename T, typename U>
+auto operator*(const PointT<T>& a, const PointT<U>& b) -> PointT<decltype(a.x * b.x)>
+{
+	return {a.x * b.x, a.y * b.y};
+}
+
+template <typename T, typename U>
+PointT<T> operator*(U s, const PointT<T>& a)
+{
+	return {s * a.x, s * a.y};
+}
+
+template <typename T, typename U>
+PointT<T> operator/(const PointT<T>& a, U d)
+{
+	return {a.x / d, a.y / d};
+}
+
+template <typename T, typename U>
+auto dot(const PointT<T>& a, const PointT<U>& b) -> decltype (a.x * b.x)
+{
+	return a.x * b.x + a.y * b.y;
+}
+
+template <typename T>
+auto cross(PointT<T> a, PointT<T> b) -> decltype(a.x * b.x)
+{
+	return a.x * b.y - b.x * a.y;
+}
+
+/// L1 norm
+template <typename T>
+T sumAbsComponent(PointT<T> p)
+{
+	return std::abs(p.x) + std::abs(p.y);
+}
+
+/// L2 norm
+template <typename T>
+auto length(PointT<T> p) -> decltype(std::sqrt(dot(p, p)))
+{
+	return std::sqrt(dot(p, p));
+}
+
+/// L-inf norm
+template <typename T>
+T maxAbsComponent(PointT<T> p)
+{
+	return std::max(std::abs(p.x), std::abs(p.y));
+}
+
+template <typename T>
+auto distance(PointT<T> a, PointT<T> b) -> decltype(length(a - b))
+{
+	return length(a - b);
+}
+
+template <typename T>
+PointF normalized(PointT<T> d)
+{
+	return PointF(d) / length(PointF(d));
+}
+
+template <typename T>
+PointT<T> bresenhamDirection(PointT<T> d)
+{
+	return d / maxAbsComponent(d);
+}
+
+template <typename T>
+PointT<T> mainDirection(PointT<T> d)
+{
+	return std::abs(d.x) > std::abs(d.y) ? PointT<T>(d.x, 0) : PointT<T>(0, d.y);
+}
+
+template <typename T>
+PointT<T> right(PointT<T> d)
+{
+	return {-d.y, d.x};
+}
+
+template <typename T>
+PointT<T> left(PointT<T> d)
+{
+	return {d.y, -d.x};
+}
+
+/// Calculate a floating point pixel coordinate representing the 'center' of the pixel.
+/// This is sort of the inverse operation of the PointI(PointF) conversion constructor.
+/// See also the documentation of the GridSampler API.
+inline PointF centered(PointI p)
+{
+	return p + PointF(0.5f, 0.5f);
+}
+
+inline PointF centered(PointF p)
+{
+	return {std::floor(p.x) + 0.5f, std::floor(p.y) + 0.5f};
+}
+
+/// @endcond
+
+template <typename T>
+std::string ToString(const PointT<T>& p, bool swap = false, char delim = 'x')
+{
+	return std::to_string(swap ? p.y : p.x) + delim + std::to_string(swap ? p.x : p.y);
+}
+
+} // ZXing
+

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

@@ -0,0 +1,215 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Point.h"
+
+#ifdef ZXING_INTERNAL
+#include "ZXAlgorithms.h"
+#endif
+
+#include <array>
+#include <cmath>
+#include <string>
+
+namespace ZXing {
+
+/**
+ * @brief A simple class representing a quadrilateral defined by its four corner points.
+ *
+ * It represents a quadrilateral defined by its four corner points:
+ * top-left, top-right, bottom-right, and bottom-left. Those points are relative to the detected symbol
+ * i.e. topLeft() will return the coordinates of the top-left corner of the symbol. If e.g. the symbol
+ * is rotated 180 degrees, the top-left corner will be the one that is at the bottom-right position in the image.
+ */
+template <typename T>
+class Quadrilateral : public std::array<T, 4>
+{
+	using Base = std::array<T, 4>;
+	using Base::at;
+public:
+	using Point = T;
+
+	Quadrilateral() = default;
+	Quadrilateral(T tl, T tr, T br, T bl) : Base{tl, tr, br, bl} {}
+	template <typename U>
+	Quadrilateral(PointT<U> tl, PointT<U> tr, PointT<U> br, PointT<U> bl)
+		: Quadrilateral(Point(tl), Point(tr), Point(br), Point(bl))
+	{}
+
+	constexpr Point topLeft() const noexcept { return at(0); }
+	constexpr Point topRight() const noexcept { return at(1); }
+	constexpr Point bottomRight() const noexcept { return at(2); }
+	constexpr Point bottomLeft() const noexcept { return at(3); }
+
+	/// Return the orientation of the quadrilateral in radians, where 0 means the horizontal center line
+	/// is parallel to the x-axis and positive values mean a clockwise rotation.
+	double orientation() const
+	{
+		auto centerLine = (topRight() + bottomRight()) - (topLeft() + bottomLeft());
+		if (centerLine == Point{})
+			return 0.;
+		auto centerLineF = normalized(centerLine);
+		return std::atan2(centerLineF.y, centerLineF.x);
+	}
+};
+
+using QuadrilateralF = Quadrilateral<PointF>;
+using QuadrilateralI = Quadrilateral<PointI>;
+
+template <typename T>
+std::string ToString(const Quadrilateral<PointT<T>>& points)
+{
+	std::string res;
+	for (const auto& p : points)
+		res += std::to_string(p.x) + "x" + std::to_string(p.y) + (&p == &points.back() ? "" : " ");
+	return res;
+}
+
+#ifdef ZXING_INTERNAL
+
+template <typename PointT = PointF>
+Quadrilateral<PointT> Rectangle(int width, int height, typename PointT::value_t margin = 0)
+{
+	return {
+		PointT{margin, margin}, {width - margin, margin}, {width - margin, height - margin}, {margin, height - margin}};
+}
+
+template <typename PointT = PointF>
+Quadrilateral<PointT> Rectangle(int x0, int x1, int y0, int y1, typename PointT::value_t o)
+{
+	return {PointT{x0 + o, y0 + o}, {x1 + o, y0 + o}, {x1 + o, y1 + o}, {x0 + o, y1 + o}};
+}
+
+template <typename PointT = PointF>
+Quadrilateral<PointT> Rectangle(int left, int top, int width, int height)
+{
+	int right  = left + width - 1;
+	int bottom = top + height - 1;
+
+	return {PointT{left, top}, {right, top}, {right, bottom}, {left, bottom}};
+}
+
+template <typename PointT = PointF>
+Quadrilateral<PointT> CenteredSquare(int size)
+{
+	return Scale(Quadrilateral(PointT{-1, -1}, {1, -1}, {1, 1}, {-1, 1}), size / 2);
+}
+
+template <typename PointT = PointI>
+Quadrilateral<PointT> Line(int y, int xStart, int xStop)
+{
+	return {PointT{xStart, y}, {xStop, y}, {xStop, y}, {xStart, y}};
+}
+
+template <typename PointT>
+bool IsConvex(const Quadrilateral<PointT>& poly)
+{
+	const int N = Size(poly);
+	bool sign = false;
+
+	typename PointT::value_t m = INFINITY, M = 0;
+
+	for(int i = 0; i < N; i++)
+	{
+		auto d1 = poly[(i + 2) % N] - poly[(i + 1) % N];
+		auto d2 = poly[i] - poly[(i + 1) % N];
+		auto cp = cross(d1, d2);
+
+		// TODO: see if the isInside check for all boundary points in GridSampler is still required after fixing the wrong fabs()
+		// application in the following line
+		UpdateMinMax(m, M, std::fabs(cp));
+
+		if (i == 0)
+			sign = cp > 0;
+		else if (sign != (cp > 0))
+			return false;
+	}
+
+	// It turns out being convex is not enough to prevent a "numerical instability"
+	// that can cause the corners being projected inside the image boundaries but
+	// some points near the corners being projected outside. This has been observed
+	// where one corner is almost in line with two others. The M/m ratio is below 2
+	// for the complete existing sample set. For very "skewed" QRCodes a value of
+	// around 3 is realistic. A value of 14 has been observed to trigger the
+	// instability.
+	return M / m < 4.0;
+}
+
+template <typename PointT>
+Quadrilateral<PointT> Scale(const Quadrilateral<PointT>& q, int factor)
+{
+	return {factor * q[0], factor * q[1], factor * q[2], factor * q[3]};
+}
+
+template <typename PointT>
+Quadrilateral<PointT> Move(const Quadrilateral<PointT>& q, PointT offset)
+{
+	return {q[0] + offset, q[1] + offset, q[2] + offset, q[3] + offset};
+}
+
+template <typename PointT>
+PointT Center(const Quadrilateral<PointT>& q)
+{
+	return Reduce(q) / Size(q);
+}
+
+template <typename PointT>
+Quadrilateral<PointT> RotatedCorners(const Quadrilateral<PointT>& q, int n = 1, bool mirror = false)
+{
+	Quadrilateral<PointT> res;
+	std::rotate_copy(q.begin(), q.begin() + ((n + 4) % 4), q.end(), res.begin());
+	if (mirror)
+		std::swap(res[1], res[3]);
+	return res;
+}
+
+template <typename PointT>
+bool IsInside(const PointT& p, const Quadrilateral<PointT>& q)
+{
+	// Test if p is on the same side (right or left) of all polygon segments
+	int pos = 0, neg = 0;
+	for (int i = 0; i < Size(q); ++i)
+		(cross(p - q[i], q[(i + 1) % Size(q)] - q[i]) < 0 ? neg : pos)++;
+	return pos == 0 || neg == 0;
+}
+
+template <typename PointT>
+Quadrilateral<PointT> BoundingBox(const Quadrilateral<PointT>& q)
+{
+	auto [minX, maxX] = std::minmax({q[0].x, q[1].x, q[2].x, q[3].x});
+	auto [minY, maxY] = std::minmax({q[0].y, q[1].y, q[2].y, q[3].y});
+	return {PointT{minX, minY}, {maxX, minY}, {maxX, maxY}, {minX, maxY}};
+}
+
+template <typename PointT>
+bool HaveIntersectingBoundingBoxes(const Quadrilateral<PointT>& a, const Quadrilateral<PointT>& b)
+{
+	auto bba = BoundingBox(a), bbb = BoundingBox(b);
+
+	bool x = bbb.topRight().x < bba.topLeft().x || bbb.topLeft().x > bba.topRight().x;
+	bool y = bbb.bottomLeft().y < bba.topLeft().y || bbb.topLeft().y > bba.bottomLeft().y;
+	return !(x || y);
+}
+
+template <typename PointT>
+Quadrilateral<PointT> Blend(const Quadrilateral<PointT>& a, const Quadrilateral<PointT>& b)
+{
+	auto dist2First = [r = a[0]](auto s, auto t) { return distance(s, r) < distance(t, r); };
+	// rotate points such that the the two topLeft points are closest to each other
+	auto offset = std::min_element(b.begin(), b.end(), dist2First) - b.begin();
+
+	Quadrilateral<PointT> res;
+	for (int i = 0; i < 4; ++i)
+		res[i] = (a[i] + b[(i + offset) % 4]) / 2;
+
+	return res;
+}
+
+#endif
+
+} // ZXing
+

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

@@ -0,0 +1,112 @@
+/*
+* Copyright 2022 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ZXAlgorithms.h"
+
+#include <cstdint>
+#include <iterator>
+
+namespace ZXing {
+
+template <typename Iterator>
+struct StrideIter
+{
+	Iterator pos;
+	int stride;
+
+	using iterator_category = std::random_access_iterator_tag;
+	using difference_type   = typename std::iterator_traits<Iterator>::difference_type;
+	using value_type        = typename std::iterator_traits<Iterator>::value_type;
+	using pointer           = Iterator;
+	using reference         = typename std::iterator_traits<Iterator>::reference;
+
+	auto operator*() const { return *pos; }
+	auto operator[](int i) const { return *(pos + i * stride); }
+	StrideIter<Iterator>& operator++() { return pos += stride, *this; }
+	StrideIter<Iterator> operator++(int) { auto temp = *this; ++*this; return temp; }
+	bool operator==(const StrideIter<Iterator>& rhs) const { return pos == rhs.pos; }
+	StrideIter<Iterator> operator+(int i) const { return {pos + i * stride, stride}; }
+	StrideIter<Iterator> operator-(int i) const { return {pos - i * stride, stride}; }
+	int operator-(const StrideIter<Iterator>& rhs) const { return narrow_cast<int>((pos - rhs.pos) / stride); }
+};
+
+template <typename Iterator>
+StrideIter(const Iterator&, int) -> StrideIter<Iterator>;
+
+
+template <typename Iterator>
+struct Range
+{
+	Iterator _begin, _end;
+
+	Range(Iterator b, Iterator e) : _begin(b), _end(e) {}
+
+	template <typename C>
+	Range(const C& c) : _begin(std::begin(c)), _end(std::end(c)) {}
+
+	Iterator begin() const noexcept { return _begin; }
+	Iterator end() const noexcept { return _end; }
+	explicit operator bool() const { return begin() < end(); }
+	int size() const { return narrow_cast<int>(end() - begin()); }
+};
+
+template <typename C>
+Range(const C&) -> Range<typename C::const_iterator>;
+
+/**
+ * ArrayView is a lightweight, non-owning, non-mutable view over a contiguous sequence of elements.
+ * Similar to std::span<const T>. See also Range template for general iterator use case.
+ */
+template <typename T>
+class ArrayView
+{
+	const T* _data = nullptr;
+	std::size_t _size = 0;
+
+public:
+	using value_type = T;
+	using pointer = const value_type*;
+	using const_pointer = const value_type*;
+	using reference = const value_type&;
+	using const_reference = const value_type&;
+	using size_type = std::size_t;
+
+	constexpr ArrayView() noexcept = default;
+
+	constexpr ArrayView(pointer data, size_type size) noexcept : _data(data), _size(size) {}
+
+	template <typename P, typename U = T,
+			  typename = std::enable_if_t<
+				  sizeof(U) == 1 && std::is_same_v<void, std::remove_cv_t<std::remove_reference_t<std::remove_pointer_t<P>>>>>>
+	constexpr ArrayView(P data, size_type size) noexcept : _data(reinterpret_cast<pointer>(data)), _size(size)
+	{}
+
+	template <typename Container,
+			  typename = std::enable_if_t<std::is_convertible_v<decltype(std::data(std::declval<Container&>())), const_pointer>>>
+	constexpr ArrayView(const Container& c) noexcept : _data(std::data(c)), _size(std::size(c))
+	{}
+
+	constexpr pointer data() const noexcept { return _data; }
+	constexpr size_type size() const noexcept { return _size; }
+	constexpr bool empty() const noexcept { return _size == 0; }
+
+	constexpr const_reference operator[](size_type index) const noexcept { return _data[index]; }
+
+	constexpr pointer begin() const noexcept { return _data; }
+	constexpr pointer end() const noexcept { return _data + _size; }
+
+	constexpr ArrayView<T> subview(size_type pos, size_type len = size_type(-1)) const noexcept
+	{
+		if (pos > _size)
+			return {};
+		return {_data + pos, std::min(len, _size - pos)};
+	}
+};
+
+using ByteView = ArrayView<uint8_t>;
+
+} // namespace ZXing