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

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

@@ -0,0 +1,335 @@
+/*
+* Copyright 2019 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ReadBarcode.h"
+#include "ReaderOptions.h"
+#include "BarcodeData.h"
+#include "Version.h"
+
+#include <utility>
+
+
+#ifdef ZXING_READERS
+#include "GlobalHistogramBinarizer.h"
+#include "HybridBinarizer.h"
+#include "MultiFormatReader.h"
+#include "Pattern.h"
+#include "ThresholdBinarizer.h"
+#endif
+
+#include <climits>
+#include <memory>
+#include <stdexcept>
+
+namespace ZXing {
+
+// ==============================================================================
+// ReaderOptions implementation
+// ==============================================================================
+
+struct ReaderOptions::Data
+{
+	bool tryHarder                : 1 = true;
+	bool tryRotate                : 1 = true;
+	bool tryInvert                : 1 = true;
+	bool tryDownscale             : 1 = true;
+#ifdef ZXING_EXPERIMENTAL_API
+	bool tryDenoise               : 1 = false;
+#endif
+	bool isPure                   : 1 = false;
+	bool validateOptionalChecksum : 1 = false;
+	bool returnErrors             : 1 = false;
+	uint8_t downscaleFactor       : 3 = 3; // values 2, 3, 4
+	EanAddOnSymbol eanAddOnSymbol : 2 = EanAddOnSymbol::Ignore;
+	Binarizer binarizer           : 2 = Binarizer::LocalAverage;
+	TextMode textMode             : 3 = TextMode::HRI;
+	CharacterSet characterSet     : 6 = CharacterSet::Unknown;
+
+	uint8_t minLineCount          = 2;
+	uint8_t maxNumberOfSymbols    = 0xff;
+	uint16_t downscaleThreshold   = 500;
+	BarcodeFormats formats        = {};
+};
+
+ReaderOptions::ReaderOptions() : d(std::make_unique<Data>()) {}
+ReaderOptions::~ReaderOptions() = default;
+
+// copy
+ReaderOptions::ReaderOptions(const ReaderOptions& other) : d(std::make_unique<Data>(*other.d)) {}
+ReaderOptions& ReaderOptions::operator=(const ReaderOptions& other)
+{
+	if (this != &other)
+		d = std::make_unique<Data>(*other.d);
+	return *this;
+}
+
+// move
+ReaderOptions::ReaderOptions(ReaderOptions&&) noexcept = default;
+ReaderOptions& ReaderOptions::operator=(ReaderOptions&&) noexcept = default;
+
+const BarcodeFormats& ReaderOptions::formats() const noexcept { return d->formats; }
+ReaderOptions& ReaderOptions::formats(BarcodeFormats&& v) & { return (void)(d->formats = std::move(v)), *this; }
+ReaderOptions&& ReaderOptions::formats(BarcodeFormats&& v) && { return (void)(d->formats = std::move(v)), std::move(*this); }
+
+#define ZX_PROPERTY(TYPE, NAME, SETTER) \
+	TYPE ReaderOptions::NAME() const noexcept { return d->NAME; } \
+	ReaderOptions& ReaderOptions::NAME(TYPE v) & { return (void)(d->NAME = std::move(v)), *this; } \
+	ReaderOptions&& ReaderOptions::NAME(TYPE v) && { return (void)(d->NAME = std::move(v)), std::move(*this); }
+
+ZX_PROPERTY(bool, tryHarder, setTryHarder)
+ZX_PROPERTY(bool, tryRotate, setTryRotate)
+ZX_PROPERTY(bool, tryInvert, setTryInvert)
+ZX_PROPERTY(bool, tryDownscale, setTryDownscale)
+#ifdef ZXING_EXPERIMENTAL_API
+ZX_PROPERTY(bool, tryDenoise, setTryDenoise)
+#endif
+ZX_PROPERTY(Binarizer, binarizer, setBinarizer)
+ZX_PROPERTY(bool, isPure, setIsPure)
+ZX_PROPERTY(uint16_t, downscaleThreshold, setDownscaleThreshold)
+ZX_PROPERTY(uint8_t, downscaleFactor, setDownscaleFactor)
+ZX_PROPERTY(uint8_t, minLineCount, setMinLineCount)
+ZX_PROPERTY(uint8_t, maxNumberOfSymbols, setMaxNumberOfSymbols)
+ZX_PROPERTY(bool, validateOptionalChecksum, setValidateOptionalChecksum)
+ZX_PROPERTY(bool, returnErrors, setReturnErrors)
+ZX_PROPERTY(EanAddOnSymbol, eanAddOnSymbol, setEanAddOnSymbol)
+ZX_PROPERTY(TextMode, textMode, setTextMode)
+ZX_PROPERTY(CharacterSet, characterSet, setCharacterSet)
+
+#undef ZX_PROPERTY
+
+ReaderOptions& ReaderOptions::characterSet(std::string_view v) &
+{
+	d->characterSet = CharacterSetFromString(v);
+	return *this;
+}
+ReaderOptions&& ReaderOptions::characterSet(std::string_view v) &&
+{
+	d->characterSet = CharacterSetFromString(v);
+	return std::move(*this);
+}
+
+bool ReaderOptions::hasFormat(const BarcodeFormats& formats) const noexcept
+{
+	return d->formats.empty() || std::any_of(formats.begin(), formats.end(), [this](BarcodeFormat bt) { return bt <= d->formats; });
+}
+
+bool ReaderOptions::hasAnyFormat(const BarcodeFormats& formats) const noexcept
+{
+	return d->formats.empty() || std::any_of(formats.begin(), formats.end(), [this](BarcodeFormat bt) { return bt & d->formats; });
+}
+
+// ==============================================================================
+// ReadBarcode implementation
+// ==============================================================================
+
+#ifdef ZXING_READERS
+
+class LumImage : public Image
+{
+public:
+	using Image::Image;
+
+	uint8_t* data() { return const_cast<uint8_t*>(Image::data()); }
+};
+
+template<typename P>
+static LumImage ExtractLum(const ImageView& iv, P projection)
+{
+	LumImage res(iv.width(), iv.height());
+
+	auto* dst = res.data();
+	for(int y = 0; y < iv.height(); ++y)
+		for(int x = 0, w = iv.width(); x < w; ++x)
+			*dst++ = projection(iv.data(x, y));
+
+	return res;
+}
+
+class LumImagePyramid
+{
+	std::vector<LumImage> buffers;
+
+	template<int N>
+	void addLayer()
+	{
+		auto siv = layers.back();
+		buffers.emplace_back(siv.width() / N, siv.height() / N);
+		layers.push_back(buffers.back());
+		auto& div = buffers.back();
+		auto* d   = div.data();
+
+		for (int dy = 0; dy < div.height(); ++dy)
+			for (int dx = 0; dx < div.width(); ++dx) {
+				int sum = (N * N) / 2;
+				for (int ty = 0; ty < N; ++ty)
+					for (int tx = 0; tx < N; ++tx)
+						sum += *siv.data(dx * N + tx, dy * N + ty);
+				*d++ = sum / (N * N);
+			}
+	}
+
+	void addLayer(int factor)
+	{
+		// help the compiler's auto-vectorizer by hard-coding the scale factor
+		switch (factor) {
+		case 2: addLayer<2>(); break;
+		case 3: addLayer<3>(); break;
+		case 4: addLayer<4>(); break;
+		default: throw std::invalid_argument("Invalid ReaderOptions::downscaleFactor"); break;
+		}
+	}
+
+public:
+	std::vector<ImageView> layers;
+
+	LumImagePyramid(const ImageView& iv, int threshold, int factor)
+	{
+		if (factor < 2)
+			throw std::invalid_argument("Invalid ReaderOptions::downscaleFactor");
+
+		layers.push_back(iv);
+		// TODO: if only matrix codes were considered, then using std::min would be sufficient (see #425)
+		while (threshold > 0 && std::max(layers.back().width(), layers.back().height()) > threshold &&
+			   std::min(layers.back().width(), layers.back().height()) >= factor)
+			addLayer(factor);
+#if 0
+		// Reversing the layers means we'd start with the smallest. that can make sense if we are only looking for a
+		// single symbol. If we start with the higher resolution, we get better (high res) position information.
+		// TODO: see if masking out higher res layers based on found symbols in lower res helps overall performance.
+		std::reverse(layers.begin(), layers.end());
+#endif
+	}
+};
+
+ImageView SetupLumImageView(ImageView iv, LumImage& lum, const ReaderOptions& opts)
+{
+	if (iv.format() == ImageFormat::None)
+		throw std::invalid_argument("Invalid image format");
+
+	if (opts.binarizer() == Binarizer::GlobalHistogram || opts.binarizer() == Binarizer::LocalAverage) {
+		// manually spell out the 3 most common pixel formats to get at least gcc to vectorize the code
+		if (iv.format() == ImageFormat::RGB && iv.pixStride() == 3) {
+			lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[0], src[1], src[2]); });
+		} else if (iv.format() == ImageFormat::RGBA && iv.pixStride() == 4) {
+			lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[0], src[1], src[2]); });
+		} else if (iv.format() == ImageFormat::BGR && iv.pixStride() == 3) {
+			lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[2], src[1], src[0]); });
+		} else if (iv.format() != ImageFormat::Lum) {
+			lum = ExtractLum(iv, [r = RedIndex(iv.format()), g = GreenIndex(iv.format()), b = BlueIndex(iv.format())](
+									 const uint8_t* src) { return RGBToLum(src[r], src[g], src[b]); });
+		} else if (iv.pixStride() != 1) {
+			// GlobalHistogram and LocalAverage need dense line memory layout
+			lum = ExtractLum(iv, [](const uint8_t* src) { return *src; });
+		}
+		if (lum.data())
+			return lum;
+	}
+	return iv;
+}
+
+std::unique_ptr<BinaryBitmap> CreateBitmap(ZXing::Binarizer binarizer, const ImageView& iv)
+{
+	switch (binarizer) {
+	case Binarizer::BoolCast: return std::make_unique<ThresholdBinarizer>(iv, 0);
+	case Binarizer::FixedThreshold: return std::make_unique<ThresholdBinarizer>(iv, 127);
+	case Binarizer::GlobalHistogram: return std::make_unique<GlobalHistogramBinarizer>(iv);
+	case Binarizer::LocalAverage: return std::make_unique<HybridBinarizer>(iv);
+	}
+	return {}; // silence gcc warning
+}
+
+Barcode ReadBarcode(const ImageView& _iv, const ReaderOptions& opts)
+{
+	return FirstOrDefault(ReadBarcodes(_iv, ReaderOptions(opts).maxNumberOfSymbols(1)));
+}
+
+Barcodes ReadBarcodes(const ImageView& _iv, const ReaderOptions& opts)
+{
+	if (sizeof(PatternType) < 4 && (_iv.width() > 0xffff || _iv.height() > 0xffff))
+		throw std::invalid_argument("Maximum image width/height is 65535");
+
+	if (!_iv.data() || _iv.width() * _iv.height() == 0)
+		throw std::invalid_argument("ImageView is null/empty");
+
+	LumImage lum;
+	ImageView iv = SetupLumImageView(_iv, lum, opts);
+	MultiFormatReader reader(opts);
+
+	if (opts.isPure())
+		return {FirstOrDefault(reader.read(*CreateBitmap(opts.binarizer(), iv), 1)).setReaderOptions(opts)};
+
+	std::unique_ptr<MultiFormatReader> closedReader;
+#ifdef ZXING_EXPERIMENTAL_API
+	using enum BarcodeFormat;
+	BarcodeFormats formatsBenefittingFromClosing = Aztec | DataMatrix | QRCode;
+	ReaderOptions closedOptions = opts;
+	if (opts.tryDenoise() && opts.hasAnyFormat(formatsBenefittingFromClosing) && _iv.height() >= 3) {
+		closedOptions.formats(opts.formats().empty() ? formatsBenefittingFromClosing : formatsBenefittingFromClosing & opts.formats());
+		closedReader = std::make_unique<MultiFormatReader>(closedOptions);
+	}
+#endif
+	LumImagePyramid pyramid(iv, opts.downscaleThreshold() * opts.tryDownscale(), opts.downscaleFactor());
+
+	Barcodes res;
+	int maxSymbols = opts.maxNumberOfSymbols() ? opts.maxNumberOfSymbols() : INT_MAX;
+	for (auto&& iv : pyramid.layers) {
+		auto bitmap = CreateBitmap(opts.binarizer(), iv);
+		for (int close = 0; close <= (closedReader ? 1 : 0); ++close) {
+			if (close) {
+				// if we already inverted the image in the first round, we need to undo that first
+				if (bitmap->inverted())
+					bitmap->invert();
+				bitmap->close();
+			}
+
+			// TODO: check if closing after invert would be beneficial
+			for (int invert = 0; invert <= static_cast<int>(opts.tryInvert() && !close); ++invert) {
+				if (invert)
+					bitmap->invert();
+				auto rs = (close ? *closedReader : reader).read(*bitmap, maxSymbols);
+				for (auto& r : rs) {
+					if (iv.width() != _iv.width())
+						r.d->position = Scale(r.position(), _iv.width() / iv.width());
+					if (!Contains(res, r)) {
+						r.setReaderOptions(opts);
+						r.d->isInverted = bitmap->inverted();
+						res.push_back(std::move(r));
+						--maxSymbols;
+					}
+				}
+				if (maxSymbols <= 0)
+					return res;
+			}
+		}
+	}
+
+	if (opts.returnErrors()) {
+		// if symbols overlap and one is in error remove it
+		for (auto a = res.begin(); a != res.end(); ++a)
+			for (auto b = std::next(a); b != res.end(); ++b)
+				if (HaveIntersectingBoundingBoxes(a->position(), b->position()) && (a->error() != b->error()))
+					*(a->error() ? a : b) = BarcodeData();
+
+		std::erase_if(res, [](auto&& r) { return r.format() == BarcodeFormat::None; });
+	}
+
+	return res;
+}
+
+#else // ZXING_READERS
+
+Barcode ReadBarcode(const ImageView&, const ReaderOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support reading barcodes.");
+}
+
+Barcodes ReadBarcodes(const ImageView&, const ReaderOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support reading barcodes.");
+}
+
+#endif // ZXING_READERS
+
+} // ZXing

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

@@ -0,0 +1,33 @@
+/*
+* Copyright 2019 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ReaderOptions.h"
+#include "ImageView.h"
+#include "Barcode.h"
+
+namespace ZXing {
+
+/**
+ * Read barcode from an ImageView
+ *
+ * @param image  view of the image data including layout and format
+ * @param options  optional ReaderOptions to parameterize / speed up detection
+ * @return Barcode found, if any, otherwise a Barcode with empty content and format ZXing::BarcodeFormat::None
+ */
+Barcode ReadBarcode(const ImageView& image, const ReaderOptions& options = {});
+
+/**
+ * Read barcodes from an ImageView
+ *
+ * @param image  view of the image data including layout and format
+ * @param options  optional ReaderOptions to parameterize / speed up detection
+ * @return List of Barcode found, may be empty
+ */
+Barcodes ReadBarcodes(const ImageView& image, const ReaderOptions& options = {});
+
+} // ZXing
+

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

@@ -0,0 +1,32 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ReaderOptions.h"
+#include "BarcodeData.h"
+
+namespace ZXing {
+
+class BinaryBitmap;
+class ReaderOptions;
+
+class Reader
+{
+protected:
+	const ReaderOptions& _opts;
+
+public:
+	const bool supportsInversion;
+
+	explicit Reader(const ReaderOptions& opts, bool supportsInversion = false) : _opts(opts), supportsInversion(supportsInversion) {}
+	explicit Reader(ReaderOptions&& opts) = delete;
+	virtual ~Reader() = default;
+
+	virtual BarcodesData read(const BinaryBitmap& image, int maxSymbols) const = 0;
+};
+
+} // ZXing

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

@@ -0,0 +1,210 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BarcodeFormat.h"
+#include "CharacterSet.h"
+#include "Version.h"
+
+#include <string_view>
+#include <utility>
+#include <memory>
+
+namespace ZXing {
+
+/**
+ * @brief Specify which algorithm to use for the grayscale to binary transformation.
+ *
+ * The difference is how to get to a threshold value T which results in a bit value R(esult) = L(uminance) <= T(hreshold).
+ */
+enum class Binarizer : unsigned char // needs to be unsigned for the bitfield below to work, uint8_t fails as well
+{
+	LocalAverage,    ///< T = average of neighboring pixels for matrix and GlobalHistogram for linear (HybridBinarizer)
+	GlobalHistogram, ///< T = valley between the 2 largest peaks in the histogram (per line in linear case)
+	FixedThreshold,  ///< T = 127
+	BoolCast,        ///< T = 0, fastest possible
+};
+
+/**
+ * @brief Specify whether to ignore, read or require EAN-2/5 add-on symbols while scanning EAN/UPC codes.
+ */
+enum class EanAddOnSymbol : unsigned char // see above
+{
+	Ignore,  ///< Ignore any Add-On symbol during read/scan
+	Read,    ///< Read EAN-2/EAN-5 Add-On symbol if found
+	Require, ///< Require EAN-2/EAN-5 Add-On symbol to be present
+};
+
+/**
+ * @brief Specify how the decoded byte content of a barcode should be transcoded to text.
+ *
+ * @see Barcode::text(), ReaderOptions::textMode().
+ */
+enum class TextMode : unsigned char // see above
+{
+	Plain,   ///< bytes() transcoded to unicode based on ECI info or guessed charset (the default mode prior to 2.0)
+	ECI,     ///< standard content following the ECI protocol with every character set ECI segment transcoded to unicode
+	HRI,     ///< Human Readable Interpretation (dependent on the ContentType)
+	Escaped, ///< Use the EscapeNonGraphical() function (e.g. ASCII 29 will be transcoded to "<GS>")
+	Hex,     ///< bytes() transcoded to ASCII string of HEX values
+	HexECI,  ///< bytesECI() transcoded to ASCII string of HEX values
+};
+
+/**
+ * @brief Configuration options for barcode reading and decoding behavior.
+ *
+ * ReaderOptions encapsulates a set of flags and parameters that control
+ * how barcode detection and decoding is performed. It provides
+ * fluent setters that support chaining. Both `name(val)` and `setName(val)`
+ * forms are available for convenience and compatibility.
+ *
+ * The class is intended to be passed to the ReadBarcodes function to
+ * influence scanning heuristics, performance vs. accuracy trade-offs, output
+ * formatting, and symbol filtering. Instances can be reused across multiple
+ * read operations.
+ *
+ * The default settings are optimized for detection rate and can be tuned
+ * for speed or specific use-cases.
+ *
+ * @see BarcodeFormats, Binarizer, TextMode, CharacterSet, ReadBarcodes
+ */
+class ReaderOptions
+{
+	struct Data;
+	std::unique_ptr<Data> d;
+
+public:
+	ReaderOptions();
+	~ReaderOptions();
+	ReaderOptions(const ReaderOptions&);
+	ReaderOptions& operator=(const ReaderOptions&);
+	ReaderOptions(ReaderOptions&&) noexcept;
+	ReaderOptions& operator=(ReaderOptions&&) noexcept;
+
+#define ZX_PROPERTY(TYPE, NAME, SETTER, ...) \
+	TYPE NAME() const noexcept; \
+	__VA_ARGS__ ReaderOptions& NAME(TYPE v) &; \
+	__VA_ARGS__ ReaderOptions&& NAME(TYPE v) &&; \
+	__VA_ARGS__ inline ReaderOptions& SETTER(TYPE v) & { return NAME(v); } \
+	__VA_ARGS__ inline ReaderOptions&& SETTER(TYPE v) && { return std::move(*this).NAME(v); }
+
+	/// Specify a set of BarcodeFormats that should be searched for, the default is all supported formats.
+	const BarcodeFormats& formats() const noexcept;
+	ReaderOptions& formats(BarcodeFormats&& v) &;
+	ReaderOptions&& formats(BarcodeFormats&& v) &&;
+	ReaderOptions& formats(const BarcodeFormats& v) & { return formats(BarcodeFormats(v)); }
+	ReaderOptions&& formats(const BarcodeFormats& v) && { return std::move(*this).formats(BarcodeFormats(v)); }
+	inline ReaderOptions& setFormats(BarcodeFormats&& v) & { return formats(std::move(v)); }
+	inline ReaderOptions&& setFormats(BarcodeFormats&& v) && { return std::move(*this).formats(std::move(v)); }
+	inline ReaderOptions& setFormats(const BarcodeFormats& v) & { return formats(BarcodeFormats(v)); }
+	inline ReaderOptions&& setFormats(const BarcodeFormats& v) && { return std::move(*this).formats(BarcodeFormats(v)); }
+
+	/// Spend more time to try to find a barcode; optimize for accuracy instead of not speed (default: true).
+	ZX_PROPERTY(bool, tryHarder, setTryHarder)
+
+	/// Try detecting codes in 90, 180 and 270 degree rotated images (default: true).
+	ZX_PROPERTY(bool, tryRotate, setTryRotate)
+
+	/// Try detecting inverted ("reversed reflectance") codes if the format allows for those (default: true).
+	ZX_PROPERTY(bool, tryInvert, setTryInvert)
+
+	/// Try detecting code in downscaled images (depending on image size) (default: true).
+	ZX_PROPERTY(bool, tryDownscale, setTryDownscale)
+
+#ifdef ZXING_EXPERIMENTAL_API
+	/// Also try detecting code after denoising (currently morphological closing filter for 2D formats only).
+	ZX_PROPERTY(bool, tryDenoise, setTryDenoise)
+#endif
+
+	/// Binarizer to use for grayscale to binary transformation (default: Binarizer::LocalAverage).
+	ZX_PROPERTY(Binarizer, binarizer, setBinarizer)
+
+	/// Set to true if the input contains nothing but a single perfectly aligned barcode (generated image).
+	ZX_PROPERTY(bool, isPure, setIsPure)
+
+	/// Image size ( min(width, height) ) threshold at which to start downscaled scanning.
+	ZX_PROPERTY(uint16_t, downscaleThreshold, setDownscaleThreshold)
+
+	/// Scale factor used during downscaling, meaningful values are 2, 3 and 4.
+	ZX_PROPERTY(uint8_t, downscaleFactor, setDownscaleFactor)
+
+	/// The number of scan lines in a linear barcode that have to be equal to accept the result (default: 2).
+	ZX_PROPERTY(uint8_t, minLineCount, setMinLineCount)
+
+	/// The maximum number of symbols (barcodes) to detect / look for with ReadBarcodes().
+	ZX_PROPERTY(uint8_t, maxNumberOfSymbols, setMaxNumberOfSymbols)
+
+	/// Validate optional checksums where applicable (e.g. Code39, ITF) (default: false).
+	ZX_PROPERTY(bool, validateOptionalChecksum, setValidateOptionalChecksum)
+
+	/// If true, return the barcodes with errors as well (e.g. checksum errors, see Barcode::error()) (default: false).
+	ZX_PROPERTY(bool, returnErrors, setReturnErrors)
+
+	/// Specify whether to ignore, read or require EAN-2/5 add-on symbols while scanning EAN/UPC codes.
+	ZX_PROPERTY(EanAddOnSymbol, eanAddOnSymbol, setEanAddOnSymbol)
+
+	/// Specifies the TextMode that controls the return of the Barcode::text() function (default: TextMode::HRI).
+	ZX_PROPERTY(TextMode, textMode, setTextMode)
+
+	/// Specifies fallback character set to use instead of auto-detecting it (when applicable).
+	ZX_PROPERTY(CharacterSet, characterSet, setCharacterSet)
+	ReaderOptions& characterSet(std::string_view v) &;
+	ReaderOptions&& characterSet(std::string_view v) &&;
+	inline ReaderOptions& setCharacterSet(std::string_view v) & { return characterSet(v); }
+	inline ReaderOptions&& setCharacterSet(std::string_view v) && { return std::move(*this).characterSet(v); }
+
+#undef ZX_PROPERTY
+
+/// @cond DEPRECATED
+
+	// Silence deprecated-declarations warnings, only happening here for deprecated inline functions
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+#define ZX_DEPRECATED_PROPERTY(TYPE, NAME, SETTER, GET_IMPL, SET_IMPL) \
+	[[deprecated]] inline TYPE NAME() const noexcept { return GET_IMPL; } \
+	[[deprecated]] ReaderOptions& NAME(TYPE v) & { SET_IMPL; return *this; } \
+	[[deprecated]] ReaderOptions&& NAME(TYPE v) && { SET_IMPL; return std::move(*this); } \
+	[[deprecated]] inline ReaderOptions& SETTER(TYPE v) & { return NAME(v); } \
+	[[deprecated]] inline ReaderOptions&& SETTER(TYPE v) && { return std::move(*this).NAME(v); }
+
+	/// @deprecated (does nothing). See BarcodeFormat::Code39Ext and ::Code39Std to select full ASCII or standard Code39 mode.
+	ZX_DEPRECATED_PROPERTY(bool, tryCode39ExtendedMode, setTryCode39ExtendedMode, true, (void)v)
+
+	/// @deprecated (use validateOptionalChecksum). The Code39 symbol has a valid checksum iff symbologyIdentifier()[2] is an odd digit
+	ZX_DEPRECATED_PROPERTY(bool, validateCode39CheckSum, setValidateCode39CheckSum, validateOptionalChecksum(),
+						   validateOptionalChecksum(v))
+
+	/// @deprecated (use validateOptionalChecksum). The ITF symbol has a valid checksum iff symbologyIdentifier()[2] == '1'.
+	ZX_DEPRECATED_PROPERTY(bool, validateITFCheckSum, setValidateITFCheckSum, validateOptionalChecksum(), validateOptionalChecksum(v))
+
+#undef ZX_DEPRECATED_PROPERTY
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+/// @endcond
+
+#ifdef ZXING_INTERNAL
+	/// Check if a specific format is explicitly enabled in the formats set
+	bool hasFormat(const BarcodeFormats& formats) const noexcept;
+
+	/// Check if any format is explicitly or implicitly enabled in the formats set
+	bool hasAnyFormat(const BarcodeFormats& formats) const noexcept;
+#endif
+};
+
+} // ZXing