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

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

@@ -0,0 +1,136 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODCodabarWriter.h"
+
+#include "ODWriterHelper.h"
+#include "Utf.h"
+#include "ZXAlgorithms.h"
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+
+namespace ZXing::OneD {
+
+static constexpr std::wstring_view START_END_CHARS =  L"ABCD";
+static constexpr std::wstring_view ALT_START_END_CHARS = L"TN*E";
+static constexpr std::wstring_view CHARS_WHICH_ARE_TEN_LENGTH_EACH_AFTER_DECODED = L"/:+.";
+static constexpr wchar_t DEFAULT_GUARD = START_END_CHARS[0];
+
+static constexpr std::wstring_view ALPHABET = L"0123456789-$:/.+ABCD";
+
+static constexpr int WIDE_TO_NARROW_BAR_RATIO = 2; //TODO: spec says 2.25 to 3 is the valid range. So this is technically illformed.
+
+/**
+* These represent the encodings of characters, as patterns of wide and narrow bars. The 7 least-significant bits of
+* each int correspond to the pattern of wide and narrow, with 1s representing "wide" and 0s representing narrow.
+*/
+static const int CHARACTER_ENCODINGS[] = {
+	0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, // 0-9
+	0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E, // -$:/.+ABCD
+};
+
+static_assert(Size(ALPHABET) == Size(CHARACTER_ENCODINGS), "table size mismatch");
+
+BitMatrix
+CodabarWriter::encode(const std::wstring& contents_, int width, int height) const
+{
+	std::wstring contents = contents_;
+	if (contents.empty()) {
+		throw std::invalid_argument("Found empty contents");
+	}
+	if (contents.length() < 2) {
+		// Can't have a start/end guard, so tentatively add default guards
+		contents = DEFAULT_GUARD + contents + DEFAULT_GUARD;
+	}
+	else {
+		// Verify input and calculate decoded length.
+		bool startsNormal = Contains(START_END_CHARS, contents.front());
+		bool endsNormal = Contains(START_END_CHARS, contents.back());
+		bool startsAlt = Contains(ALT_START_END_CHARS, contents.front());
+		bool endsAlt = Contains(ALT_START_END_CHARS, contents.back());
+		if (startsNormal) {
+			if (!endsNormal) {
+				throw std::invalid_argument("Invalid start/end guards");
+			}
+			// else already has valid start/end
+		}
+		else if (startsAlt) {
+			if (!endsAlt) {
+				throw std::invalid_argument("Invalid start/end guards");
+			}
+			// else already has valid start/end
+
+			// map alt characters to normal once so they are found in the ALPHABET
+			auto map_alt_guard_char = [](wchar_t& c) {
+				switch (c) {
+				case 'T': c = 'A'; break;
+				case 'N': c = 'B'; break;
+				case '*': c = 'C'; break;
+				case 'E': c = 'D'; break;
+				}
+			};
+			map_alt_guard_char(contents.front());
+			map_alt_guard_char(contents.back());
+		}
+		else {
+			// Doesn't start with a guard
+			if (endsNormal || endsAlt) {
+				throw std::invalid_argument("Invalid start/end guards");
+			}
+			// else doesn't end with guard either, so add a default
+			contents = DEFAULT_GUARD + contents + DEFAULT_GUARD;
+		}
+	}
+
+	// The start character and the end character are decoded to 10 length each.
+	size_t resultLength = 20;
+	for (size_t i = 1; i + 1 < contents.length(); ++i) {
+		auto c = contents[i];
+		if (IsDigit(c) || c == '-' || c == '$') {
+			resultLength += 9;
+		}
+		else if (Contains(CHARS_WHICH_ARE_TEN_LENGTH_EACH_AFTER_DECODED, c)) {
+			resultLength += 10;
+		}
+		else {
+			throw std::invalid_argument(StrCat("Cannot encode : '", static_cast<char>(c), "'"));
+		}
+	}
+	// A blank is placed between each character.
+	resultLength += contents.length() - 1;
+
+	std::vector<bool> result(resultLength, false);
+	auto position = result.begin();
+	for (wchar_t c : contents) {
+		int code = CHARACTER_ENCODINGS[IndexOf(ALPHABET, c)]; // c is checked above to be in ALPHABET
+		bool isBlack = true;
+		int counter = 0; // count the width of the current bar
+		int bit = 0;
+		while (bit < 7) { // A character consists of 7 digit.
+			*position++ = isBlack;
+			++counter;
+			if (((code >> (6 - bit)) & 1) == 0 || counter == WIDE_TO_NARROW_BAR_RATIO) { // if current bar is short or we
+				isBlack = !isBlack; // Flip the color.
+				bit++;
+				counter = 0;
+			}
+		}
+		if (position != result.end()) {
+			*position++ = false; // inter character whitespace
+		}
+	}
+
+	return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 10);
+}
+
+BitMatrix CodabarWriter::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,34 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace OneD {
+
+/**
+* This class renders CodaBar as {@code boolean[]}.
+*
+* @author dsbnatut@gmail.com (Kazuki Nishiura)
+*/
+class CodabarWriter
+{
+public:
+	CodabarWriter& setMargin(int sidesMargin) { _sidesMargin = sidesMargin; 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:
+	int _sidesMargin = -1;
+};
+
+} // OneD
+} // ZXing

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

@@ -0,0 +1,130 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Pattern.h"
+
+namespace ZXing::OneD::Code128 {
+
+constexpr int CHAR_LEN = 6;
+constexpr int CHAR_MODS = 11;
+
+// See ISO/IEC 15417:2007(E) Table 1
+constexpr std::array<FixedPattern<CHAR_LEN, CHAR_MODS>, 107> CODE_PATTERNS = { {
+	{ 2, 1, 2, 2, 2, 2 }, // 0
+	{ 2, 2, 2, 1, 2, 2 },
+	{ 2, 2, 2, 2, 2, 1 },
+	{ 1, 2, 1, 2, 2, 3 },
+	{ 1, 2, 1, 3, 2, 2 },
+	{ 1, 3, 1, 2, 2, 2 }, // 5
+	{ 1, 2, 2, 2, 1, 3 },
+	{ 1, 2, 2, 3, 1, 2 },
+	{ 1, 3, 2, 2, 1, 2 },
+	{ 2, 2, 1, 2, 1, 3 },
+	{ 2, 2, 1, 3, 1, 2 }, // 10
+	{ 2, 3, 1, 2, 1, 2 },
+	{ 1, 1, 2, 2, 3, 2 },
+	{ 1, 2, 2, 1, 3, 2 },
+	{ 1, 2, 2, 2, 3, 1 },
+	{ 1, 1, 3, 2, 2, 2 }, // 15
+	{ 1, 2, 3, 1, 2, 2 },
+	{ 1, 2, 3, 2, 2, 1 },
+	{ 2, 2, 3, 2, 1, 1 },
+	{ 2, 2, 1, 1, 3, 2 },
+	{ 2, 2, 1, 2, 3, 1 }, // 20
+	{ 2, 1, 3, 2, 1, 2 },
+	{ 2, 2, 3, 1, 1, 2 },
+	{ 3, 1, 2, 1, 3, 1 },
+	{ 3, 1, 1, 2, 2, 2 },
+	{ 3, 2, 1, 1, 2, 2 }, // 25
+	{ 3, 2, 1, 2, 2, 1 },
+	{ 3, 1, 2, 2, 1, 2 },
+	{ 3, 2, 2, 1, 1, 2 },
+	{ 3, 2, 2, 2, 1, 1 },
+	{ 2, 1, 2, 1, 2, 3 }, // 30
+	{ 2, 1, 2, 3, 2, 1 },
+	{ 2, 3, 2, 1, 2, 1 },
+	{ 1, 1, 1, 3, 2, 3 },
+	{ 1, 3, 1, 1, 2, 3 },
+	{ 1, 3, 1, 3, 2, 1 }, // 35
+	{ 1, 1, 2, 3, 1, 3 },
+	{ 1, 3, 2, 1, 1, 3 },
+	{ 1, 3, 2, 3, 1, 1 },
+	{ 2, 1, 1, 3, 1, 3 },
+	{ 2, 3, 1, 1, 1, 3 }, // 40
+	{ 2, 3, 1, 3, 1, 1 },
+	{ 1, 1, 2, 1, 3, 3 },
+	{ 1, 1, 2, 3, 3, 1 },
+	{ 1, 3, 2, 1, 3, 1 },
+	{ 1, 1, 3, 1, 2, 3 }, // 45
+	{ 1, 1, 3, 3, 2, 1 },
+	{ 1, 3, 3, 1, 2, 1 },
+	{ 3, 1, 3, 1, 2, 1 },
+	{ 2, 1, 1, 3, 3, 1 },
+	{ 2, 3, 1, 1, 3, 1 }, // 50
+	{ 2, 1, 3, 1, 1, 3 },
+	{ 2, 1, 3, 3, 1, 1 },
+	{ 2, 1, 3, 1, 3, 1 },
+	{ 3, 1, 1, 1, 2, 3 },
+	{ 3, 1, 1, 3, 2, 1 }, // 55
+	{ 3, 3, 1, 1, 2, 1 },
+	{ 3, 1, 2, 1, 1, 3 },
+	{ 3, 1, 2, 3, 1, 1 },
+	{ 3, 3, 2, 1, 1, 1 },
+	{ 3, 1, 4, 1, 1, 1 }, // 60
+	{ 2, 2, 1, 4, 1, 1 },
+	{ 4, 3, 1, 1, 1, 1 },
+	{ 1, 1, 1, 2, 2, 4 },
+	{ 1, 1, 1, 4, 2, 2 },
+	{ 1, 2, 1, 1, 2, 4 }, // 65
+	{ 1, 2, 1, 4, 2, 1 },
+	{ 1, 4, 1, 1, 2, 2 },
+	{ 1, 4, 1, 2, 2, 1 },
+	{ 1, 1, 2, 2, 1, 4 },
+	{ 1, 1, 2, 4, 1, 2 }, // 70
+	{ 1, 2, 2, 1, 1, 4 },
+	{ 1, 2, 2, 4, 1, 1 },
+	{ 1, 4, 2, 1, 1, 2 },
+	{ 1, 4, 2, 2, 1, 1 },
+	{ 2, 4, 1, 2, 1, 1 }, // 75
+	{ 2, 2, 1, 1, 1, 4 },
+	{ 4, 1, 3, 1, 1, 1 },
+	{ 2, 4, 1, 1, 1, 2 },
+	{ 1, 3, 4, 1, 1, 1 },
+	{ 1, 1, 1, 2, 4, 2 }, // 80
+	{ 1, 2, 1, 1, 4, 2 },
+	{ 1, 2, 1, 2, 4, 1 },
+	{ 1, 1, 4, 2, 1, 2 },
+	{ 1, 2, 4, 1, 1, 2 },
+	{ 1, 2, 4, 2, 1, 1 }, // 85
+	{ 4, 1, 1, 2, 1, 2 },
+	{ 4, 2, 1, 1, 1, 2 },
+	{ 4, 2, 1, 2, 1, 1 },
+	{ 2, 1, 2, 1, 4, 1 },
+	{ 2, 1, 4, 1, 2, 1 }, // 90
+	{ 4, 1, 2, 1, 2, 1 },
+	{ 1, 1, 1, 1, 4, 3 },
+	{ 1, 1, 1, 3, 4, 1 },
+	{ 1, 3, 1, 1, 4, 1 },
+	{ 1, 1, 4, 1, 1, 3 }, // 95
+	{ 1, 1, 4, 3, 1, 1 },
+	{ 4, 1, 1, 1, 1, 3 },
+	{ 4, 1, 1, 3, 1, 1 },
+	{ 1, 1, 3, 1, 4, 1 },
+	{ 1, 1, 4, 1, 3, 1 }, // 100
+	{ 3, 1, 1, 1, 4, 1 },
+	{ 4, 1, 1, 1, 3, 1 },
+	{ 2, 1, 1, 4, 1, 2 },
+	{ 2, 1, 1, 2, 1, 4 },
+	{ 2, 1, 1, 2, 3, 2 }, // 105
+	{ 2, 3, 3, 1, 1, 1 }  // STOP_CODE followed by 2-wide termination bar
+} };
+
+// See ISO/IEC 15417:2007(E) Table 2
+constexpr auto E2E_PATTERNS = PatternsToE2EInts(CODE_PATTERNS);
+
+} // namespace ZXing::OneD::Code128

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

@@ -0,0 +1,236 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODCode128Reader.h"
+
+#include "ODCode128Patterns.h"
+#include "BarcodeData.h"
+#include "ByteArray.h"
+#include "JSON.h"
+#include "SymbologyIdentifier.h"
+#include "ZXAlgorithms.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ZXing::OneD {
+
+using namespace Code128;
+
+static const float MAX_AVG_VARIANCE = 0.25f;
+static const float MAX_INDIVIDUAL_VARIANCE = 0.7f;
+
+static const int CODE_SHIFT = 98;
+
+static const int CODE_CODE_C = 99;
+static const int CODE_CODE_B = 100;
+static const int CODE_CODE_A = 101;
+
+static const int CODE_FNC_1 = 102;
+static const int CODE_FNC_2 = 97;
+static const int CODE_FNC_3 = 96;
+
+static const int CODE_START_A = 103;
+static const int CODE_START_C = 105;
+static const int CODE_STOP = 106;
+
+class Raw2TxtDecoder
+{
+	int codeSet = 0;
+	SymbologyIdentifier _symbologyIdentifier = {'C', '0'}; // ISO/IEC 15417:2007 Annex C Table C.1
+	bool _readerInit = false;
+	bool _havePositionFNC1 = false;
+	std::string txt;
+	size_t lastTxtSize = 0;
+
+	bool fnc4All = false;
+	bool fnc4Next = false;
+	bool shift = false;
+
+	void fnc1(const bool isCodeSetC)
+	{
+		if (!_havePositionFNC1 && txt.empty()) {
+			// ISO/IEC 15417:2007 Annex B.1 and GS1 General Specifications 21.0.1 Section 5.4.3.7
+			// If the first char after the start code is FNC1 then this is GS1-128.
+			_symbologyIdentifier.modifier = '1';
+			// GS1 General Specifications Section 5.4.6.4
+			// "Transmitted data ... is prefixed by the symbology identifier ]C1, if used."
+			// Choosing not to use symbology identifier, i.e. to not prefix to data.
+			_symbologyIdentifier.aiFlag = AIFlag::GS1;
+			_havePositionFNC1 = true;
+		}
+		else if (!_havePositionFNC1
+					&& ((isCodeSetC && txt.size() == 2 && IsDigit(txt[0]) && IsDigit(txt[1]))
+						|| (!isCodeSetC && txt.size() == 1 && IsAlpha(txt[0])))) {
+			// ISO/IEC 15417:2007 Annex B.2
+			// FNC1 in second position following Code Set C "00-99" or Code Set A/B "A-Za-z" - AIM
+			_symbologyIdentifier.modifier = '2';
+			_symbologyIdentifier.aiFlag = AIFlag::AIM;
+			_havePositionFNC1 = true;
+		}
+		else {
+			// ISO/IEC 15417:2007 Annex B.3. Otherwise FNC1 is returned as ASCII 29 (GS)
+			txt.push_back((char)29);
+		}
+	};
+
+public:
+	Raw2TxtDecoder(int startCode) : codeSet(204 - startCode)
+	{
+		txt.reserve(20);
+	}
+
+	bool decode(int code)
+	{
+		lastTxtSize = txt.size();
+
+		if (codeSet == CODE_CODE_C) {
+			if (code < 100) {
+				txt.append(ToString(code, 2));
+			} else if (code == CODE_FNC_1) {
+				fnc1(true /*isCodeSetC*/);
+			} else {
+				codeSet = code; // CODE_A / CODE_B
+			}
+		} else { // codeSet A or B
+			bool unshift = shift;
+
+			switch (code) {
+			case CODE_FNC_1: fnc1(false /*isCodeSetC*/); break;
+			case CODE_FNC_2:
+				// Message Append - do nothing?
+				break;
+			case CODE_FNC_3:
+				_readerInit = true; // Can occur anywhere in the symbol (ISO/IEC 15417:2007 4.3.4.2 (c))
+				break;
+			case CODE_SHIFT:
+				if (shift)
+					return false; // two shifts in a row make no sense
+				shift = true;
+				codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
+				break;
+			case CODE_CODE_A:
+			case CODE_CODE_B:
+				if (codeSet == code) {
+					// FNC4
+					if (fnc4Next)
+						fnc4All = !fnc4All;
+					fnc4Next = !fnc4Next;
+				} else {
+					codeSet = code;
+				}
+				break;
+			case CODE_CODE_C: codeSet = CODE_CODE_C; break;
+
+			default: {
+				// code < 96 at this point
+				int offset;
+				if (codeSet == CODE_CODE_A && code >= 64)
+					offset = fnc4All == fnc4Next ? -64 : +64;
+				else
+					offset = fnc4All == fnc4Next ? ' ' : ' ' + 128;
+				txt.push_back((char)(code + offset));
+				fnc4Next = false;
+				break;
+			}
+			}
+
+			// Unshift back to another code set if we were shifted
+			if (unshift) {
+				codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
+				shift = false;
+			}
+		}
+
+		return true;
+	}
+
+	std::string text() const
+	{
+		// Need to pull out the check digit(s) from string (if the checksum code happened to
+		// be a printable character).
+		return txt.substr(0, lastTxtSize);
+	}
+
+	SymbologyIdentifier symbologyIdentifier() const { return _symbologyIdentifier; }
+	bool readerInit() const { return _readerInit; }
+};
+
+// all 3 start patterns share the same 2-1-1 prefix
+constexpr auto START_PATTERN_PREFIX = FixedPattern<3, 4>{2, 1, 1};
+constexpr float QUIET_ZONE = 5;	// quiet zone spec is 10 modules, real world examples ignore that, see #138
+
+BarcodeData Code128Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+{
+	int minCharCount = 4; // start + payload + checksum + stop
+	auto decodePattern = [](const PatternView& view, bool start = false) {
+		// This is basically the reference algorithm from the specification
+		int code = IndexOf(E2E_PATTERNS, ToInt(NormalizedE2EPattern<CHAR_LEN, CHAR_MODS>(view)));
+		if (code == -1 && !start) // if the reference algo fails, give the original upstream version a try (required to decode a few samples)
+			code = DecodeDigit(view, CODE_PATTERNS, MAX_AVG_VARIANCE, MAX_INDIVIDUAL_VARIANCE);
+		return code;
+	};
+
+	next = FindLeftGuard(next, minCharCount * CHAR_LEN, START_PATTERN_PREFIX, QUIET_ZONE);
+	if (!next.isValid())
+		return {};
+
+	next = next.subView(0, CHAR_LEN);
+	int startCode = decodePattern(next, true);
+	if (!(CODE_START_A <= startCode && startCode <= CODE_START_C))
+		return {};
+
+	int xStart = next.pixelsInFront();
+	ByteArray rawCodes;
+	rawCodes.reserve(20);
+	rawCodes.push_back(narrow_cast<uint8_t>(startCode));
+
+	Raw2TxtDecoder raw2txt(startCode);
+
+	while (true) {
+		if (!next.skipSymbol())
+			return {};
+
+		// Decode another code from image
+		int code = decodePattern(next);
+		if (code == -1)
+			return {};
+		if (code == CODE_STOP)
+			break;
+		if (code >= CODE_START_A)
+			return {};
+		if (!raw2txt.decode(code))
+			return {};
+
+		rawCodes.push_back(narrow_cast<uint8_t>(code));
+	}
+
+	if (Size(rawCodes) < minCharCount - 1) // stop code is missing in rawCodes
+		return {};
+
+	// check termination bar (is present and not wider than about 2 modules) and quiet zone (next is now 13 modules
+	// wide, require at least 8)
+	next = next.subView(0, CHAR_LEN + 1);
+	if (!next.isValid() || next[CHAR_LEN] > next.sum(CHAR_LEN) / 4 || !next.hasQuietZoneAfter(QUIET_ZONE/13))
+		return {};
+
+	Error error;
+	int checksum = rawCodes.front();
+	for (int i = 1; i < Size(rawCodes) - 1; ++i)
+		checksum += i * rawCodes[i];
+	// the last code is the checksum:
+	if (checksum % 103 != rawCodes.back())
+		error = ChecksumError();
+
+	int xStop = next.pixelsTillEnd();
+	return LinearBarcode(BarcodeFormat::Code128, raw2txt.text(), rowNumber, xStart, xStop, raw2txt.symbologyIdentifier(), error,
+				   JsonProp(BarcodeExtra::ReaderInit, raw2txt.readerInit()));
+}
+
+} // namespace ZXing::OneD

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

@@ -0,0 +1,21 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+class Code128Reader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	BarcodeData decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+};
+
+} // namespace ZXing::OneD