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

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

@@ -0,0 +1,253 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "GTIN.h"
+
+#include <algorithm>
+#ifdef __cpp_lib_format // not available on gcc 12
+#include <format>
+#endif
+#include <iomanip>
+#include <iterator>
+#include <string>
+
+namespace ZXing::GTIN {
+
+struct CountryId
+{
+	uint16_t first;
+	uint16_t last;
+	const char id[3];
+};
+
+bool operator<(const CountryId& lhs, const CountryId& rhs)
+{
+	return lhs.last < rhs.last;
+}
+
+// https://www.gs1.org/standards/id-keys/company-prefix (as of 7 Feb 2022)
+// and https://en.wikipedia.org/wiki/List_of_GS1_country_codes
+static const CountryId COUNTRIES[] = {
+	// clang-format off
+	{1, 19, "US"},
+	{30, 39, "US"},
+	{60, 99, "US"}, // Note 99 coupon identification
+	{100, 139, "US"},
+	{300, 379, "FR"}, // France (and Monaco according to Wikipedia)
+	{380, 380, "BG"}, // Bulgaria
+	{383, 383, "SI"}, // Slovenia
+	{385, 385, "HR"}, // Croatia
+	{387, 387, "BA"}, // Bosnia and Herzegovina
+	{389, 389, "ME"}, // Montenegro
+	//{390, 390, "XK"}, // (Kosovo according to Wikipedia, unsourced)
+	{400, 440, "DE"}, // Germany
+	{450, 459, "JP"}, // Japan
+	{460, 469, "RU"}, // Russia
+	{470, 470, "KG"}, // Kyrgyzstan
+	{471, 471, "TW"}, // Taiwan
+	{474, 474, "EE"}, // Estonia
+	{475, 475, "LV"}, // Latvia
+	{476, 476, "AZ"}, // Azerbaijan
+	{477, 477, "LT"}, // Lithuania
+	{478, 478, "UZ"}, // Uzbekistan
+	{479, 479, "LK"}, // Sri Lanka
+	{480, 480, "PH"}, // Philippines
+	{481, 481, "BY"}, // Belarus
+	{482, 482, "UA"}, // Ukraine
+	{483, 483, "TM"}, // Turkmenistan
+	{484, 484, "MD"}, // Moldova
+	{485, 485, "AM"}, // Armenia
+	{486, 486, "GE"}, // Georgia
+	{487, 487, "KZ"}, // Kazakhstan
+	{488, 488, "TJ"}, // Tajikistan
+	{489, 489, "HK"}, // Hong Kong
+	{490, 499, "JP"}, // Japan
+	{500, 509, "GB"}, // UK
+	{520, 521, "GR"}, // Greece
+	{528, 528, "LB"}, // Lebanon
+	{529, 529, "CY"}, // Cyprus
+	{530, 530, "AL"}, // Albania
+	{531, 531, "MK"}, // North Macedonia
+	{535, 535, "MT"}, // Malta
+	{539, 539, "IE"}, // Ireland
+	{540, 549, "BE"}, // Belgium & Luxembourg
+	{560, 560, "PT"}, // Portugal
+	{569, 569, "IS"}, // Iceland
+	{570, 579, "DK"}, // Denmark (and Faroe Islands and Greenland according to Wikipedia)
+	{590, 590, "PL"}, // Poland
+	{594, 594, "RO"}, // Romania
+	{599, 599, "HU"}, // Hungary
+	{600, 601, "ZA"}, // South Africa
+	{603, 603, "GH"}, // Ghana
+	{604, 604, "SN"}, // Senegal
+	{608, 608, "BH"}, // Bahrain
+	{609, 609, "MU"}, // Mauritius
+	{611, 611, "MA"}, // Morocco
+	{613, 613, "DZ"}, // Algeria
+	{615, 615, "NG"}, // Nigeria
+	{616, 616, "KE"}, // Kenya
+	{617, 617, "CM"}, // Cameroon
+	{618, 618, "CI"}, // Côte d'Ivoire
+	{619, 619, "TN"}, // Tunisia
+	{620, 620, "TZ"}, // Tanzania
+	{621, 621, "SY"}, // Syria
+	{622, 622, "EG"}, // Egypt
+	{623, 623, "BN"}, // Brunei
+	{624, 624, "LY"}, // Libya
+	{625, 625, "JO"}, // Jordan
+	{626, 626, "IR"}, // Iran
+	{627, 627, "KW"}, // Kuwait
+	{628, 628, "SA"}, // Saudi Arabia
+	{629, 629, "AE"}, // United Arab Emirates
+	{630, 630, "QA"}, // Qatar
+	{631, 631, "NA"}, // Namibia
+	{640, 649, "FI"}, // Finland
+	{690, 699, "CN"}, // China
+	{700, 709, "NO"}, // Norway
+	{729, 729, "IL"}, // Israel
+	{730, 739, "SE"}, // Sweden
+	{740, 740, "GT"}, // Guatemala
+	{741, 741, "SV"}, // El Salvador
+	{742, 742, "HN"}, // Honduras
+	{743, 743, "NI"}, // Nicaragua
+	{744, 744, "CR"}, // Costa Rica
+	{745, 745, "PA"}, // Panama
+	{746, 746, "DO"}, // Dominican Republic
+	{750, 750, "MX"}, // Mexico
+	{754, 755, "CA"}, // Canada
+	{759, 759, "VE"}, // Venezuela
+	{760, 769, "CH"}, // Switzerland (and Liechtenstein according to Wikipedia)
+	{770, 771, "CO"}, // Colombia
+	{773, 773, "UY"}, // Uruguay
+	{775, 775, "PE"}, // Peru
+	{777, 777, "BO"}, // Bolivia
+	{778, 779, "AR"}, // Argentina
+	{780, 780, "CL"}, // Chile
+	{784, 784, "PY"}, // Paraguay
+	{786, 786, "EC"}, // Ecuador
+	{789, 790, "BR"}, // Brazil
+	{800, 839, "IT"}, // Italy (and San Marino and Vatican City according to Wikipedia)
+	{840, 849, "ES"}, // Spain (and Andorra according to Wikipedia)
+	{850, 850, "CU"}, // Cuba
+	{858, 858, "SK"}, // Slovakia
+	{859, 859, "CZ"}, // Czechia
+	{860, 860, "RS"}, // Serbia
+	{865, 865, "MN"}, // Mongolia
+	{867, 867, "KP"}, // North Korea
+	{868, 869, "TR"}, // Turkey
+	{870, 879, "NL"}, // Netherlands
+	{880, 880, "KR"}, // South Korea
+	{883, 883, "MM"}, // Myanmar
+	{884, 884, "KH"}, // Cambodia
+	{885, 885, "TH"}, // Thailand
+	{888, 888, "SG"}, // Singapore
+	{890, 890, "IN"}, // India
+	{893, 893, "VN"}, // Vietnam
+	{896, 896, "PK"}, // Pakistan
+	{899, 899, "ID"}, // Indonesia
+	{900, 919, "AT"}, // Austria
+	{930, 939, "AU"}, // Australia
+	{940, 949, "NZ"}, // New Zealand
+	{955, 955, "MY"}, // Malaysia
+	{958, 958, "MO"}, // Macao
+	//{960, 961, "GB"}, // Global Office - assigned to GS1 UK for GTIN-8 allocations (also 9620-9624999)
+	// clang-format on
+};
+
+std::string LookupCountryIdentifier(std::string_view GTIN, const BarcodeFormat format)
+{
+	// Ignore add-on if any
+	const auto space = GTIN.find(' ');
+	const std::string::size_type size = space != std::string::npos ? space : GTIN.size();
+
+	if (size != 14 && size != 13 && size != 12 && size != 8)
+		return {};
+
+	// GTIN-14 leading packaging level indicator
+	const int first = size == 14 ? 1 : 0;
+	// UPC-A/E implicit leading 0
+	const int implicitZero = size == 12 || (size == 8 && format != BarcodeFormat::EAN8) ? 1 : 0;
+
+	if (size != 8 || format != BarcodeFormat::EAN8) { // Assuming following doesn't apply to EAN-8
+		// 0000000 Restricted Circulation Numbers; 0000001-0000099 unused to avoid collision with GTIN-8
+		int prefix = FromString<int>(GTIN.substr(first, 7 - implicitZero));
+		if (prefix >= 0 && prefix <= 99)
+			return {};
+
+		// 00001-00009 US
+		prefix = FromString<int>(GTIN.substr(first, 5 - implicitZero));
+		if (prefix >= 1 && prefix <= 9)
+			return "US";
+
+		// 0001-0009 US
+		prefix = FromString<int>(GTIN.substr(first, 4 - implicitZero));
+		if (prefix >= 1 && prefix <= 9)
+			return "US";
+	}
+
+	const int prefix = FromString<int>(GTIN.substr(first, 3 - implicitZero));
+
+	// Special case EAN-8 for prefix < 100 (GS1 General Specifications Figure 1.4.3-1)
+	if (size == 8 && format == BarcodeFormat::EAN8 && prefix <= 99) // Restricted Circulation Numbers
+		return {};
+
+	const auto it = std::lower_bound(std::begin(COUNTRIES), std::end(COUNTRIES), CountryId{0, narrow_cast<uint16_t>(prefix), ""});
+
+	return it != std::end(COUNTRIES) && prefix >= it->first && prefix <= it->last ? it->id : std::string();
+}
+
+std::string EanAddOn(const Barcode& barcode)
+{
+	if (barcode.symbologyIdentifier() != "]E3")
+		return {};
+	return barcode.text().substr(barcode.format() == BarcodeFormat::EAN8 ? 8 : 13);
+}
+
+std::string IssueNr(const std::string& ean2AddOn)
+{
+	if (ean2AddOn.size() != 2)
+		return {};
+
+	return std::to_string(std::stoi(ean2AddOn));
+}
+
+std::string Price(const std::string& ean5AddOn)
+{
+	if (ean5AddOn.size() != 5)
+		return {};
+
+	std::string currency;
+	switch (ean5AddOn.front()) {
+	case '0': [[fallthrough]];
+	case '1': currency = "GBP £"; break; // UK
+	case '3': currency = "AUD $"; break; // AUS
+	case '4': currency = "NZD $"; break; // NZ
+	case '5': currency = "USD $"; break; // US
+	case '6': currency = "CAD $"; break; // CA
+	case '9':
+		// Reference: http://www.jollytech.com
+		if (ean5AddOn == "90000") // No suggested retail price
+			return {};
+		if (ean5AddOn == "99991") // Complementary
+			return "0.00";
+		if (ean5AddOn == "99990")
+			return "Used";
+
+		// Otherwise... unknown currency?
+		currency = "";
+		break;
+	default: currency = ""; break;
+	}
+
+	int rawAmount = std::stoi(ean5AddOn.substr(1));
+#if !defined(__cpp_lib_to_chars) || !defined(__cpp_lib_format) // not available on older macOS / gcc 12
+	return currency + std::to_string(rawAmount / 100) + '.' + std::to_string(rawAmount % 100);
+#else
+	return std::format("{}{:.2f}", currency, float(rawAmount) / 100);
+#endif
+}
+
+} // namespace ZXing::GTIN

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

@@ -0,0 +1,58 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Barcode.h"
+#include "BarcodeFormat.h"
+
+#ifdef ZXING_INTERNAL
+#include "ZXAlgorithms.h"
+#endif
+
+#include <string>
+#include <string_view>
+
+namespace ZXing::GTIN {
+
+#ifdef ZXING_INTERNAL
+template <typename T>
+T ComputeCheckDigit(const std::basic_string<T>& digits, bool skipTail = false)
+{
+	int sum = 0, N = Size(digits) - skipTail;
+	for (int i = N - 1; i >= 0; i -= 2)
+		sum += digits[i] - '0';
+	sum *= 3;
+	for (int i = N - 2; i >= 0; i -= 2)
+		sum += digits[i] - '0';
+	return ToDigit<T>((10 - (sum % 10)) % 10);
+}
+
+template <typename T>
+bool IsCheckDigitValid(const std::basic_string<T>& s)
+{
+	return ComputeCheckDigit(s, true) == s.back();
+}
+#endif
+
+/**
+ * Evaluate the prefix of the GTIN to estimate the country of origin. See
+ * <a href="https://www.gs1.org/standards/id-keys/company-prefix">
+ * https://www.gs1.org/standards/id-keys/company-prefix</a> and
+ * <a href="https://en.wikipedia.org/wiki/List_of_GS1_country_codes">
+ * https://en.wikipedia.org/wiki/List_of_GS1_country_codes</a>.
+ *
+ * `format` required for EAN-8 (UPC-E assumed if not given)
+ */
+std::string LookupCountryIdentifier(std::string_view GTIN, BarcodeFormat format = BarcodeFormat::None);
+
+std::string EanAddOn(const Barcode& barcode);
+
+std::string IssueNr(const std::string& ean2AddOn);
+std::string Price(const std::string& ean5AddOn);
+
+} // namespace ZXing::GTIN

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

@@ -0,0 +1,197 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "GlobalHistogramBinarizer.h"
+
+#include "BitMatrix.h"
+#include "Pattern.h"
+#include "ZXConfig.h"
+
+#include <algorithm>
+#include <array>
+#include <utility>
+
+namespace ZXing {
+
+static constexpr int LUMINANCE_BITS = 5;
+static constexpr int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+static constexpr int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+
+using Histogram = std::array<uint16_t, LUMINANCE_BUCKETS>;
+
+GlobalHistogramBinarizer::GlobalHistogramBinarizer(const ImageView& buffer) : BinaryBitmap(buffer) {}
+
+GlobalHistogramBinarizer::~GlobalHistogramBinarizer() = default;
+
+using ImageLineView = Range<StrideIter<const uint8_t*>>;
+
+inline ImageLineView RowView(const ImageView& iv, int row)
+{
+	return {{iv.data(0, row), iv.pixStride()}, {iv.data(iv.width(), row), iv.pixStride()}};
+}
+
+template <typename I>
+static void ThresholdSharpened(Range<I> in, int threshold, std::vector<uint8_t>& out)
+{
+	out.resize(in.size());
+	auto i = in.begin();
+	auto o = out.begin();
+
+	*o++ = (*i++ <= threshold) * BitMatrix::SET_V;
+	for (auto end = in.end() - 1; i != end; ++i)
+		*o++ = ((-i[-1] + (int(i[0]) * 4) - i[1]) / 2 <= threshold) * BitMatrix::SET_V;
+	*o++ = (*i++ <= threshold) * BitMatrix::SET_V;
+}
+
+template <typename I>
+static auto GenHistogram(Range<I> line)
+{
+	// This code causes about 20% of the total runtime on an AVX2 system for a EAN13 search on Lum input data.
+	// Trying to increase the performance by performing 2 or 4 "parallel" histograms helped nothing on the Intel
+	// system but was able to make the total runtime for that use case go down about 10% on an ARM M4.
+#if 1
+	Histogram res0 = {}, res1 = {}, res2 = {}, res3 = {};
+
+	auto src = line.begin();
+	const auto end = line.end();
+
+	while (end - src >= 4) {
+		res0[*src++ >> LUMINANCE_SHIFT]++;
+		res1[*src++ >> LUMINANCE_SHIFT]++;
+		res2[*src++ >> LUMINANCE_SHIFT]++;
+		res3[*src++ >> LUMINANCE_SHIFT]++;
+	}
+
+	Histogram res = {};
+	for (int i = 0; i < LUMINANCE_BUCKETS; ++i)
+		res[i] = res0[i] + res1[i] + res2[i] + res3[i];
+
+	while (src != end)
+		res[*src++ >> LUMINANCE_SHIFT]++;
+
+	return res;
+#else
+	Histogram res = {};
+	for (auto pix : line)
+		res[pix >> LUMINANCE_SHIFT]++;
+	return res;
+#endif
+}
+
+// Return -1 on error
+static int EstimateBlackPoint(const Histogram& buckets)
+{
+	// Find the tallest peak in the histogram.
+	auto firstPeakPos = std::max_element(buckets.begin(), buckets.end());
+	int firstPeak = narrow_cast<int>(firstPeakPos - buckets.begin());
+	int firstPeakSize = *firstPeakPos;
+	int maxBucketCount = firstPeakSize;
+
+	// Find the second-tallest peak which is somewhat far from the tallest peak.
+	int secondPeak = 0;
+	int secondPeakScore = 0;
+	for (int x = 0; x < Size(buckets); x++) {
+		int distanceToBiggest = x - firstPeak;
+		// Encourage more distant second peaks by multiplying by square of distance.
+		int score = buckets[x] * distanceToBiggest * distanceToBiggest;
+		if (score > secondPeakScore) {
+			secondPeak = x;
+			secondPeakScore = score;
+		}
+	}
+
+	// Make sure firstPeak corresponds to the black peak.
+	if (firstPeak > secondPeak) {
+		std::swap(firstPeak, secondPeak);
+	}
+
+	// If there is too little contrast in the image to pick a meaningful black point, throw rather
+	// than waste time trying to decode the image, and risk false positives.
+	if (secondPeak - firstPeak <= LUMINANCE_BUCKETS / 16) {
+		return -1;
+	}
+
+	// Find a valley between them that is low and closer to the white peak.
+	int bestValley = secondPeak - 1;
+	int bestValleyScore = -1;
+	for (int x = secondPeak - 1; x > firstPeak; x--) {
+		int fromFirst = x - firstPeak;
+		int score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);
+		if (score > bestValleyScore) {
+			bestValley = x;
+			bestValleyScore = score;
+		}
+	}
+
+	return bestValley << LUMINANCE_SHIFT;
+}
+
+bool GlobalHistogramBinarizer::getPatternRow(int row, int rotation, PatternRow& res) const
+{
+	auto buffer = _buffer.rotated(rotation);
+	auto lineView = RowView(buffer, row);
+
+	if (buffer.width() < 3)
+		return false; // special casing the code below for a width < 3 makes no sense
+
+#if defined(__AVX__) || defined(__ARM_NEON)
+	// If we are extracting a column (instead of a row), we run into cache misses on every pixel access both
+	// during the histogram calculation and during the sharpen+threshold operation. Additionally, if we
+	// perform the ThresholdSharpened function on pixStride==1 data, the auto-vectorizer makes that part
+	// 8x faster on an AVX2 cpu which easily recovers the extra cost that we pay for the copying.
+	ZX_THREAD_LOCAL std::vector<uint8_t> line;
+	if (std::abs(buffer.pixStride()) > 4) {
+		line.resize(lineView.size());
+		std::copy(lineView.begin(), lineView.end(), line.begin());
+		lineView = {{line.data(), 1}, {line.data() + line.size(), 1}};
+	}
+#endif
+
+	auto packedLineView =
+		lineView.begin().stride == 1 ? Range(lineView.begin().pos, lineView.end().pos) : Range<const uint8_t*>(nullptr, nullptr);
+	auto histogram = packedLineView ? GenHistogram(packedLineView) : GenHistogram(lineView);
+	auto threshold = EstimateBlackPoint(histogram) - 1;
+	if (threshold <= 0)
+		return false;
+
+	ZX_THREAD_LOCAL std::vector<uint8_t> binarized;
+	// the optimizer can generate a specialized version for pixStride==1 (non-rotated input) that is about 8x faster on AVX2 hardware
+	if (packedLineView)
+		ThresholdSharpened(packedLineView, threshold, binarized);
+	else
+		ThresholdSharpened(lineView, threshold, binarized);
+	GetPatternRow(Range(binarized), res);
+
+	return true;
+}
+
+// Does not sharpen the data, as this call is intended to only be used by 2D Readers.
+std::shared_ptr<const BitMatrix>
+GlobalHistogramBinarizer::getBlackMatrix() const
+{
+	// Quickly calculates the histogram by sampling four rows from the image. This proved to be
+	// more robust on the blackbox tests than sampling a diagonal as we used to do.
+	Histogram localBuckets = {};
+	{
+		for (int y = 1; y < 5; y++) {
+			int row = height() * y / 5;
+			const uint8_t* luminances = _buffer.data(0, row);
+			int right = (width() * 4) / 5;
+			for (int x = width() / 5; x < right; x++)
+				localBuckets[luminances[x] >> LUMINANCE_SHIFT]++;
+		}
+	}
+
+	int blackPoint = EstimateBlackPoint(localBuckets);
+	if (blackPoint <= 0)
+		return {};
+
+
+
+	return std::make_shared<const BitMatrix>(binarize(blackPoint));
+}
+
+} // ZXing

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

@@ -0,0 +1,34 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BinaryBitmap.h"
+
+namespace ZXing {
+
+/**
+* This Binarizer implementation uses the old ZXing global histogram approach. It is suitable
+* for low-end mobile devices which don't have enough CPU or memory to use a local thresholding
+* algorithm. However, because it picks a global black point, it cannot handle difficult shadows
+* and gradients.
+*
+* Faster mobile devices and all desktop applications should probably use HybridBinarizer instead.
+*
+* @author dswitkin@google.com (Daniel Switkin)
+* @author Sean Owen
+*/
+class GlobalHistogramBinarizer : public BinaryBitmap
+{
+public:
+	explicit GlobalHistogramBinarizer(const ImageView& buffer);
+	~GlobalHistogramBinarizer() override;
+
+	bool getPatternRow(int row, int rotation, PatternRow &res) const override;
+	std::shared_ptr<const BitMatrix> getBlackMatrix() const override;
+};
+
+} // ZXing

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

@@ -0,0 +1,124 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "GridSampler.h"
+
+#ifdef PRINT_DEBUG
+#include "LogMatrix.h"
+#include "BitMatrixIO.h"
+#endif
+
+namespace ZXing {
+
+#ifdef PRINT_DEBUG
+LogMatrix log;
+#endif
+
+DetectorResult SampleGrid(const BitMatrix& image, int width, int height, const PerspectiveTransform& mod2Pix)
+{
+	return SampleGrid(image, width, height, {ROI{0, width, 0, height, mod2Pix}});
+}
+
+DetectorResult SampleGrid(const BitMatrix& image, int width, int height, const ROIs& rois)
+{
+#ifdef PRINT_DEBUG
+	LogMatrix log;
+	static int i = 0;
+	LogMatrixWriter lmw(log, image, 5, "grid" + std::to_string(i++) + ".pnm");
+#endif
+	if (width <= 0 || height <= 0)
+		return {};
+
+	for (auto&& [x0, x1, y0, y1, mod2Pix] : rois) {
+		// Precheck the corners of every roi to bail out early if the grid is "obviously" not completely inside the image
+		auto isInside = [&mod2Pix = mod2Pix, &image](int x, int y) { return image.isIn(mod2Pix(centered(PointI(x, y)))); };
+		if (!mod2Pix.isValid() || !isInside(x0, y0) || !isInside(x1 - 1, y0) || !isInside(x1 - 1, y1 - 1) || !isInside(x0, y1 - 1))
+			return {};
+	}
+
+	BitMatrix res(width, height);
+	for (auto&& [x0, x1, y0, y1, mod2Pix] : rois) {
+		for (int y = y0; y < y1; ++y)
+			for (int x = x0; x < x1; ++x) {
+				auto p = mod2Pix(centered(PointI{x, y}));
+				// Due to a "numerical instability" in the PerspectiveTransform generation/application it has been observed
+				// that even though all boundary grid points get projected inside the image, it can still happen that an
+				// inner grid points is not. See #563. A true perspective transformation cannot have this property.
+				// The following check takes 100% care of the issue and turned out to be less of a performance impact than feared.
+				// TODO: Check some mathematical/numercial property of mod2Pix to determine if it is a perspective transformation.
+				if (!image.isIn(p))
+					return {};
+
+#ifdef PRINT_DEBUG
+				log(p, 3);
+#endif
+#if 0
+				int sum = 0;
+				for (int dy = -1; dy <= 1; ++dy)
+					for (int dx = -1; dx <= 1; ++dx)
+						sum += image.get(p + PointF(dx, dy));
+				if (sum >= 5)
+#else
+				if (image.get(p))
+#endif
+					res.set(x, y);
+			}
+	}
+
+#ifdef PRINT_DEBUG
+	printf("width: %d, height: %d\n", width, height);
+//	printf("%s", ToString(res).c_str());
+#endif
+
+	auto projectCorner = [&](PointI p) {
+		for (auto&& [x0, x1, y0, y1, mod2Pix] : rois)
+			if (x0 <= p.x && p.x <= x1 && y0 <= p.y && p.y <= y1)
+				return PointI(mod2Pix(PointF(p)) + PointF(0.5, 0.5));
+
+		return PointI();
+	};
+
+	return {std::move(res),
+			{projectCorner({0, 0}), projectCorner({width, 0}), projectCorner({width, height}), projectCorner({0, height})}};
+}
+
+DetectorResult SampleGrid(const BitMatrix& image, int width, int height, const PerspectiveTransform& mod2Pix,
+						  Matrix<std::optional<PointF>>&& apP, const std::vector<int>& apMX, const std::vector<int>& apMY)
+{
+	const int W = Size(apMX) - 1, H = Size(apMY) - 1;
+
+	// go over the set of alignment patters and fill any remaining gaps by a projection based on the fallback
+	// mod2Pix projection. This works if the symbol is flat, which is a reasonable fall-back assumption.
+	for (int y = 0; y <= H; ++y)
+		for (int x = 0; x <= W; ++x) {
+			if (apP(x, y)) {
+#ifdef PRINT_DEBUG
+				log(*apP(x, y), 2);
+#endif
+			} else {
+#ifdef PRINT_DEBUG
+				printf("locate failed at %dx%d\n", x, y);
+#endif
+				// project the alignment pattern at module coordinates x/y to pixel coordinate based on current mod2Pix
+				apP.set(x, y, mod2Pix(centered(PointI(apMX[x], apMY[y]))));
+			}
+		}
+
+	// assemble a list of region-of-interests based on the found alignment pattern pixel positions
+	ROIs rois;
+	for (int y = 0; y < H; ++y)
+		for (int x = 0; x < W; ++x) {
+			int x0 = apMX[x], x1 = apMX[x + 1], y0 = apMY[y], y1 = apMY[y + 1];
+			rois.push_back({x == 0 ? 0 : x0, (x == W - 1) ? width : x1, (y == 0) ? 0 : y0, (y == H - 1) ? height : y1,
+							PerspectiveTransform{Rectangle(x0, x1, y0, y1, 0.5),
+												 {*apP(x, y), *apP(x + 1, y), *apP(x + 1, y + 1), *apP(x, y + 1)}}});
+		}
+
+	return SampleGrid(image, width, height, rois);
+}
+
+} // ZXing