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

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

@@ -0,0 +1,246 @@
+/*
+ * Copyright 2023 Antoine Mérino
+ * Copyright 2023 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODDXFilmEdgeReader.h"
+
+#include "BarcodeData.h"
+#include "SymbologyIdentifier.h"
+
+#include <cmath>
+#include <optional>
+#include <vector>
+
+namespace ZXing::OneD {
+
+namespace {
+
+// Detection is made from center outward.
+// We ensure the clock track is decoded before the data track to avoid false positives.
+// They are two version of a DX Edge codes : with and without frame number.
+// The clock track is longer if the DX code contains the frame number (more recent version)
+constexpr int CLOCK_LENGTH_FN = 31;
+constexpr int CLOCK_LENGTH_NO_FN = 23;
+
+// data track length, without the start and stop patterns
+constexpr int DATA_LENGTH_FN = 23;
+constexpr int DATA_LENGTH_NO_FN = 15;
+
+constexpr auto CLOCK_PATTERN_FN =
+	FixedPattern<25, CLOCK_LENGTH_FN>{5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3};
+constexpr auto CLOCK_PATTERN_NO_FN = FixedPattern<17, CLOCK_LENGTH_NO_FN>{5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3};
+constexpr auto DATA_START_PATTERN = FixedPattern<5, 5>{1, 1, 1, 1, 1};
+constexpr auto DATA_STOP_PATTERN = FixedPattern<3, 3>{1, 1, 1};
+
+template <int N, int SUM>
+bool IsPattern(PatternView& view, const FixedPattern<N, SUM>& pattern, float minQuietZone)
+{
+	view = view.subView(0, N);
+	return view.isValid() && IsPattern(view, pattern, view.spaceInFront(), minQuietZone);
+}
+
+bool DistIsBelowThreshold(PointI a, PointI b, PointI threshold)
+{
+	return std::abs(a.x - b.x) <= threshold.x && std::abs(a.y - b.y) <= threshold.y;
+}
+
+// DX Film Edge clock track found on 35mm films.
+struct Clock
+{
+	bool hasFrameNr = false; // Clock track (thus data track) with frame number (longer version)
+	int rowNumber = 0;
+	int xStart = 0; // Beginning of the clock track on the X-axis, in pixels
+	int xStop = 0; // End of the clock track on the X-axis, in pixels
+
+	int dataLength() const { return hasFrameNr ? DATA_LENGTH_FN : DATA_LENGTH_NO_FN; }
+
+	float moduleSize() const { return float(xStop + 1 - xStart) / (hasFrameNr ? CLOCK_LENGTH_FN : CLOCK_LENGTH_NO_FN); }
+
+	bool isCloseTo(PointI p, int x) const { return DistIsBelowThreshold(p, {x, rowNumber}, PointI(moduleSize() * PointF{0.5, 4})); }
+
+	bool isCloseToStart(int x, int y) const { return isCloseTo({x, y}, xStart); }
+	bool isCloseToStop(int x, int y) const { return isCloseTo({x, y}, xStop); }
+};
+
+struct DXFEState : public RowReader::DecodingState
+{
+	int centerRow = 0;
+	std::vector<Clock> clocks;
+
+	// see if we a clock that starts near {x, y}
+	Clock* findClock(int x, int y)
+	{
+		auto i = FindIf(clocks, [start = PointI{x, y}](auto& v) { return v.rowNumber != start.y && v.isCloseToStart(start.x, start.y); });
+		return i != clocks.end() ? &(*i) : nullptr;
+	}
+
+	// add/update clock
+	void addClock(const Clock& clock)
+	{
+		if (Clock* i = findClock(clock.xStart, clock.rowNumber))
+			*i = clock;
+		else
+			clocks.push_back(clock);
+	}
+};
+
+std::optional<Clock> CheckForClock(int rowNumber, PatternView& view)
+{
+	Clock clock;
+
+	if (IsPattern(view, CLOCK_PATTERN_FN, 0.5)) // On FN versions, the decimal number can be really close to the clock
+		clock.hasFrameNr = true;
+	else if (IsPattern(view, CLOCK_PATTERN_NO_FN, 2.0))
+		clock.hasFrameNr = false;
+	else
+		return {};
+
+	clock.rowNumber = rowNumber;
+	clock.xStart = view.pixelsInFront();
+	clock.xStop = view.pixelsTillEnd();
+
+	return clock;
+}
+
+} // namespace
+
+BarcodeData DXFilmEdgeReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const
+{
+	if (!state) {
+		state = std::make_unique<DXFEState>();
+		static_cast<DXFEState*>(state.get())->centerRow = rowNumber;
+	}
+
+	auto dxState = static_cast<DXFEState*>(state.get());
+
+	// Only consider rows below the center row of the image
+	if (!_opts.tryRotate() && rowNumber < dxState->centerRow - 1)
+		return {};
+
+	// Look for a pattern that is part of both the clock as well as the data track (omitting the first bar)
+	constexpr auto Is4x1 = [](const PatternView& view, int spaceInPixel) {
+#if 0
+		// Find min/max of 4 consecutive bars/spaces and make sure they are close together.
+		auto a = view[1], b = view[2], c = view[3], d = view[4];
+		auto m = std::min(std::min(a, b), std::min(c, d));
+		auto M = std::max(std::max(a, b), std::max(c, d));
+		return M <= m * 4 / 3 + 1 && spaceInPixel > m / 2;
+#else
+		// perform a very rough check to see if the 4 bars/spaces are close together
+		auto a = view[1], b = view[2], c = view[3], d = view[4];
+		auto diff = std::abs(a - b) + std::abs(a - c) + std::abs(a - d);
+		return diff < a && spaceInPixel > a / 2;
+#endif
+	};
+
+	// 12 is the minimum size of the data track (at least one product class bit + one parity bit)
+	next = FindLeftGuard<4>(next, 10, Is4x1);
+	if (!next.isValid())
+		return {};
+
+	// Check if the 4x1 pattern is part of a clock track
+	if (auto clock = CheckForClock(rowNumber, next)) {
+		dxState->addClock(*clock);
+		next.skipSymbol();
+		return {};
+	}
+
+	// Without at least one clock track, we stop here
+	if (dxState->clocks.empty())
+		return {};
+
+	constexpr float minDataQuietZone = 0.5;
+
+	if (!IsPattern(next, DATA_START_PATTERN, minDataQuietZone))
+		return {};
+
+	auto xStart = next.pixelsInFront();
+
+	// Only consider data tracks that are next to a clock track
+	auto clock = dxState->findClock(xStart, rowNumber);
+	if (!clock)
+		return {};
+
+	// Make sure the start pattern has the proper size (approx. 5 modules)
+	if (std::fabs(next.sum() / clock->moduleSize() - 5) > 1.0 )
+		return {};
+
+	// Skip the data start pattern (black, white, black, white, black)
+	// The first signal bar is always white: this is the
+	// separation between the start pattern and the product number
+	next.skipSymbol();
+
+	// Read the data bits
+	BitArray dataBits;
+	while (next.isValid(1) && dataBits.size() < clock->dataLength()) {
+
+		// Max no. of modules is 20 spaces (with "96-0/0")
+		if (int modules = std::lround(next[0] / clock->moduleSize()); modules >= 1 && modules <= 20)
+			// even index means we are at a bar, otherwise at a space
+			dataBits.appendBits(next.index() % 2 == 0 ? 0xFFFFFFFF : 0x0, modules);
+		else
+			return {};
+
+		next.shift(1);
+	}
+
+	// Check the data track length
+	if (dataBits.size() != clock->dataLength())
+		return {};
+
+	next = next.subView(0, DATA_STOP_PATTERN.size());
+
+	// Check there is the Stop pattern at the end of the data track
+	if (!IsRightGuard(next, DATA_STOP_PATTERN, minDataQuietZone))
+		return {};
+
+	// The following bits are always white (=false), they are separators.
+	if (dataBits.get(0) || dataBits.get(8) || (clock->hasFrameNr ? (dataBits.get(20) || dataBits.get(22)) : dataBits.get(14)))
+		return {};
+
+	// Check the parity bit
+	auto signalSum = Reduce(dataBits.begin(), dataBits.end() - 2, 0);
+	auto parityBit = *(dataBits.end() - 2);
+	if (signalSum % 2 != (int)parityBit)
+		return {};
+
+	// Compute the DX 1 number (product number)
+	auto productNumber = ToInt(dataBits, 1, 7);
+	if (!productNumber)
+		return {};
+
+	// Compute the DX 2 number (generation number)
+	auto generationNumber = ToInt(dataBits, 9, 4);
+
+	// Generate the textual representation.
+	// Eg: 115-10/11A means: DX1 = 115, DX2 = 10, Frame number = 11A
+	std::string txt;
+	txt.reserve(10);
+	txt = std::to_string(productNumber) + "-" + std::to_string(generationNumber);
+	if (clock->hasFrameNr) {
+		auto frameNr = ToInt(dataBits, 13, 6);
+		txt += "/" + std::to_string(frameNr);
+		if (dataBits.get(19))
+			txt += "A";
+	}
+
+	auto xStop = next.pixelsTillEnd();
+
+	// The found data track must end near the clock track
+	if (!clock->isCloseToStop(xStop, rowNumber))
+		return {};
+
+	// Update the clock coordinates with the latest corresponding data track
+	// This may improve signal detection for next row iterations
+	clock->xStart = xStart;
+	clock->xStop = xStop;
+
+	// ISO/IEC 15424:2008(E) specifies 'X' as 'other barcode' that can be used by the decoder manufacturer as he sees fit.
+	SymbologyIdentifier si {'X', 'F'};
+
+	return LinearBarcode(BarcodeFormat::DXFilmEdge, txt, rowNumber, xStart, xStop, si);
+}
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 Antoine Mérino
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+ * <p>Implements decoding of the DX Edge Film code format, a type of barcode found on 35mm films.</p>
+ *
+ * <p>See <a href="https://en.wikipedia.org/wiki/DX_encoding">https://en.wikipedia.org/wiki/DX_encoding</a></p>
+ */
+
+class DXFilmEdgeReader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+};
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,172 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODDataBarCommon.h"
+
+#include <cmath>
+
+namespace ZXing::OneD::DataBar {
+
+static int combins(int n, int r)
+{
+	int maxDenom;
+	int minDenom;
+	if (n - r > r) {
+		minDenom = r;
+		maxDenom = n - r;
+	} else {
+		minDenom = n - r;
+		maxDenom = r;
+	}
+	int val = 1;
+	int j   = 1;
+	for (int i = n; i > maxDenom; i--) {
+		val *= i;
+		if (j <= minDenom) {
+			val /= j;
+			j++;
+		}
+	}
+	while (j <= minDenom) {
+		val /= j;
+		j++;
+	}
+	return val;
+}
+
+int GetValue(ArrayView<int> widths, int maxWidth, bool noNarrow)
+{
+	int elements = Size(widths);
+	int n = Reduce(widths);
+	int val = 0;
+	int narrowMask = 0;
+	for (int bar = 0; bar < elements - 1; bar++) {
+		int elmWidth;
+		for (elmWidth = 1, narrowMask |= 1 << bar; elmWidth < widths[bar]; elmWidth++, narrowMask &= ~(1 << bar)) {
+			int subVal = combins(n - elmWidth - 1, elements - bar - 2);
+			if (noNarrow && (narrowMask == 0) && (n - elmWidth - (elements - bar - 1) >= elements - bar - 1)) {
+				subVal -= combins(n - elmWidth - (elements - bar), elements - bar - 2);
+			}
+			if (elements - bar - 1 > 1) {
+				int lessVal = 0;
+				for (int mxwElement = n - elmWidth - (elements - bar - 2); mxwElement > maxWidth; mxwElement--) {
+					lessVal += combins(n - elmWidth - mxwElement - 1, elements - bar - 3);
+				}
+				subVal -= lessVal * (elements - 1 - bar);
+			} else if (n - elmWidth > maxWidth) {
+				subVal--;
+			}
+			val += subVal;
+		}
+		n -= elmWidth;
+	}
+	return val;
+}
+
+using Array4F = std::array<float, 4>;
+
+bool ReadDataCharacterRaw(const PatternView& view, int numModules, bool reversed, Array4I& oddPattern,
+						  Array4I& evnPattern)
+{
+#if 1
+	auto pattern = NormalizedPatternFromE2E<8>(view, numModules, reversed);
+	OddEven<Array4I&> res = {oddPattern, evnPattern};
+
+	for (int i = 0; i < Size(pattern); ++i)
+		res[i % 2][i / 2] = pattern[i];
+
+#else
+	OddEven<Array4I&> res = {oddPattern, evnPattern};
+	OddEven<Array4F> rem;
+
+	float moduleSize = static_cast<float>(view.sum(8)) / numModules;
+	auto* iter = view.data() + reversed * 7;
+	int inc = reversed ? -1 : 1;
+
+	for (int i = 0; i < 8; ++i, iter += inc) {
+		float v = *iter / moduleSize;
+		res[i % 2][i / 2] = int(v + .5f);
+		rem[i % 2][i / 2] = v - res[i % 2][i / 2];
+	}
+#endif
+
+	// DataBarExpanded data character is 17 modules wide
+	// DataBar outer   data character is 16 modules wide
+	// DataBar inner   data character is 15 modules wide
+
+	int minSum = 4; // each data character has 4 bars and 4 spaces
+	int maxSum = numModules - minSum;
+	int oddSum = Reduce(res.odd);
+	int evnSum = Reduce(res.evn);
+
+	int sumErr = oddSum + evnSum - numModules;
+	// sum < min -> negative error; sum > max -> positive error
+	int oddSumErr = std::min(0, oddSum - (minSum + (numModules == 15))) + std::max(0, oddSum - maxSum);
+	int evnSumErr = std::min(0, evnSum - minSum) + std::max(0, evnSum - (maxSum - (numModules == 15)));
+
+	int oddParityErr = (oddSum & 1) == (numModules > 15);
+	int evnParityErr = (evnSum & 1) == (numModules < 17);
+
+#if 0
+	// the 'signal improving' strategy of trying to fix off-by-one errors in the sum or parity leads to a massively
+	// increased likelihood of false positives / misreads especially with expanded codes that are composed of many
+	// pairs. the combinatorial explosion of possible pair combinations (see FindValidSequence) results in many possible
+	// sequences with valid checksums. It can slightly lower the minimum required resolution to detect something at all
+	// but the introduced error rate is clearly not worth it.
+
+	if ((sumErr == 0 && oddParityErr != evnParityErr) || (std::abs(sumErr) == 1 && oddParityErr == evnParityErr) ||
+		std::abs(sumErr) > 1 || std::abs(oddSumErr) > 1 || std::abs(evnSumErr) > 1)
+		return {};
+
+	if (sumErr == -1) {
+		oddParityErr *= -1;
+		evnParityErr *= -1;
+	} else if (sumErr == 0 && oddParityErr != 0) {
+		// both parity errors are 1 -> flip one of them
+		(oddSum < evnSum ? oddParityErr : evnParityErr) *= -1;
+	}
+
+	// check if parity and sum errors have opposite signs
+	if (oddParityErr * oddSumErr < 0 || evnParityErr * evnSumErr < 0)
+		return {};
+
+	// apparently the spec calls numbers at even indices 'odd'!?!
+	constexpr int odd = 0, evn = 1;
+	for (int i : {odd, evn}) {
+		int err = i == odd ? (oddSumErr | oddParityErr) : (evnSumErr | evnParityErr);
+		int mi = err < 0 ? std::max_element(rem[i].begin(), rem[i].end()) - rem[i].begin()
+						 : std::min_element(rem[i].begin(), rem[i].end()) - rem[i].begin();
+		res[i][mi] -= err;
+	}
+
+	return true;
+#else
+	// instead, we ignore any character that is not exactly fitting the requirements
+	return !(sumErr || oddSumErr || evnSumErr || oddParityErr || evnParityErr);
+#endif
+}
+
+static bool IsStacked(const Pair& first, const Pair& last)
+{
+	// check if we see two halfes that are far away from each other in y or overlapping in x
+	return std::abs(first.y - last.y) > (first.xStop - first.xStart) || last.xStart < (first.xStart + first.xStop) / 2;
+}
+
+Position EstimatePosition(const Pair& first, const Pair& last)
+{
+	if (!IsStacked(first, last))
+		return Line((first.y + last.y) / 2, first.xStart, last.xStop);
+	else
+		return Position{{first.xStart, first.y}, {first.xStop, first.y}, {last.xStop, last.y}, {last.xStart, last.y}};
+}
+
+int EstimateLineCount(const Pair& first, const Pair& last)
+{
+	// see ODReader.cpp 'lineCount++' and Barcode::operator==() for the -2 here
+	// TODO: this is a bit of a hack... implement a proper Pair clustering
+	return std::max(0, std::min(first.count, last.count) - 2) + IsStacked(first, last);
+}
+
+} // namespace ZXing::OneD::DataBar

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

@@ -0,0 +1,204 @@
+/*
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+#include "Range.h"
+#include "Pattern.h"
+
+#include <array>
+#include <cmath>
+#include <numeric>
+
+namespace ZXing::OneD::DataBar {
+
+inline bool IsFinder(int a, int b, int c, int d, int e)
+{
+	//  a,b,c,d,e, g | sum(a..e) = 15
+	//  ------------
+	//  1,1,2
+	//	| | |,1,1, 1
+	//	3,8,9
+
+	// use only pairs of bar+space to limit effect of poor threshold:
+	// b+c can be 10, 11 or 12 modules, d+e is always 2
+	int w = 2 * (b + c), n = d + e;
+	// the offsets (5 and 2) are there to reduce quantization effects for small module sizes
+	// TODO: review after switch to sub-pixel bar width calculation
+	bool x = (w + 5 > 9 * n) &&
+			 (w - 5 < 13 * n) &&
+//			 (b < 5 + 9 * d) &&
+//			 (c < 5 + 10 * e) &&
+			 (a < 2 + 4 * e) &&
+			 (4 * a > n);
+#if defined(PRINT_DEBUG) && 0
+	printf("[");
+	for (bool v :
+		 {w + 5 > 9 * n,
+		  w - 5 < 13 * n,
+//		  b < 5 + 9 * d,
+//		  c < 5 + 10 * e,
+		  a < 2 + 4 * e,
+			4 * a > n})
+		printf(" %d", v);
+	printf("]"); fflush(stdout);
+#endif
+	return x;
+};
+
+inline PatternView Finder(const PatternView& view)
+{
+	return view.subView(8, 5);
+}
+
+inline PatternView LeftChar(const PatternView& view)
+{
+	return view.subView(0, 8);
+}
+
+inline PatternView RightChar(const PatternView& view)
+{
+	return view.subView(13, 8);
+}
+
+inline float ModSizeFinder(const PatternView& view)
+{
+	return Finder(view).sum() / 15.f;
+}
+
+inline bool IsGuard(int a, int b)
+{
+	//	printf(" (%d, %d)", a, b);
+	return a > b * 3 / 4 - 2 && a < b * 5 / 4 + 2;
+}
+
+inline bool IsCharacter(const PatternView& view, int modules, float modSizeRef)
+{
+	float err = std::abs(float(view.sum()) / modules / modSizeRef - 1);
+	return err < 0.1f;
+}
+
+struct Character
+{
+	int value = -1, checksum = 0;
+
+	operator bool() const noexcept { return value != -1; }
+	bool operator==(const Character& o) const noexcept { return value == o.value && checksum == o.checksum; }
+	bool operator!=(const Character& o) const { return !(*this == o); }
+};
+
+struct Pair
+{
+	Character left, right;
+	int finder = 0, xStart = -1, xStop = 1, y = -1, count = 1;
+
+	operator bool() const noexcept { return finder != 0; }
+	bool operator==(const Pair& o) const noexcept { return finder == o.finder && left == o.left && right == o.right; }
+	bool operator!=(const Pair& o) const noexcept { return !(*this == o); }
+	int center() const { return std::midpoint(xStart, xStop); }
+};
+
+struct PairHash
+{
+	std::size_t operator()(const Pair& p) const noexcept
+	{
+		return p.left.value ^ p.left.checksum ^ p.right.value ^ p.right.checksum ^ p.finder;
+	}
+};
+
+constexpr int FULL_PAIR_SIZE = 8 + 5 + 8;
+constexpr int HALF_PAIR_SIZE = 8 + 5 + 2; // half has to be followed by a guard pattern
+
+template<size_t E2E_LEN, size_t N>
+int ParseFinderPattern(const PatternView& view, bool reversed, const std::array<Pattern<E2E_LEN>, N>& e2ePatterns)
+{
+	static_assert(E2E_LEN == 3);
+	const auto e2e = NormalizedE2EPattern<5, E2E_LEN>(view, 15, reversed);
+
+	int best_i = -1, best_e = 3;
+	for (int i = 0; i < Size(e2ePatterns); ++i) {
+		int e = 0;
+		for (int j = 0; j < 3; ++j)
+			e += std::abs(static_cast<int>(e2ePatterns[i][j]) - e2e[j]);
+		if (e < best_e) {
+			best_e = e;
+			best_i = i;
+		}
+	}
+	int i = best_e <= 1 ? 1 + best_i : 0;
+	return reversed ? -i : i;
+}
+
+template <typename T>
+struct OddEven
+{
+	T odd = {}, evn = {};
+	T& operator[](int i) { return i & 1 ? evn : odd; }
+};
+
+using Array4I = std::array<int, 4>;
+
+// elements() determines the element widths of an (n,k) character.
+// for DataBar:         LEN=8, mods=15/16
+// for DataBarExpanded: LEN=8, mods=17
+// for DataBarLimited:  LEN=14, mods=26/18
+template <int LEN>
+std::array<int, LEN> NormalizedPatternFromE2E(const PatternView& view, int mods, bool reversed = false)
+{
+	// To disambiguate the edge-to-edge measurements, it is defined that either the odd or the even-numbered
+	// elements contain at least 1 element that is 1 module wide. (Note: even-numbered elements - 2nd, 4th, 6th, etc., have odd
+	// indexes).
+	// The reference decoding algorithm in Annex G of ISO/IEC 24724:2011 is distinguishing between DataBarExpanded on one side
+	// and all other variants on the other. That seems to contradict the rest of the specification. For details see
+	// https://github.com/zxing-cpp/zxing-cpp/issues/935.
+	// Turns out the true distinction is to be made as follows:
+	//   min-even-is-one: DataBarLimited, DataBar outside character
+	//   min-odd-is-one:  DataBarExpanded, DataBar inside character
+	bool minOddIsOne = mods == 15 || mods == 17;
+	const auto e2e = NormalizedE2EPattern<LEN, LEN - 2>(view, mods, reversed);
+	std::array<int, LEN> widths;
+
+	// derive element widths from normalized edge-to-similar-edge measurements
+	int barSum = widths[0] = minOddIsOne ? 8 : 1; // first assume 1st bar is 1 / 8
+	for (int i = 0; i < Size(e2e); i++) {
+		widths[i + 1] = e2e[i] - widths[i];
+		barSum += widths[i + 1];
+	}
+	widths.back() = mods - barSum; // last even element makes mods modules
+
+	// int minEven = widths[1];
+	// for (int i = 3; i < Size(widths); i += 2)
+	// 	minEven = std::min(minEven, widths[i]);
+	OddEven<int> min = {widths[0], widths[1]};
+	for (int i = 2; i < Size(widths); i++)
+		min[i] = std::min(min[i], widths[i]);
+
+	if (minOddIsOne && min[0] > 1) {
+		// minimum odd width is too big, readjust so minimum odd is 1
+		for (int i = 0; i < Size(widths); i += 2) {
+			widths[i] -= min[0] - 1;
+			widths[i + 1] += min[0] - 1;
+		}
+	} else if (!minOddIsOne && min[1] > 1) {
+		// minimum even width is too big, readjust so minimum even is 1
+		for (int i = 0; i < Size(widths); i += 2) {
+			widths[i] += min[1] - 1;
+			widths[i + 1] -= min[1] - 1;
+		}
+	}
+
+	return widths;
+}
+
+bool ReadDataCharacterRaw(const PatternView& view, int numModules, bool reversed, Array4I& oddPattern,
+						  Array4I& evnPattern);
+
+int GetValue(ArrayView<int> widths, int maxWidth, bool noNarrow);
+
+Position EstimatePosition(const Pair& first, const Pair& last);
+int EstimateLineCount(const Pair& first, const Pair& last);
+
+} // namespace ZXing::OneD::DataBar