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

package/cpp/zxing-core/core/src/oned/ODReader.cpp

@@ -0,0 +1,259 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODReader.h"
+
+#include "BinaryBitmap.h"
+#include "ReaderOptions.h"
+#include "ODCodabarReader.h"
+#include "ODCode128Reader.h"
+#include "ODCode39Reader.h"
+#include "ODCode93Reader.h"
+#include "ODDataBarExpandedReader.h"
+#include "ODDataBarLimitedReader.h"
+#include "ODDataBarReader.h"
+#include "ODDXFilmEdgeReader.h"
+#include "ODITFReader.h"
+#include "ODMultiUPCEANReader.h"
+#include "ODTelepenReader.h"
+#include "BarcodeData.h"
+
+#include <algorithm>
+#include <utility>
+
+#ifdef PRINT_DEBUG
+#include "BitMatrix.h"
+#include "BitMatrixIO.h"
+#endif
+
+namespace ZXing::OneD {
+
+Reader::Reader(const ReaderOptions& opts) : ZXing::Reader(opts)
+{
+	using enum BarcodeFormat;
+
+	_readers.reserve(8);
+
+	if (opts.hasAnyFormat(EANUPC))
+		_readers.emplace_back(new MultiUPCEANReader(opts));
+
+	if (opts.hasAnyFormat(Code39))
+		_readers.emplace_back(new Code39Reader(opts));
+	if (opts.hasAnyFormat(Code93))
+		_readers.emplace_back(new Code93Reader(opts));
+	if (opts.hasAnyFormat(Code128))
+		_readers.emplace_back(new Code128Reader(opts));
+	if (opts.hasAnyFormat(ITF))
+		_readers.emplace_back(new ITFReader(opts));
+	if (opts.hasAnyFormat(Telepen))
+		_readers.emplace_back(new TelepenReader(opts));
+	if (opts.hasAnyFormat(Codabar))
+		_readers.emplace_back(new CodabarReader(opts));
+	if (opts.hasFormat(DataBar | DataBarOmni | DataBarStk | DataBarStkOmni))
+		_readers.emplace_back(new DataBarReader(opts));
+	if (opts.hasFormat(DataBar | DataBarExp | DataBarExpStk))
+		_readers.emplace_back(new DataBarExpandedReader(opts));
+	if (opts.hasFormat(DataBar | DataBarLtd))
+		_readers.emplace_back(new DataBarLimitedReader(opts));
+	if (opts.hasAnyFormat(DXFilmEdge))
+		_readers.emplace_back(new DXFilmEdgeReader(opts));
+}
+
+Reader::~Reader() = default;
+
+/**
+* We're going to examine rows from the middle outward, searching alternately above and below the
+* middle, and farther out each time. rowStep is the number of rows between each successive
+* attempt above and below the middle. So we'd scan row middle, then middle - rowStep, then
+* middle + rowStep, then middle - (2 * rowStep), etc.
+* rowStep is bigger as the image is taller, but is always at least 1. We've somewhat arbitrarily
+* decided that moving up and down by about 1/16 of the image is pretty good; we try more of the
+* image if "trying harder".
+*/
+BarcodesData DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers, const BinaryBitmap& image, bool tryHarder,
+						 bool rotate, bool isPure, int maxSymbols, int minLineCount, bool returnErrors)
+{
+	BarcodesData res;
+
+	std::vector<std::unique_ptr<RowReader::DecodingState>> decodingState(readers.size());
+
+	int width = image.width();
+	int height = image.height();
+
+	if (rotate)
+		std::swap(width, height);
+
+	int middle = height / 2;
+	// TODO: find a better heuristic/parameterization if maxSymbols != 1
+	int rowStep = std::max(1, height / ((tryHarder && !isPure) ? (maxSymbols == 1 ? 256 : 512) : 32));
+	int maxLines = tryHarder ?
+		height :	// Look at the whole image, not just the center
+		15;			// 15 rows spaced 1/32 apart is roughly the middle half of the image
+
+	if (isPure)
+		minLineCount = 1;
+	else
+		minLineCount = std::min(minLineCount, height);
+	std::vector<int> checkRows;
+
+	PatternRow bars;
+	bars.reserve(128); // e.g. EAN-13 has 59 bars/spaces
+
+#ifdef PRINT_DEBUG
+	BitMatrix dbg(width, height);
+#endif
+
+	for (int i = 0; i < maxLines; i++) {
+
+		// Scanning from the middle out. Determine which row we're looking at next:
+		int rowStepsAboveOrBelow = (i + 1) / 2;
+		bool isAbove = (i & 0x01) == 0; // i.e. is x even?
+		int rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);
+		bool isCheckRow = false;
+		if (rowNumber < 0 || rowNumber >= height) {
+			// Oops, if we run off the top or bottom, stop
+			break;
+		}
+
+		// See if we have additional check rows (see below) to process
+		if (checkRows.size()) {
+			--i;
+			rowNumber = checkRows.back();
+			checkRows.pop_back();
+			isCheckRow = true;
+			if (rowNumber < 0 || rowNumber >= height)
+				continue;
+		}
+
+		if (!image.getPatternRow(rowNumber, rotate ? 90 : 0, bars))
+			continue;
+
+#ifdef PRINT_DEBUG
+		bool val = false;
+		int x = 0;
+		for (auto b : bars) {
+			for(unsigned j = 0; j < b; ++j)
+				dbg.set(x++, rowNumber, val);
+			val = !val;
+		}
+#endif
+
+		// While we have the image data in a PatternRow, it's fairly cheap to reverse it in place to
+		// handle decoding upside down barcodes.
+		// TODO: the DataBarExpanded (stacked) decoder depends on seeing each line from both directions. This is
+		// 'surprising' and inconsistent. It also requires the decoderState to be shared between normal and reversed
+		// scans, which makes no sense in general because it would mix partial detection data from two codes of the same
+		// type next to each other. See also https://github.com/zxing-cpp/zxing-cpp/issues/87
+		for (bool upsideDown : {false, true}) {
+			// trying again?
+			if (upsideDown) {
+				// reverse the row and continue
+				std::reverse(bars.begin(), bars.end());
+			}
+			// Look for a barcode
+			for (size_t r = 0; r < readers.size(); ++r) {
+				// If this is a pure symbol, then checking a single non-empty line is sufficient for all but the stacked
+				// DataBar codes. They are the only ones using the decodingState, which we can use as a flag here.
+				if (isPure && i && !decodingState[r])
+					continue;
+
+				PatternView next(bars);
+				do {
+					BarcodeData result = readers[r]->decodePattern(rowNumber, next, decodingState[r]);
+					if (result.isValid() || (returnErrors && result.error)) {
+						result.lineCount++;
+						if (upsideDown) {
+							// update position (flip horizontally).
+							for (auto& p : result.position) {
+								p = {width - p.x - 1, p.y};
+							}
+						}
+						if (rotate) {
+							for (auto& p : result.position) {
+								p = {p.y, width - p.x - 1};
+							}
+						}
+
+						// check if we know this code already
+						for (auto& other : res) {
+							if (result == other) {
+								// merge the position information
+								auto dTop = maxAbsComponent(other.position.topLeft() - result.position.topLeft());
+								auto dBot = maxAbsComponent(other.position.bottomLeft() - result.position.topLeft());
+								if (dTop < dBot || (dTop == dBot && rotate ^ (sumAbsComponent(other.position[0]) >
+																			  sumAbsComponent(result.position[0])))) {
+									other.position[0] = result.position[0];
+									other.position[1] = result.position[1];
+								} else {
+									other.position[2] = result.position[2];
+									other.position[3] = result.position[3];
+								}
+								other.lineCount++;
+								// clear the result, so we don't insert it again below
+								result = BarcodeData();
+								break;
+							}
+						}
+
+						if (result.format != BarcodeFormat::None) {
+							res.push_back(std::move(result));
+
+							// if we found a valid code we have not seen before but a minLineCount > 1,
+							// add additional check rows above and below the current one
+							if (!isCheckRow && minLineCount > 1 && rowStep > 1) {
+								checkRows = {rowNumber - 1, rowNumber + 1};
+								if (rowStep > 2)
+									checkRows.insert(checkRows.end(), {rowNumber - 2, rowNumber + 2});
+							}
+						}
+
+						if (maxSymbols && Reduce(res, 0, [&](int s, const BarcodeData& r) {
+											  return s + (r.lineCount >= minLineCount);
+										  }) == maxSymbols) {
+							goto out;
+						}
+					}
+					// make sure we make progress and we start the next try on a bar
+					next.shift(2 - (next.index() % 2));
+					next.extend();
+				} while (tryHarder && next.size());
+			}
+		}
+	}
+
+out:
+	// remove all symbols with insufficient line count
+	std::erase_if(res, [&](auto&& r) { return r.lineCount < minLineCount; });
+
+	// if symbols overlap, remove the one with a lower line count
+	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->lineCount < b->lineCount ? a : b) = BarcodeData();
+
+	std::erase_if(res, [](auto&& r) { return r.format == BarcodeFormat::None; });
+
+#ifdef PRINT_DEBUG
+	SaveAsPBM(dbg, rotate ? "od-log-r.pnm" : "od-log.pnm");
+#endif
+
+	return res;
+}
+
+BarcodesData Reader::read(const BinaryBitmap& image, int maxSymbols) const
+{
+	auto resH =
+		DoDecode(_readers, image, _opts.tryHarder(), false, _opts.isPure(), maxSymbols, _opts.minLineCount(), _opts.returnErrors());
+	if ((!maxSymbols || Size(resH) < maxSymbols) && _opts.tryRotate()) {
+		auto resV = DoDecode(_readers, image, _opts.tryHarder(), true, _opts.isPure(), maxSymbols - Size(resH),
+								 _opts.minLineCount(), _opts.returnErrors());
+		resH.insert(resH.end(), std::make_move_iterator(resV.begin()), std::make_move_iterator(resV.end()));
+	}
+	return resH;
+}
+
+} // namespace ZXing::OneD

package/cpp/zxing-core/core/src/oned/ODReader.h

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

package/cpp/zxing-core/core/src/oned/ODRowReader.h

@@ -0,0 +1,222 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BitArray.h"
+#include "Pattern.h"
+#include "BarcodeData.h"
+#include "ZXAlgorithms.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <memory>
+
+/*
+Code39 : 1:2/3, 5+4+1 (0x3|2x1 wide) -> 12-15 mods, v1-? | ToNarrowWide(OMG 1) == *
+Codabar: 1:2/3, 4+3+1 (1x1|1x2|3x0 wide) -> 9-13 mods, v1-? | ToNarrowWide(OMG 2) == ABCD
+ITF    : 1:2/3, 5+5   (2x2 wide) -> mods, v6-?| .5, .38 == * | qz:10
+
+Code93 : 1-4, 3+3 -> 9 mods  v1-? | round to 1-4 == *
+Code128: 1-4, 3+3 -> 11 mods v1-? | .7, .25 == ABC | qz:10
+UPC/EAN: 1-4, 2+2 -> 7 mods  f    | .7, .48 == *
+  UPC-A: 11d 95m = 3 + 6*4 + 5 + 6*4 + 3 = 59 | qz:3
+  EAN-13: 12d 95m
+  UPC-E: 6d, 3 + 6*4 + 6 = 33
+  EAN-8: 8d, 3 + 4*4 + 5 + 4*4 + 3 = 43
+
+RSS14  : 1-8, finder: (15,2+3), symbol: (15/16,4+4) | .45, .2 (finder only), 14d
+  code = 2xguard + 2xfinder + 4xsymbol = (96,23), stacked = 2x50 mods
+RSSExp.:  v?-74d/?-41c
+*/
+
+namespace ZXing {
+
+class ReaderOptions;
+
+namespace OneD {
+
+/**
+* Encapsulates functionality and implementation that is common to all families
+* of one-dimensional barcodes.
+*/
+class RowReader
+{
+protected:
+	const ReaderOptions& _opts;
+
+public:
+	explicit RowReader(const ReaderOptions& opts) : _opts(opts) {}
+	explicit RowReader(ReaderOptions&&) = delete;
+
+	struct DecodingState
+	{
+		virtual ~DecodingState() = default;
+	};
+
+	virtual ~RowReader() = default;
+
+	virtual BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const = 0;
+
+	/**
+	 * Determines how closely a set of observed counts of runs of black/white values matches a given
+	 * target pattern. This is reported as the ratio of the total variance from the expected pattern
+	 * proportions across all pattern elements, to the length of the pattern.
+	 *
+	 * @param counters observed counters
+	 * @param pattern expected pattern
+	 * @param maxIndividualVariance The most any counter can differ before we give up
+	 * @return ratio of total variance between counters and pattern compared to total pattern size
+	 */
+	template <typename CP, typename PP>
+	static float PatternMatchVariance(const CP* counters, const PP* pattern, size_t length, float maxIndividualVariance)
+	{
+		int total = Reduce(counters, counters + length, 0);
+		int patternLength = Reduce(pattern, pattern + length, 0);
+		if (total < patternLength) {
+			// If we don't even have one pixel per unit of bar width, assume this is too small
+			// to reliably match, so fail:
+			return std::numeric_limits<float>::max();
+		}
+
+		float unitBarWidth = (float)total / patternLength;
+		maxIndividualVariance *= unitBarWidth;
+
+		float totalVariance = 0.0f;
+		for (size_t x = 0; x < length; ++x) {
+			float variance = std::abs(counters[x] - pattern[x] * unitBarWidth);
+			if (variance > maxIndividualVariance) {
+				return std::numeric_limits<float>::max();
+			}
+			totalVariance += variance;
+		}
+		return totalVariance / total;
+	}
+
+	template <typename Counters, typename Pattern>
+	static float PatternMatchVariance(const Counters& counters, const Pattern& pattern, float maxIndividualVariance) {
+		assert(Size(counters) == Size(pattern));
+		return PatternMatchVariance(std::data(counters), std::data(pattern), std::size(counters), maxIndividualVariance);
+	}
+
+	/**
+	* Attempts to decode a sequence of black/white lines into single
+	* digit.
+	*
+	* @param counters the counts of runs of observed black/white/black/... values
+	* @param patterns the list of patterns to compare the contents of counters to
+	* @param requireUnambiguousMatch the 'best match' must be better than all other matches
+	* @return The decoded digit index, -1 if no pattern matched
+	*/
+	template <typename Counters, typename Patterns>
+	static int DecodeDigit(const Counters& counters, const Patterns& patterns, float maxAvgVariance,
+						   float maxIndividualVariance, bool requireUnambiguousMatch = true)
+	{
+		float bestVariance = maxAvgVariance; // worst variance we'll accept
+		constexpr int INVALID_MATCH = -1;
+		int bestMatch = INVALID_MATCH;
+		for (int i = 0; i < Size(patterns); i++) {
+			float variance = PatternMatchVariance(counters, patterns[i], maxIndividualVariance);
+			if (variance < bestVariance) {
+				bestVariance = variance;
+				bestMatch = i;
+			} else if (requireUnambiguousMatch && variance == bestVariance) {
+				// if we find a second 'best match' with the same variance, we can not reliably report to have a suitable match
+				bestMatch = INVALID_MATCH;
+			}
+		}
+		return bestMatch;
+	}
+
+	/**
+	 * @brief NarrowWideThreshold calculates width thresholds to separate narrow and wide bars and spaces.
+	 *
+	 * This is useful for codes like Codabar, Code39 and ITF which distinguish between narrow and wide
+	 * bars/spaces. Where wide ones are between 2 and 3 times as wide as the narrow ones.
+	 *
+	 * @param view containing one character
+	 * @return threshold value for bars and spaces
+	 */
+	static BarAndSpaceI NarrowWideThreshold(const PatternView& view)
+	{
+		BarAndSpaceI m = {view[0], view[1]};
+		BarAndSpaceI M = m;
+		for (int i = 2; i < view.size(); ++i)
+			UpdateMinMax(m[i], M[i], view[i]);
+
+		// the max-spread check between bar/space depends on whether both have seen narrow and wide
+		int maxSpread = M[0] >= 2 * m[0] && M[1] >= 2 * m[1] ? 2 : 4;
+
+		BarAndSpaceI res;
+		for (int i = 0; i < 2; ++i) {
+			// check that
+			//  a) wide <= 4 * narrow
+			//  b) bars and spaces are not more than a factor of spread apart from each other
+			if (M[i] > 4 * (m[i] + 1) || M[i] > maxSpread * M[i + 1] || m[i] > maxSpread * (m[i + 1] + 1))
+				return {};
+			// the threshold is the average of min and max but at least 1.5 * min
+			res[i] = std::max((m[i] + M[i]) / 2, m[i] * 3 / 2);
+		}
+
+		return res;
+	}
+
+	/**
+	 * @brief ToNarrowWidePattern takes a PatternView, calculates a NarrowWideThreshold and returns int where a '0' bit
+	 * means narrow and a '1' bit means 'wide'.
+	 */
+	static int NarrowWideBitPattern(const PatternView& view)
+	{
+		const auto threshold = NarrowWideThreshold(view);
+		if (!threshold.isValid())
+			return -1;
+
+		int pattern = 0;
+		for (int i = 0; i < view.size(); ++i) {
+			if (view[i] > threshold[i] * 2)
+				return -1;
+			AppendBit(pattern, view[i] > threshold[i]);
+		}
+
+		return pattern;
+	}
+
+	/**
+	 * @brief Lookup the pattern in the table and return the character in alphabet at the same index.
+	 * @returns 0 if pattern is not found. Used to be -1 but that fails on systems where char is unsigned.
+	 */
+	template<typename INDEX, typename ALPHABET>
+	static char LookupBitPattern(int pattern, const INDEX& table, const ALPHABET& alphabet)
+	{
+		int i = IndexOf(table, pattern);
+		return i == -1 ? 0 : alphabet[i];
+	}
+
+	template<typename INDEX, typename ALPHABET>
+	static char DecodeNarrowWidePattern(const PatternView& view, const INDEX& table, const ALPHABET& alphabet)
+	{
+		return LookupBitPattern(NarrowWideBitPattern(view), table, alphabet);
+	}
+};
+
+template<typename Range>
+Barcode DecodeSingleRow(const RowReader& reader, const Range& range)
+{
+	PatternRow row;
+	GetPatternRow(range, row);
+	PatternView view(row);
+
+	std::unique_ptr<RowReader::DecodingState> state;
+	return {reader.decodePattern(0, view, state)};
+}
+
+} // OneD
+} // ZXing