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

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

@@ -0,0 +1,107 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "MultiFormatReader.h"
+
+#include "BarcodeFormat.h"
+#include "BinaryBitmap.h"
+#include "Reader.h"
+#include "ReaderOptions.h"
+#include "Version.h"
+
+#if ZXING_ENABLE_AZTEC
+#include "aztec/AZReader.h"
+#endif
+#if ZXING_ENABLE_DATAMATRIX
+#include "datamatrix/DMReader.h"
+#endif
+#if ZXING_ENABLE_MAXICODE
+#include "maxicode/MCReader.h"
+#endif
+#if ZXING_ENABLE_1D
+#include "oned/ODReader.h"
+#endif
+#if ZXING_ENABLE_PDF417
+#include "pdf417/PDFReader.h"
+#include "pdf417/MicroPDFReader.h"
+#endif
+#if ZXING_ENABLE_QRCODE
+#include "qrcode/QRReader.h"
+#endif
+
+#include <memory>
+
+namespace ZXing {
+
+MultiFormatReader::MultiFormatReader(const ReaderOptions& opts) : _opts(opts)
+{
+	using enum BarcodeFormat;
+
+	// Put linear readers upfront in "normal" mode
+#if ZXING_ENABLE_1D
+	if (!opts.tryHarder() && opts.hasAnyFormat(AllLinear))
+		_readers.emplace_back(new OneD::Reader(opts));
+#endif
+
+#if ZXING_ENABLE_QRCODE
+	if (opts.hasAnyFormat(QRCode))
+		_readers.emplace_back(new QRCode::Reader(opts, true));
+#endif
+#if ZXING_ENABLE_DATAMATRIX
+	if (opts.hasAnyFormat(DataMatrix))
+		_readers.emplace_back(new DataMatrix::Reader(opts, true));
+#endif
+#if ZXING_ENABLE_AZTEC
+	if (opts.hasAnyFormat(Aztec))
+		_readers.emplace_back(new Aztec::Reader(opts, true));
+#endif
+#if ZXING_ENABLE_PDF417
+	if (opts.hasFormat(PDF417 | CompactPDF417))
+		_readers.emplace_back(new Pdf417::Reader(opts));
+	if (opts.hasFormat(MicroPDF417))
+		_readers.emplace_back(new MicroPdf417::Reader(opts));
+#endif
+#if ZXING_ENABLE_MAXICODE
+	if (opts.hasAnyFormat(MaxiCode))
+		_readers.emplace_back(new MaxiCode::Reader(opts));
+#endif
+
+	// At end in "try harder" mode
+#if ZXING_ENABLE_1D
+	if (opts.tryHarder() && opts.hasAnyFormat(AllLinear))
+		_readers.emplace_back(new OneD::Reader(opts));
+#endif
+}
+
+MultiFormatReader::~MultiFormatReader() = default;
+
+Barcodes MultiFormatReader::read(const BinaryBitmap& image, int maxSymbols) const
+{
+	Barcodes res;
+
+	for (const auto& reader : _readers) {
+		if (image.inverted() && !reader->supportsInversion)
+			continue;
+		auto r = reader->read(image, maxSymbols);
+		if (!_opts.returnErrors())
+			std::erase_if(r, [](auto&& s) { return !s.isValid(); });
+		maxSymbols -= Size(r);
+		res.insert(res.end(), std::move_iterator(r.begin()), std::move_iterator(r.end()));
+		if (maxSymbols <= 0)
+			break;
+	}
+
+	// sort barcodes based on their position on the image
+	std::sort(res.begin(), res.end(), [](const Barcode& l, const Barcode& r) {
+		auto lp = l.position().topLeft();
+		auto rp = r.position().topLeft();
+		return lp.y < rp.y || (lp.y == rp.y && lp.x < rp.x);
+	});
+
+	return res;
+}
+
+} // ZXing

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

@@ -0,0 +1,34 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Barcode.h"
+
+#include <vector>
+#include <memory>
+
+namespace ZXing {
+
+class Reader;
+class BinaryBitmap;
+class ReaderOptions;
+
+class MultiFormatReader
+{
+public:
+	explicit MultiFormatReader(const ReaderOptions& opts);
+	explicit MultiFormatReader(ReaderOptions&& opts) = delete;
+	~MultiFormatReader();
+
+	Barcodes read(const BinaryBitmap& image, int maxSymbols = 0xFF) const;
+
+private:
+	std::vector<std::unique_ptr<Reader>> _readers;
+	const ReaderOptions& _opts;
+};
+
+} // ZXing

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

@@ -0,0 +1,111 @@
+/*
+* Copyright 2017 Huy Cuong Nguyen
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "MultiFormatWriter.h"
+
+#include "BitMatrix.h"
+#include "Utf.h"
+#include "Version.h"
+
+#if ZXING_ENABLE_AZTEC
+#include "aztec/AZWriter.h"
+#endif
+#if ZXING_ENABLE_DATAMATRIX
+#include "datamatrix/DMWriter.h"
+#endif
+#if ZXING_ENABLE_1D
+#include "oned/ODCodabarWriter.h"
+#include "oned/ODCode128Writer.h"
+#include "oned/ODCode39Writer.h"
+#include "oned/ODCode93Writer.h"
+#include "oned/ODEAN13Writer.h"
+#include "oned/ODEAN8Writer.h"
+#include "oned/ODITFWriter.h"
+#include "oned/ODUPCAWriter.h"
+#include "oned/ODUPCEWriter.h"
+#endif
+#if ZXING_ENABLE_PDF417
+#include "pdf417/PDFWriter.h"
+#endif
+#if ZXING_ENABLE_QRCODE
+#include "qrcode/QRErrorCorrectionLevel.h"
+#include "qrcode/QRWriter.h"
+#endif
+
+#include <stdexcept>
+
+namespace ZXing {
+
+BitMatrix
+MultiFormatWriter::encode(const std::wstring& contents, int width, int height) const
+{
+	[[maybe_unused]] auto exec0 = [&](auto&& writer) {
+		if (_margin >=0)
+			writer.setMargin(_margin);
+		return writer.encode(contents, width, height);
+	};
+
+#if ZXING_ENABLE_AZTEC
+	auto AztecEccLevel = [&](Aztec::Writer& writer, int eccLevel) { writer.setEccPercent(eccLevel * 100 / 8); };
+#endif
+#if ZXING_ENABLE_PDF417
+	auto Pdf417EccLevel = [&](Pdf417::Writer& writer, int eccLevel) { writer.setErrorCorrectionLevel(eccLevel); };
+#endif
+#if ZXING_ENABLE_QRCODE
+	auto QRCodeEccLevel = [&](QRCode::Writer& writer, int eccLevel) {
+		writer.setErrorCorrectionLevel(static_cast<QRCode::ErrorCorrectionLevel>(--eccLevel / 2));
+	};
+#endif
+
+	[[maybe_unused]] auto exec1 = [&](auto&& writer, auto setEccLevel) {
+		if (_encoding != CharacterSet::Unknown)
+			writer.setEncoding(_encoding);
+		if (_eccLevel >= 0 && _eccLevel <= 8)
+			setEccLevel(writer, _eccLevel);
+		return exec0(std::forward<decltype(writer)>(writer));
+	};
+
+	[[maybe_unused]] auto exec2 = [&](auto&& writer) {
+		if (_encoding != CharacterSet::Unknown)
+			writer.setEncoding(_encoding);
+		return exec0(std::forward<decltype(writer)>(writer));
+	};
+
+	switch (_format) {
+#if ZXING_ENABLE_AZTEC
+	case BarcodeFormat::Aztec:
+	case BarcodeFormat::AztecCode: return exec1(Aztec::Writer(), AztecEccLevel);
+#endif
+#if ZXING_ENABLE_DATAMATRIX
+	case BarcodeFormat::DataMatrix: return exec2(DataMatrix::Writer());
+#endif
+#if ZXING_ENABLE_PDF417
+	case BarcodeFormat::PDF417: return exec1(Pdf417::Writer(), Pdf417EccLevel);
+#endif
+#if ZXING_ENABLE_QRCODE
+	case BarcodeFormat::QRCodeModel2:
+	case BarcodeFormat::QRCode: return exec1(QRCode::Writer(), QRCodeEccLevel);
+#endif
+#if ZXING_ENABLE_1D
+	case BarcodeFormat::Codabar: return exec0(OneD::CodabarWriter());
+	case BarcodeFormat::Code39: return exec0(OneD::Code39Writer());
+	case BarcodeFormat::Code93: return exec0(OneD::Code93Writer());
+	case BarcodeFormat::Code128: return exec0(OneD::Code128Writer());
+	case BarcodeFormat::EAN8: return exec0(OneD::EAN8Writer());
+	case BarcodeFormat::EAN13: return exec0(OneD::EAN13Writer());
+	case BarcodeFormat::ITF: return exec0(OneD::ITFWriter());
+	case BarcodeFormat::UPCA: return exec0(OneD::UPCAWriter());
+	case BarcodeFormat::UPCE: return exec0(OneD::UPCEWriter());
+#endif
+	default: throw std::invalid_argument("Unsupported format: " + ToString(_format));
+	}
+}
+
+BitMatrix MultiFormatWriter::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // ZXing

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

@@ -0,0 +1,62 @@
+/*
+* Copyright 2017 Huy Cuong Nguyen
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BarcodeFormat.h"
+#include "CharacterSet.h"
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+/**
+* This class is here just for convenience as it offers single-point service
+* to generate barcodes for all supported formats. As a result, this class
+* offer very limited customization compared to what are available in each
+* individual encoder.
+*/
+class MultiFormatWriter
+{
+public:
+	[[deprecated("use CreateBarcode()")]] explicit MultiFormatWriter(BarcodeFormat format) : _format(format) {}
+
+	/**
+	* Used for Aztec, PDF417, and QRCode only.
+	*/
+	MultiFormatWriter& setEncoding(CharacterSet encoding) {
+		_encoding = encoding;
+		return *this;
+	}
+
+	/**
+	* Used for Aztec, PDF417, and QRCode only, [0-8].
+	*/
+	MultiFormatWriter& setEccLevel(int level) {
+		_eccLevel = level;
+		return *this;
+	}
+
+	/**
+	* Used for all formats, sets the minimum number of quiet zone pixels.
+	*/
+	MultiFormatWriter& setMargin(int margin) {
+		_margin = margin;
+		return *this;
+	}
+
+	BitMatrix encode(const std::wstring& contents, int width, int height) const;
+	BitMatrix encode(const std::string& contents, int width, int height) const;
+
+private:
+	BarcodeFormat _format;
+	CharacterSet _encoding = CharacterSet::Unknown;
+	int _margin = -1;
+	int _eccLevel = -1;
+};
+
+} // ZXing