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

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

@@ -0,0 +1,276 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "WhiteRectDetector.h"
+
+#include "BitMatrix.h"
+#include "BitMatrixCursor.h"
+#include "ResultPoint.h"
+
+namespace ZXing {
+
+static const int INIT_SIZE = 10;
+static const int CORR = 1;
+
+bool DetectWhiteRect(const BitMatrix& image, ResultPoint& p0, ResultPoint& p1, ResultPoint& p2, ResultPoint& p3)
+{
+	return DetectWhiteRect(image, INIT_SIZE, image.width() / 2, image.height() / 2, p0, p1, p2, p3);
+}
+
+/**
+* Determines whether a segment contains a black point
+*
+* @param a          min value of the scanned coordinate
+* @param b          max value of the scanned coordinate
+* @param fixed      value of fixed coordinate
+* @param horizontal set to true if scan must be horizontal, false if vertical
+* @return true if a black point has been found, else false.
+*/
+static bool ContainsBlackPoint(const BitMatrix& image, int a, int b, int fixed, bool horizontal) {
+
+	a = std::max(a, 0);
+	if (horizontal) {
+		if (fixed < 0 || fixed >= image.height())
+			return false;
+		b = std::min(b, image.width() - 1);
+		for (int x = a; x <= b; x++) {
+			if (image.get(x, fixed)) {
+				return true;
+			}
+		}
+	}
+	else {
+		if (fixed < 0 || fixed >= image.width())
+			return false;
+		b = std::min(b, image.height() - 1);
+		for (int y = a; y <= b; y++) {
+			if (image.get(fixed, y)) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+static bool GetBlackPointOnSegment(const BitMatrix& image, int aX, int aY, int bX, int bY, ResultPoint& result)
+{
+	PointF a(aX, aY), b(bX, bY);
+	BitMatrixCursorF cur(image, a, b - a);
+
+	auto dist = std::lround(distance(a, b) / length(cur.d));
+
+	for (int i = 0; i < dist; i++) {
+		if (cur.isBlack()) {
+			result = cur.p;
+			return true;
+		}
+		cur.step();
+	}
+	return false;
+}
+
+/**
+* recenters the points of a constant distance towards the center
+*
+* p0 to p3 describing the corners of the rectangular
+* region. The first and last points are opposed on the diagonal, as
+* are the second and third. The first point will be the topmost
+* point and the last, the bottommost. The second point will be
+* leftmost and the third, the rightmost
+*
+* @param y bottom most point
+* @param z left most point
+* @param x right most point
+* @param t top most point
+*/
+static void CenterEdges(const ResultPoint& y, const ResultPoint& z, const ResultPoint& x, const ResultPoint& t, int width, ResultPoint& p0, ResultPoint& p1, ResultPoint& p2, ResultPoint& p3)
+{
+	//
+	//       t            t
+	//  z                      x
+	//        x    OR    z
+	//   y                    y
+	//
+
+	float yi = y.x();
+	float yj = y.y();
+	float zi = z.x();
+	float zj = z.y();
+	float xi = x.x();
+	float xj = x.y();
+	float ti = t.x();
+	float tj = t.y();
+
+	if (yi < width / 2.0f) {
+		p0 = ResultPoint(ti - CORR, tj + CORR);
+		p1 = ResultPoint(zi + CORR, zj + CORR);
+		p2 = ResultPoint(xi - CORR, xj - CORR);
+		p3 = ResultPoint(yi + CORR, yj - CORR);
+	}
+	else {
+		p0 = ResultPoint(ti + CORR, tj + CORR);
+		p1 = ResultPoint(zi + CORR, zj - CORR);
+		p2 = ResultPoint(xi - CORR, xj + CORR);
+		p3 = ResultPoint(yi - CORR, yj - CORR);
+	}
+}
+
+bool DetectWhiteRect(const BitMatrix& image, int initSize, int x, int y, ResultPoint& p0, ResultPoint& p1,
+					 ResultPoint& p2, ResultPoint& p3)
+{
+	int height = image.height();
+	int width = image.width();
+	int halfsize = initSize / 2;
+	int left = x - halfsize;
+	int right = x + halfsize;
+	int up = y - halfsize;
+	int down = y + halfsize;
+	if (up < 0 || left < 0 || down >= height || right >= width) {
+		return false;
+	}
+
+	bool aBlackPointFoundOnBorder = true;
+	bool atLeastOneBlackPointFoundOnBorder = false;
+
+	bool atLeastOneBlackPointFoundOnRight = false;
+	bool atLeastOneBlackPointFoundOnBottom = false;
+	bool atLeastOneBlackPointFoundOnLeft = false;
+	bool atLeastOneBlackPointFoundOnTop = false;
+
+	while (aBlackPointFoundOnBorder) {
+
+		aBlackPointFoundOnBorder = false;
+
+		// .....
+		// .   |
+		// .....
+		bool rightBorderNotWhite = true;
+		while ((rightBorderNotWhite || !atLeastOneBlackPointFoundOnRight) && right < width) {
+			rightBorderNotWhite = ContainsBlackPoint(image, up, down, right, false);
+			if (rightBorderNotWhite) {
+				right++;
+				aBlackPointFoundOnBorder = true;
+				atLeastOneBlackPointFoundOnRight = true;
+			}
+			else if (!atLeastOneBlackPointFoundOnRight) {
+				right++;
+			}
+		}
+
+		// .....
+		// .   .
+		// .___.
+		bool bottomBorderNotWhite = true;
+		while ((bottomBorderNotWhite || !atLeastOneBlackPointFoundOnBottom) && down < height) {
+			bottomBorderNotWhite = ContainsBlackPoint(image, left, right, down, true);
+			if (bottomBorderNotWhite) {
+				down++;
+				aBlackPointFoundOnBorder = true;
+				atLeastOneBlackPointFoundOnBottom = true;
+			}
+			else if (!atLeastOneBlackPointFoundOnBottom) {
+				down++;
+			}
+		}
+
+		// .....
+		// |   .
+		// .....
+		bool leftBorderNotWhite = true;
+		while ((leftBorderNotWhite || !atLeastOneBlackPointFoundOnLeft) && left >= 0) {
+			leftBorderNotWhite = ContainsBlackPoint(image, up, down, left, false);
+			if (leftBorderNotWhite) {
+				left--;
+				aBlackPointFoundOnBorder = true;
+				atLeastOneBlackPointFoundOnLeft = true;
+			}
+			else if (!atLeastOneBlackPointFoundOnLeft) {
+				left--;
+			}
+		}
+
+		// .___.
+		// .   .
+		// .....
+		bool topBorderNotWhite = true;
+		while ((topBorderNotWhite || !atLeastOneBlackPointFoundOnTop) && up >= 0) {
+			topBorderNotWhite = ContainsBlackPoint(image, left, right, up, true);
+			if (topBorderNotWhite) {
+				up--;
+				aBlackPointFoundOnBorder = true;
+				atLeastOneBlackPointFoundOnTop = true;
+			}
+			else if (!atLeastOneBlackPointFoundOnTop) {
+				up--;
+			}
+		}
+
+		if (aBlackPointFoundOnBorder) {
+			atLeastOneBlackPointFoundOnBorder = true;
+		}
+
+	}
+
+	if (up < 0 || left < 0 || down >= height || right >= width)
+		return false;
+
+	if (atLeastOneBlackPointFoundOnBorder) {
+
+		int maxSize = right - left;
+
+		ResultPoint z;
+		bool found = false;
+		for (int i = 1; !found && i < maxSize; i++) {
+			found = GetBlackPointOnSegment(image, left, down - i, left + i, down, z);
+		}
+
+		if (!found) {
+			return false;
+		}
+
+		ResultPoint t;
+		found = false;
+		//go down right
+		for (int i = 1; !found && i < maxSize; i++) {
+			found = GetBlackPointOnSegment(image, left, up + i, left + i, up, t);
+		}
+
+		if (!found) {
+			return false;
+		}
+
+		ResultPoint x;
+		found = false;
+		//go down left
+		for (int i = 1; !found && i < maxSize; i++) {
+			found = GetBlackPointOnSegment(image, right, up + i, right - i, up, x);
+		}
+
+		if (!found) {
+			return false;
+		}
+
+		ResultPoint y;
+		found = false;
+		//go up left
+		for (int i = 1; !found && i < maxSize; i++) {
+			found = GetBlackPointOnSegment(image, right, down - i, right - i, down, y);
+		}
+
+		if (!found) {
+			return false;
+		}
+
+		CenterEdges(y, z, x, t, width, p0, p1, p2, p3);
+		return true;
+	}
+	else {
+		return false;
+	}
+}
+
+} // ZXing

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

@@ -0,0 +1,36 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ZXing {
+
+class BitMatrix;
+class ResultPoint;
+
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region.
+ * </p>
+ *
+ * @param image barcode image to find a rectangle in
+ * @param initSize initial size of search area around center
+ * @param x x position of search center
+ * @param y y position of search center
+ * @return {@link ResultPoint}[] describing the corners of the rectangular
+ *         region. The first and last points are opposed on the diagonal, as
+ *         are the second and third. The first point will be the topmost
+ *         point and the last, the bottommost. The second point will be
+ *         leftmost and the third, the rightmost
+ * @return true iff white rect was found
+ */
+bool DetectWhiteRect(const BitMatrix& image, int initSize, int x, int y, ResultPoint& p0, ResultPoint& p1,
+					 ResultPoint& p2, ResultPoint& p3);
+bool DetectWhiteRect(const BitMatrix& image, ResultPoint& p0, ResultPoint& p1, ResultPoint& p2, ResultPoint& p3);
+
+} // ZXing

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

@@ -0,0 +1,213 @@
+/*
+* Copyright 2024 Axel Waggershauser
+* Copyright 2025 gitlost
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "WriteBarcode.h"
+
+#include "BarcodeData.h"
+#include "BitMatrix.h"
+#include "CreateBarcode.h"
+#include "Version.h"
+
+#include <sstream>
+
+#ifdef ZXING_USE_ZINT
+#include <zint.h>
+#endif // ZXING_USE_ZINT
+
+namespace ZXing {
+
+struct WriterOptions::Data
+{
+	int scale = 1;
+	int rotate = 0;
+	bool invert = false;
+	bool addHRT = false;
+	bool addQuietZones = true;
+};
+
+#define ZX_PROPERTY(TYPE, NAME) \
+	TYPE WriterOptions::NAME() const noexcept { return d->NAME; } \
+	WriterOptions& WriterOptions::NAME(TYPE v)& { return d->NAME = std::move(v), *this; } \
+	WriterOptions&& WriterOptions::NAME(TYPE v)&& { return d->NAME = std::move(v), std::move(*this); }
+
+ZX_PROPERTY(int, scale)
+ZX_PROPERTY(int, rotate)
+ZX_PROPERTY(bool, invert)
+ZX_PROPERTY(bool, addHRT)
+ZX_PROPERTY(bool, addQuietZones)
+
+#undef ZX_PROPERTY
+
+WriterOptions::WriterOptions() : d(std::make_unique<Data>()) {}
+WriterOptions::~WriterOptions() = default;
+WriterOptions::WriterOptions(WriterOptions&&) noexcept = default;
+WriterOptions& WriterOptions::operator=(WriterOptions&&) noexcept = default;
+
+#ifdef ZXING_USE_ZINT
+
+struct SetCommonWriterOptions
+{
+	zint_symbol* zint;
+
+	SetCommonWriterOptions(zint_symbol* zint, const WriterOptions& opts) : zint(zint)
+	{
+		zint->show_hrt = opts.addHRT();
+
+		zint->output_options &= ~(OUT_BUFFER_INTERMEDIATE | BARCODE_NO_QUIET_ZONES);
+		zint->output_options |= opts.addQuietZones() ? BARCODE_QUIET_ZONES : BARCODE_NO_QUIET_ZONES;
+
+		if (opts.scale() > 0)
+			zint->scale = opts.scale() / 2.f;
+		else if (opts.scale() < 0) {
+			int size = std::max(zint->width, zint->rows);
+			zint->scale = std::max(1, int(float(-opts.scale()) / size)) / 2.f;
+		}
+
+		if (opts.invert()) {
+			strcpy(zint->bgcolour, "000000");
+			strcpy(zint->fgcolour, "ffffff");
+		}
+	}
+
+	// reset the defaults such that consecutive write calls don't influence each other
+	~SetCommonWriterOptions()
+	{
+		zint->scale = 0.5f;
+		strcpy(zint->fgcolour, "000000");
+		strcpy(zint->bgcolour, "ffffff");
+	}
+};
+
+#define CHECK(ZINT_CALL) \
+	if (int err = (ZINT_CALL); err >= ZINT_ERROR) \
+		throw std::invalid_argument(StrCat(zint->errtxt, " (retval: ", std::to_string(err), ")"));
+
+#endif // ZXING_USE_ZINT
+
+static std::string ToSVG(ImageView iv)
+{
+	if (!iv.data())
+		return {};
+
+	// see https://stackoverflow.com/questions/10789059/create-qr-code-in-vector-image/60638350#60638350
+
+	std::ostringstream res;
+
+	res << R"(<?xml version="1.0" encoding="UTF-8"?>)" << "\n"
+		<< R"(<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 )" << iv.width() << ' ' << iv.height()
+		<< R"(" stroke="none">)" << "\n"
+		<< "<path d=\"";
+
+	for (int y = 0; y < iv.height(); ++y)
+		for (int x = 0; x < iv.width(); ++x)
+			if (*iv.data(x, y) == 0)
+				res << "M" << x << "," << y << "h1v1h-1z";
+
+	res << "\"/>\n</svg>";
+
+	return res.str();
+}
+
+static Image ToImage(BitMatrix bits, bool isLinearCode, const WriterOptions& opts)
+{
+	bits.flipAll();
+	int width = opts.scale() > 0 ? bits.width() * opts.scale() : -opts.scale();
+	int height = isLinearCode ? std::clamp(width / 2, 50, 300) : opts.scale() > 0 ? bits.height() * opts.scale() : -opts.scale();
+	auto symbol = Inflate(std::move(bits), width, height, opts.addQuietZones() ? 10 : 0);
+	auto bitmap = ToMatrix<uint8_t>(symbol);
+	auto iv = Image(symbol.width(), symbol.height());
+	std::memcpy(const_cast<uint8_t*>(iv.data()), bitmap.data(), iv.width() * iv.height());
+	return iv;
+}
+
+std::string WriteBarcodeToSVG(const Barcode& barcode, [[maybe_unused]] const WriterOptions& options)
+{
+#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
+	auto* zint = barcode.d->zint.get();
+
+	if (!zint)
+#endif
+		return ToSVG(barcode.symbol());
+
+#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
+	auto zintLock = std::lock_guard(*barcode.d->zintMutex);
+	auto resetOnExit = SetCommonWriterOptions(zint, options);
+
+	zint->output_options |= BARCODE_MEMORY_FILE;// | EMBED_VECTOR_FONT;
+	strcpy(zint->outfile, "null.svg");
+
+	CHECK(ZBarcode_Print(zint, options.rotate()));
+
+	return std::string(reinterpret_cast<const char*>(zint->memfile), zint->memfile_size);
+#endif
+}
+
+Image WriteBarcodeToImage(const Barcode& barcode, [[maybe_unused]] const WriterOptions& options)
+{
+#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
+	auto* zint = barcode.d->zint.get();
+
+	if (!zint)
+#endif
+		return ToImage(barcode.d->symbol.copy(), barcode.format() & BarcodeFormat::AllLinear, options);
+
+#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
+	auto zintLock = std::lock_guard(*barcode.d->zintMutex);
+	auto resetOnExit = SetCommonWriterOptions(zint, options);
+
+	CHECK(ZBarcode_Buffer(zint, options.rotate()));
+
+#ifdef PRINT_DEBUG
+	printf("write symbol with size: %dx%d\n", zint->bitmap_width, zint->bitmap_height);
+#endif
+	auto iv = Image(zint->bitmap_width, zint->bitmap_height);
+	auto* src = zint->bitmap;
+	auto* dst = const_cast<uint8_t*>(iv.data());
+	for(int y = 0; y < iv.height(); ++y)
+		for(int x = 0, w = iv.width(); x < w; ++x, src += 3)
+			*dst++ = RGBToLum(src[0], src[1], src[2]);
+
+	return iv;
+#endif
+}
+
+std::string WriteBarcodeToUtf8(const Barcode& barcode, [[maybe_unused]] const WriterOptions& options)
+{
+	auto iv = barcode.symbol();
+	if (!iv.data())
+		return {};
+
+	constexpr auto map = std::array{" ", "▀", "▄", "█"};
+	std::ostringstream res;
+	bool invert = !options.invert();
+
+	Image buffer;
+	if (options.addQuietZones()) {
+		buffer = Image(iv.width() + 2, iv.height() + 2);
+		memset(const_cast<uint8_t*>(buffer.data()), 0xff, buffer.rowStride() * buffer.height());
+		for (int y = 0; y < iv.height(); y++)
+			memcpy(const_cast<uint8_t*>(buffer.data(1, y + 1)), iv.data(0, y), iv.width());
+		iv = barcode.format() & BarcodeFormat::AllLinear ? iv.cropped(0, 1, buffer.width(), buffer.height() - 2) : buffer;
+	}
+
+	for (int y = 0; y < iv.height(); y += 2) {
+		// for linear barcodes, only print line pairs that are distinct from the previous one
+		if (barcode.format() & BarcodeFormat::AllLinear && y > 1 && y < iv.height() - 1
+			&& memcmp(iv.data(0, y), iv.data(0, y - 2), 2 * iv.rowStride()) == 0)
+			continue;
+
+		for (int x = 0; x < iv.width(); ++x) {
+			int tp = bool(*iv.data(x, y)) ^ invert;
+			int bt = (iv.height() == 1 && tp) || (y + 1 < iv.height() && (bool(*iv.data(x, y + 1)) ^ invert));
+			res << map[tp | (bt << 1)];
+		}
+		res << '\n';
+	}
+
+	return res.str();
+}
+
+} // namespace ZXing

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

@@ -0,0 +1,72 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Barcode.h"
+#include "ImageView.h"
+
+#include <memory>
+
+namespace ZXing {
+
+/**
+ * @brief Configuration options for barcode writing/generation.
+ *
+ * WriterOptions provides a fluent interface for setting various parameters
+ * that control how barcodes are generated.
+ *
+ * This class supports method chaining for convenient option configuration:
+ * ```cpp
+ * auto opts = WriterOptions().scale(5).addHRT(true);
+ * ```
+ */
+class WriterOptions
+{
+	struct Data;
+
+	std::unique_ptr<Data> d;
+
+public:
+	WriterOptions();
+	~WriterOptions();
+	WriterOptions(WriterOptions&&) noexcept;
+	WriterOptions& operator=(WriterOptions&&) noexcept;
+
+#define ZX_PROPERTY(TYPE, NAME) \
+	TYPE NAME() const noexcept; \
+	WriterOptions& NAME(TYPE v)&; \
+	WriterOptions&& NAME(TYPE v)&&;
+
+	/// scale factor for rendering, ie the module size (default: 1). Passing a negative value will choose the scale
+	/// automatically to fit the size of the barcode to abs(scale) as close as possible.
+	ZX_PROPERTY(int, scale)
+
+	/// rotate the barcode by given degrees (0, 90, 180, 270)
+	ZX_PROPERTY(int, rotate)
+
+	/// invert the colors of the barcode
+	ZX_PROPERTY(bool, invert)
+
+	/// add human readable text (HRI) to the barcode
+	ZX_PROPERTY(bool, addHRT)
+
+	/// add quiet zones around the barcode (default: true)
+	ZX_PROPERTY(bool, addQuietZones)
+
+#undef ZX_PROPERTY
+};
+
+
+/// Write barcode symbol to SVG
+std::string WriteBarcodeToSVG(const Barcode& barcode, const WriterOptions& options = {});
+
+/// Write barcode symbol to a utf8 string using graphical characters (e.g. '▀')
+std::string WriteBarcodeToUtf8(const Barcode& barcode, const WriterOptions& options = {});
+
+/// Write barcode symbol to Image (Bitmap)
+Image WriteBarcodeToImage(const Barcode& barcode, const WriterOptions& options = {});
+
+} // ZXing