Nayuki Minase
9 years ago
parent
bc10146355
commit
008fddf4be
@ -0,0 +1,63 @@
|
||||
/*
|
||||
* QR Code generator library (C++)
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#include <cstddef>
|
||||
#include "BitBuffer.hpp"
|
||||
|
||||
|
||||
qrcodegen::BitBuffer::BitBuffer() :
|
||||
data(),
|
||||
bitLength(0) {}
|
||||
|
||||
|
||||
int qrcodegen::BitBuffer::getBitLength() const {
|
||||
return bitLength;
|
||||
}
|
||||
|
||||
|
||||
std::vector<uint8_t> qrcodegen::BitBuffer::getBytes() const {
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::BitBuffer::appendBits(uint32_t val, int len) {
|
||||
if (len < 0 || len > 32 || (len < 32 && (val >> len) != 0))
|
||||
throw "Value out of range";
|
||||
size_t newBitLen = bitLength + len;
|
||||
while (data.size() * 8 < newBitLen)
|
||||
data.push_back(0);
|
||||
for (int i = len - 1; i >= 0; i--, bitLength++) // Append bit by bit
|
||||
data.at(bitLength >> 3) |= ((val >> i) & 1) << (7 - (bitLength & 7));
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::BitBuffer::appendData(const QrSegment &seg) {
|
||||
size_t newBitLen = bitLength + seg.bitLength;
|
||||
while (data.size() * 8 < newBitLen)
|
||||
data.push_back(0);
|
||||
for (int i = 0; i < seg.bitLength; i++, bitLength++) { // Append bit by bit
|
||||
int bit = (seg.data.at(i >> 3) >> (7 - (i & 7))) & 1;
|
||||
data.at(bitLength >> 3) |= bit << (7 - (bitLength & 7));
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
/*
|
||||
* QR Code generator library (C++)
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "QrSegment.hpp"
|
||||
|
||||
|
||||
namespace qrcodegen {
|
||||
|
||||
/**
|
||||
* An appendable sequence of bits. Bits are packed in big endian within a byte.
|
||||
*/
|
||||
class BitBuffer final {
|
||||
|
||||
/*---- Fields ----*/
|
||||
private:
|
||||
|
||||
std::vector<uint8_t> data;
|
||||
int bitLength;
|
||||
|
||||
|
||||
|
||||
/*---- Constructor ----*/
|
||||
public:
|
||||
|
||||
// Creates an empty bit buffer (length 0).
|
||||
BitBuffer();
|
||||
|
||||
|
||||
|
||||
/*---- Methods ----*/
|
||||
public:
|
||||
|
||||
// Returns the number of bits in the buffer, which is a non-negative value.
|
||||
int getBitLength() const;
|
||||
|
||||
|
||||
// Returns a copy of all bytes, padding up to the nearest byte.
|
||||
std::vector<uint8_t> getBytes() const;
|
||||
|
||||
|
||||
// Appends the given number of bits of the given value to this sequence.
|
||||
// If 0 <= len <= 31, then this requires 0 <= val < 2^len.
|
||||
void appendBits(uint32_t val, int len);
|
||||
|
||||
|
||||
// Appends the data of the given segment to this bit buffer.
|
||||
void appendData(const QrSegment &seg);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
@ -0,0 +1,623 @@
|
||||
/*
|
||||
* QR Code generator library (C++)
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#include <algorithm>
|
||||
#include <climits>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <sstream>
|
||||
#include "BitBuffer.hpp"
|
||||
#include "QrCode.hpp"
|
||||
|
||||
|
||||
qrcodegen::QrCode::Ecc::Ecc(int ord, int fb) :
|
||||
ordinal(ord),
|
||||
formatBits(fb) {}
|
||||
|
||||
|
||||
const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::LOW (0, 1);
|
||||
const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::MEDIUM (1, 0);
|
||||
const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::QUARTILE(2, 3);
|
||||
const qrcodegen::QrCode::Ecc qrcodegen::QrCode::Ecc::HIGH (3, 2);
|
||||
|
||||
|
||||
qrcodegen::QrCode qrcodegen::QrCode::encodeText(const char *text, const Ecc &ecl) {
|
||||
std::vector<QrSegment> segs;
|
||||
segs.push_back(encodeTextToSegment(text));
|
||||
return encodeSegments(segs, ecl);
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrSegment qrcodegen::QrCode::encodeTextToSegment(const char *text) {
|
||||
// Select the most efficient segment encoding automatically
|
||||
if (QrSegment::isNumeric(text))
|
||||
return QrSegment::makeNumeric(text);
|
||||
else if (QrSegment::isAlphanumeric(text))
|
||||
return QrSegment::makeAlphanumeric(text);
|
||||
else {
|
||||
std::vector<uint8_t> bytes;
|
||||
for (; *text != '\0'; text++)
|
||||
bytes.push_back(static_cast<uint8_t>(*text));
|
||||
return QrSegment::makeBytes(bytes);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrCode qrcodegen::QrCode::encodeBinary(const std::vector<uint8_t> &data, const Ecc &ecl) {
|
||||
std::vector<QrSegment> segs;
|
||||
segs.push_back(QrSegment::makeBytes(data));
|
||||
return encodeSegments(segs, ecl);
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrCode qrcodegen::QrCode::encodeSegments(const std::vector<QrSegment> &segs, const Ecc &ecl) {
|
||||
// Find the minimal version number to use
|
||||
int version, dataCapacityBits;
|
||||
for (version = 1; ; version++) { // Increment until the data fits in the QR Code
|
||||
if (version > 40) // All versions could not fit the given data
|
||||
throw "Data too long";
|
||||
dataCapacityBits = getNumDataCodewords(version, ecl) * 8; // Number of data bits available
|
||||
|
||||
// Calculate the total number of bits needed at this version number
|
||||
// to encode all the segments (i.e. segment metadata and payloads)
|
||||
int dataUsedBits = 0;
|
||||
for (size_t i = 0; i < segs.size(); i++) {
|
||||
const QrSegment &seg(segs.at(i));
|
||||
if (seg.numChars < 0)
|
||||
throw "Assertion error";
|
||||
int ccbits = seg.mode.numCharCountBits(version);
|
||||
if (seg.numChars >= (1 << ccbits)) {
|
||||
// Segment length value doesn't fit in the length field's bit-width, so fail immediately
|
||||
goto continueOuter;
|
||||
}
|
||||
dataUsedBits += 4 + ccbits + seg.bitLength;
|
||||
}
|
||||
if (dataUsedBits <= dataCapacityBits)
|
||||
break; // This version number is found to be suitable
|
||||
continueOuter:;
|
||||
}
|
||||
|
||||
// Create the data bit string by concatenating all segments
|
||||
BitBuffer bb;
|
||||
for (size_t i = 0; i < segs.size(); i++) {
|
||||
const QrSegment &seg(segs.at(i));
|
||||
bb.appendBits(seg.mode.modeBits, 4);
|
||||
bb.appendBits(seg.numChars, seg.mode.numCharCountBits(version));
|
||||
bb.appendData(seg);
|
||||
}
|
||||
|
||||
// Add terminator and pad up to a byte if applicable
|
||||
bb.appendBits(0, std::min(4, dataCapacityBits - bb.getBitLength()));
|
||||
bb.appendBits(0, (8 - bb.getBitLength() % 8) % 8);
|
||||
|
||||
// Pad with alternate bytes until data capacity is reached
|
||||
for (uint8_t padByte = 0xEC; bb.getBitLength() < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
|
||||
bb.appendBits(padByte, 8);
|
||||
if (bb.getBitLength() % 8 != 0)
|
||||
throw "Assertion error";
|
||||
|
||||
// Create the QR Code symbol
|
||||
return QrCode(version, ecl, bb.getBytes(), -1);
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrCode::QrCode(int ver, const Ecc &ecl, const std::vector<uint8_t> &dataCodewords, int mask) :
|
||||
// Initialize scalar fields
|
||||
version(ver),
|
||||
size(1 <= ver && ver <= 40 ? ver * 4 + 17 : -1), // Avoid signed overflow undefined behavior
|
||||
errorCorrectionLevel(ecl) {
|
||||
|
||||
// Check arguments
|
||||
if (ver < 1 || ver > 40 || mask < -1 || mask > 7)
|
||||
throw "Value out of range";
|
||||
|
||||
std::vector<bool> row(size);
|
||||
for (int i = 0; i < size; i++) {
|
||||
modules.push_back(row);
|
||||
isFunction.push_back(row);
|
||||
}
|
||||
|
||||
// Draw function patterns, draw all codewords, do masking
|
||||
drawFunctionPatterns();
|
||||
const std::vector<uint8_t> allCodewords(appendErrorCorrection(dataCodewords));
|
||||
drawCodewords(allCodewords);
|
||||
this->mask = handleConstructorMasking(mask);
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrCode::QrCode(const QrCode &qr, int mask) :
|
||||
// Copy scalar fields
|
||||
version(qr.version),
|
||||
size(qr.size),
|
||||
errorCorrectionLevel(qr.errorCorrectionLevel) {
|
||||
|
||||
// Check arguments
|
||||
if (mask < -1 || mask > 7)
|
||||
throw "Mask value out of range";
|
||||
|
||||
// Handle grid fields
|
||||
modules = qr.modules;
|
||||
isFunction = qr.isFunction;
|
||||
|
||||
// Handle masking
|
||||
applyMask(qr.mask); // Undo old mask
|
||||
this->mask = handleConstructorMasking(mask);
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrCode::getMask() const {
|
||||
return mask;
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrCode::getModule(int x, int y) const {
|
||||
if (0 <= x && x < size && 0 <= y && y < size)
|
||||
return modules.at(y).at(x) ? 1 : 0;
|
||||
else
|
||||
return 0; // Infinite white border
|
||||
}
|
||||
|
||||
|
||||
std::string qrcodegen::QrCode::toSvgString(int border) const {
|
||||
if (border < 0)
|
||||
throw "Border must be non-negative";
|
||||
std::ostringstream sb;
|
||||
sb << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
|
||||
sb << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
|
||||
sb << "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 ";
|
||||
sb << (size + border * 2) << " " << (size + border * 2) << "\">\n";
|
||||
sb << "\t<path d=\"";
|
||||
bool head = true;
|
||||
for (int y = -border; y < size + border; y++) {
|
||||
for (int x = -border; x < size + border; x++) {
|
||||
if (getModule(x, y) == 1) {
|
||||
if (head)
|
||||
head = false;
|
||||
else
|
||||
sb << " ";
|
||||
sb << "M" << (x + border) << "," << (y + border) << "h1v1h-1z";
|
||||
}
|
||||
}
|
||||
}
|
||||
sb << "\" fill=\"#000000\" stroke-width=\"0\"/>\n";
|
||||
sb << "</svg>\n";
|
||||
return sb.str();
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::drawFunctionPatterns() {
|
||||
// Draw the horizontal and vertical timing patterns
|
||||
for (int i = 0; i < size; i++) {
|
||||
setFunctionModule(6, i, i % 2 == 0);
|
||||
setFunctionModule(i, 6, i % 2 == 0);
|
||||
}
|
||||
|
||||
// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
|
||||
drawFinderPattern(3, 3);
|
||||
drawFinderPattern(size - 4, 3);
|
||||
drawFinderPattern(3, size - 4);
|
||||
|
||||
// Draw the numerous alignment patterns
|
||||
const std::vector<int> alignPatPos(getAlignmentPatternPositions(version));
|
||||
int numAlign = alignPatPos.size();
|
||||
for (int i = 0; i < numAlign; i++) {
|
||||
for (int j = 0; j < numAlign; j++) {
|
||||
if ((i == 0 && j == 0) || (i == 0 && j == numAlign - 1) || (i == numAlign - 1 && j == 0))
|
||||
continue; // Skip the three finder corners
|
||||
else
|
||||
drawAlignmentPattern(alignPatPos.at(i), alignPatPos.at(j));
|
||||
}
|
||||
}
|
||||
|
||||
// Draw configuration data
|
||||
drawFormatBits(0); // Dummy mask value; overwritten later in the constructor
|
||||
drawVersion();
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::drawFormatBits(int mask) {
|
||||
// Calculate error correction code and pack bits
|
||||
int data = errorCorrectionLevel.formatBits << 3 | mask; // errCorrLvl is uint2, mask is uint3
|
||||
int rem = data;
|
||||
for (int i = 0; i < 10; i++)
|
||||
rem = (rem << 1) ^ ((rem >> 9) * 0x537);
|
||||
data = data << 10 | rem;
|
||||
data ^= 0x5412; // uint15
|
||||
if (data >> 15 != 0)
|
||||
throw "Assertion error";
|
||||
|
||||
// Draw first copy
|
||||
for (int i = 0; i <= 5; i++)
|
||||
setFunctionModule(8, i, ((data >> i) & 1) != 0);
|
||||
setFunctionModule(8, 7, ((data >> 6) & 1) != 0);
|
||||
setFunctionModule(8, 8, ((data >> 7) & 1) != 0);
|
||||
setFunctionModule(7, 8, ((data >> 8) & 1) != 0);
|
||||
for (int i = 9; i < 15; i++)
|
||||
setFunctionModule(14 - i, 8, ((data >> i) & 1) != 0);
|
||||
|
||||
// Draw second copy
|
||||
for (int i = 0; i <= 7; i++)
|
||||
setFunctionModule(size - 1 - i, 8, ((data >> i) & 1) != 0);
|
||||
for (int i = 8; i < 15; i++)
|
||||
setFunctionModule(8, size - 15 + i, ((data >> i) & 1) != 0);
|
||||
setFunctionModule(8, size - 8, true);
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::drawVersion() {
|
||||
if (version < 7)
|
||||
return;
|
||||
|
||||
// Calculate error correction code and pack bits
|
||||
int rem = version; // version is uint6, in the range [7, 40]
|
||||
for (int i = 0; i < 12; i++)
|
||||
rem = (rem << 1) ^ ((rem >> 11) * 0x1F25);
|
||||
int data = version << 12 | rem; // uint18
|
||||
if (data >> 18 != 0)
|
||||
throw "Assertion error";
|
||||
|
||||
// Draw two copies
|
||||
for (int i = 0; i < 18; i++) {
|
||||
bool bit = ((data >> i) & 1) != 0;
|
||||
int a = size - 11 + i % 3, b = i / 3;
|
||||
setFunctionModule(a, b, bit);
|
||||
setFunctionModule(b, a, bit);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::drawFinderPattern(int x, int y) {
|
||||
for (int i = -4; i <= 4; i++) {
|
||||
for (int j = -4; j <= 4; j++) {
|
||||
int dist = std::max(std::abs(i), std::abs(j)); // Chebyshev/infinity norm
|
||||
int xx = x + j, yy = y + i;
|
||||
if (0 <= xx && xx < size && 0 <= yy && yy < size)
|
||||
setFunctionModule(xx, yy, dist != 2 && dist != 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::drawAlignmentPattern(int x, int y) {
|
||||
for (int i = -2; i <= 2; i++) {
|
||||
for (int j = -2; j <= 2; j++)
|
||||
setFunctionModule(x + j, y + i, std::max(std::abs(i), std::abs(j)) != 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::setFunctionModule(int x, int y, bool isBlack) {
|
||||
modules.at(y).at(x) = isBlack;
|
||||
isFunction.at(y).at(x) = true;
|
||||
}
|
||||
|
||||
|
||||
std::vector<uint8_t> qrcodegen::QrCode::appendErrorCorrection(const std::vector<uint8_t> &data) const {
|
||||
if (data.size() != static_cast<unsigned int>(getNumDataCodewords(version, errorCorrectionLevel)))
|
||||
throw "Invalid argument";
|
||||
int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[errorCorrectionLevel.ordinal][version];
|
||||
int numEcc = NUM_ERROR_CORRECTION_CODEWORDS[errorCorrectionLevel.ordinal][version];
|
||||
if (numEcc % numBlocks != 0)
|
||||
throw "Assertion error";
|
||||
int eccLen = numEcc / numBlocks;
|
||||
int numShortBlocks = numBlocks - getNumRawDataModules(version) / 8 % numBlocks;
|
||||
int shortBlockLen = getNumRawDataModules(version) / 8 / numBlocks;
|
||||
|
||||
std::vector<std::vector<uint8_t>> blocks;
|
||||
const ReedSolomonGenerator rs(eccLen);
|
||||
for (int i = 0, k = 0; i < numBlocks; i++) {
|
||||
std::vector<uint8_t> dat;
|
||||
dat.insert(dat.begin(), data.begin() + k, data.begin() + (k + shortBlockLen - eccLen + (i < numShortBlocks ? 0 : 1)));
|
||||
k += dat.size();
|
||||
const std::vector<uint8_t> ecc(rs.getRemainder(dat));
|
||||
if (i < numShortBlocks)
|
||||
dat.push_back(0);
|
||||
dat.insert(dat.end(), ecc.begin(), ecc.end());
|
||||
blocks.push_back(dat);
|
||||
}
|
||||
|
||||
std::vector<uint8_t> result;
|
||||
for (int i = 0; static_cast<unsigned int>(i) < blocks.at(0).size(); i++) {
|
||||
for (int j = 0; static_cast<unsigned int>(j) < blocks.size(); j++) {
|
||||
if (i != shortBlockLen - eccLen || j >= numShortBlocks)
|
||||
result.push_back(blocks.at(j).at(i));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::drawCodewords(const std::vector<uint8_t> &data) {
|
||||
if (data.size() != static_cast<unsigned int>(getNumRawDataModules(version) / 8))
|
||||
throw "Invalid argument";
|
||||
|
||||
size_t i = 0; // Bit index into the data
|
||||
// Do the funny zigzag scan
|
||||
for (int right = size - 1; right >= 1; right -= 2) { // Index of right column in each column pair
|
||||
if (right == 6)
|
||||
right = 5;
|
||||
for (int vert = 0; vert < size; vert++) { // Vertical counter
|
||||
for (int j = 0; j < 2; j++) {
|
||||
int x = right - j; // Actual x coordinate
|
||||
bool upwards = ((right & 2) == 0) ^ (x < 6);
|
||||
int y = upwards ? size - 1 - vert : vert; // Actual y coordinate
|
||||
if (!isFunction.at(y).at(x) && i < data.size() * 8) {
|
||||
modules.at(y).at(x) = ((data[i >> 3] >> (7 - (i & 7))) & 1) != 0;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (static_cast<unsigned int>(i) != data.size() * 8)
|
||||
throw "Assertion error";
|
||||
}
|
||||
|
||||
|
||||
void qrcodegen::QrCode::applyMask(int mask) {
|
||||
if (mask < 0 || mask > 7)
|
||||
throw "Mask value out of range";
|
||||
for (int y = 0; y < size; y++) {
|
||||
for (int x = 0; x < size; x++) {
|
||||
bool invert;
|
||||
switch (mask) {
|
||||
case 0: invert = (x + y) % 2 == 0; break;
|
||||
case 1: invert = y % 2 == 0; break;
|
||||
case 2: invert = x % 3 == 0; break;
|
||||
case 3: invert = (x + y) % 3 == 0; break;
|
||||
case 4: invert = (x / 3 + y / 2) % 2 == 0; break;
|
||||
case 5: invert = x * y % 2 + x * y % 3 == 0; break;
|
||||
case 6: invert = (x * y % 2 + x * y % 3) % 2 == 0; break;
|
||||
case 7: invert = ((x + y) % 2 + x * y % 3) % 2 == 0; break;
|
||||
default: throw "Assertion error";
|
||||
}
|
||||
modules.at(y).at(x) = modules.at(y).at(x) ^ (invert & !isFunction.at(y).at(x));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrCode::handleConstructorMasking(int mask) {
|
||||
if (mask == -1) { // Automatically choose best mask
|
||||
int32_t minPenalty = INT32_MAX;
|
||||
for (int i = 0; i < 8; i++) {
|
||||
drawFormatBits(i);
|
||||
applyMask(i);
|
||||
int penalty = getPenaltyScore();
|
||||
if (penalty < minPenalty) {
|
||||
mask = i;
|
||||
minPenalty = penalty;
|
||||
}
|
||||
applyMask(i); // Undoes the mask due to XOR
|
||||
}
|
||||
}
|
||||
if (mask < 0 || mask > 7)
|
||||
throw "Assertion error";
|
||||
drawFormatBits(mask); // Overwrite old format bits
|
||||
applyMask(mask); // Apply the final choice of mask
|
||||
return mask; // The caller shall assign this value to the final-declared field
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrCode::getPenaltyScore() const {
|
||||
int result = 0;
|
||||
|
||||
// Adjacent modules in row having same color
|
||||
for (int y = 0; y < size; y++) {
|
||||
bool colorX = modules.at(y).at(0);
|
||||
for (int x = 1, runX = 1; x < size; x++) {
|
||||
if (modules.at(y).at(x) != colorX) {
|
||||
colorX = modules.at(y).at(x);
|
||||
runX = 1;
|
||||
} else {
|
||||
runX++;
|
||||
if (runX == 5)
|
||||
result += PENALTY_N1;
|
||||
else if (runX > 5)
|
||||
result++;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Adjacent modules in column having same color
|
||||
for (int x = 0; x < size; x++) {
|
||||
bool colorY = modules.at(0).at(x);
|
||||
for (int y = 1, runY = 1; y < size; y++) {
|
||||
if (modules.at(y).at(x) != colorY) {
|
||||
colorY = modules.at(y).at(x);
|
||||
runY = 1;
|
||||
} else {
|
||||
runY++;
|
||||
if (runY == 5)
|
||||
result += PENALTY_N1;
|
||||
else if (runY > 5)
|
||||
result++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2*2 blocks of modules having same color
|
||||
for (int y = 0; y < size - 1; y++) {
|
||||
for (int x = 0; x < size - 1; x++) {
|
||||
bool color = modules.at(y).at(x);
|
||||
if ( color == modules.at(y).at(x + 1) &&
|
||||
color == modules.at(y + 1).at(x) &&
|
||||
color == modules.at(y + 1).at(x + 1))
|
||||
result += PENALTY_N2;
|
||||
}
|
||||
}
|
||||
|
||||
// Finder-like pattern in rows
|
||||
for (int y = 0; y < size; y++) {
|
||||
for (int x = 0, bits = 0; x < size; x++) {
|
||||
bits = ((bits << 1) & 0x7FF) | (modules.at(y).at(x) ? 1 : 0);
|
||||
if (x >= 10 && (bits == 0x05D || bits == 0x5D0)) // Needs 11 bits accumulated
|
||||
result += PENALTY_N3;
|
||||
}
|
||||
}
|
||||
// Finder-like pattern in columns
|
||||
for (int x = 0; x < size; x++) {
|
||||
for (int y = 0, bits = 0; y < size; y++) {
|
||||
bits = ((bits << 1) & 0x7FF) | (modules.at(y).at(x) ? 1 : 0);
|
||||
if (y >= 10 && (bits == 0x05D || bits == 0x5D0)) // Needs 11 bits accumulated
|
||||
result += PENALTY_N3;
|
||||
}
|
||||
}
|
||||
|
||||
// Balance of black and white modules
|
||||
int black = 0;
|
||||
for (int y = 0; y < size; y++) {
|
||||
for (int x = 0; x < size; x++) {
|
||||
if (modules.at(y).at(x))
|
||||
black++;
|
||||
}
|
||||
}
|
||||
int total = size * size;
|
||||
// Find smallest k such that (45-5k)% <= dark/total <= (55+5k)%
|
||||
for (int k = 0; black*20 < (9-k)*total || black*20 > (11+k)*total; k++)
|
||||
result += PENALTY_N4;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
std::vector<int> qrcodegen::QrCode::getAlignmentPatternPositions(int ver) {
|
||||
if (ver < 1 || ver > 40)
|
||||
throw "Version number out of range";
|
||||
else if (ver == 1)
|
||||
return std::vector<int>();
|
||||
else {
|
||||
int numAlign = ver / 7 + 2;
|
||||
int step;
|
||||
if (ver != 32)
|
||||
step = (ver * 4 + numAlign * 2 + 1) / (2 * numAlign - 2) * 2; // ceil((size - 13) / (2*numAlign - 2)) * 2
|
||||
else // C-C-C-Combo breaker!
|
||||
step = 26;
|
||||
|
||||
std::vector<int> result(numAlign);
|
||||
int size = ver * 4 + 17;
|
||||
result.at(0) = 6;
|
||||
for (int i = numAlign - 1, pos = size - 7; i >= 1; i--, pos -= step)
|
||||
result.at(i) = pos;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrCode::getNumRawDataModules(int ver) {
|
||||
if (ver < 1 || ver > 40)
|
||||
throw "Version number out of range";
|
||||
int result = (16 * ver + 128) * ver + 64;
|
||||
if (ver >= 2) {
|
||||
int numAlign = ver / 7 + 2;
|
||||
result -= (25 * numAlign - 10) * numAlign - 55;
|
||||
if (ver >= 7)
|
||||
result -= 18 * 2; // Subtract version information
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrCode::getNumDataCodewords(int ver, const Ecc &ecl) {
|
||||
if (ver < 1 || ver > 40)
|
||||
throw "Version number out of range";
|
||||
return getNumRawDataModules(ver) / 8 - NUM_ERROR_CORRECTION_CODEWORDS[ecl.ordinal][ver];
|
||||
}
|
||||
|
||||
|
||||
/*---- Tables of constants ----*/
|
||||
|
||||
// For use in getPenaltyScore(), when evaluating which mask is best.
|
||||
const int qrcodegen::QrCode::PENALTY_N1 = 3;
|
||||
const int qrcodegen::QrCode::PENALTY_N2 = 3;
|
||||
const int qrcodegen::QrCode::PENALTY_N3 = 40;
|
||||
const int qrcodegen::QrCode::PENALTY_N4 = 10;
|
||||
|
||||
|
||||
const int16_t qrcodegen::QrCode::NUM_ERROR_CORRECTION_CODEWORDS[4][41] = {
|
||||
// Version: (note that index 0 is for padding, and is set to an illegal value)
|
||||
//0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level
|
||||
{-1, 7, 10, 15, 20, 26, 36, 40, 48, 60, 72, 80, 96, 104, 120, 132, 144, 168, 180, 196, 224, 224, 252, 270, 300, 312, 336, 360, 390, 420, 450, 480, 510, 540, 570, 570, 600, 630, 660, 720, 750}, // Low
|
||||
{-1, 10, 16, 26, 36, 48, 64, 72, 88, 110, 130, 150, 176, 198, 216, 240, 280, 308, 338, 364, 416, 442, 476, 504, 560, 588, 644, 700, 728, 784, 812, 868, 924, 980, 1036, 1064, 1120, 1204, 1260, 1316, 1372}, // Medium
|
||||
{-1, 13, 22, 36, 52, 72, 96, 108, 132, 160, 192, 224, 260, 288, 320, 360, 408, 448, 504, 546, 600, 644, 690, 750, 810, 870, 952, 1020, 1050, 1140, 1200, 1290, 1350, 1440, 1530, 1590, 1680, 1770, 1860, 1950, 2040}, // Quartile
|
||||
{-1, 17, 28, 44, 64, 88, 112, 130, 156, 192, 224, 264, 308, 352, 384, 432, 480, 532, 588, 650, 700, 750, 816, 900, 960, 1050, 1110, 1200, 1260, 1350, 1440, 1530, 1620, 1710, 1800, 1890, 1980, 2100, 2220, 2310, 2430}, // High
|
||||
};
|
||||
|
||||
const int8_t qrcodegen::QrCode::NUM_ERROR_CORRECTION_BLOCKS[4][41] = {
|
||||
// Version: (note that index 0 is for padding, and is set to an illegal value)
|
||||
//0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 Error correction level
|
||||
{-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25}, // Low
|
||||
{-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49}, // Medium
|
||||
{-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68}, // Quartile
|
||||
{-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81}, // High
|
||||
};
|
||||
|
||||
|
||||
qrcodegen::QrCode::ReedSolomonGenerator::ReedSolomonGenerator(int degree) :
|
||||
coefficients() {
|
||||
if (degree < 1 || degree > 255)
|
||||
throw "Degree out of range";
|
||||
|
||||
// Start with the monomial x^0
|
||||
coefficients.resize(degree);
|
||||
coefficients.at(degree - 1) = 1;
|
||||
|
||||
// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
|
||||
// drop the highest term, and store the rest of the coefficients in order of descending powers.
|
||||
// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
|
||||
int root = 1;
|
||||
for (int i = 0; i < degree; i++) {
|
||||
// Multiply the current product by (x - r^i)
|
||||
for (size_t j = 0; j < coefficients.size(); j++) {
|
||||
coefficients.at(j) = multiply(coefficients.at(j), static_cast<uint8_t>(root));
|
||||
if (j + 1 < coefficients.size())
|
||||
coefficients.at(j) ^= coefficients.at(j + 1);
|
||||
}
|
||||
root = (root << 1) ^ ((root >> 7) * 0x11D); // Multiply by 0x02 mod GF(2^8/0x11D)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
std::vector<uint8_t> qrcodegen::QrCode::ReedSolomonGenerator::getRemainder(const std::vector<uint8_t> &data) const {
|
||||
// Compute the remainder by performing polynomial division
|
||||
std::vector<uint8_t> result(coefficients.size());
|
||||
for (size_t i = 0; i < data.size(); i++) {
|
||||
uint8_t factor = data.at(i) ^ result.at(0);
|
||||
result.erase(result.begin());
|
||||
result.push_back(0);
|
||||
for (size_t j = 0; j < result.size(); j++)
|
||||
result.at(j) ^= multiply(coefficients.at(j), factor);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
uint8_t qrcodegen::QrCode::ReedSolomonGenerator::multiply(uint8_t x, uint8_t y) {
|
||||
// Russian peasant multiplication
|
||||
int z = 0;
|
||||
for (int i = 7; i >= 0; i--) {
|
||||
z = (z << 1) ^ ((z >> 7) * 0x11D);
|
||||
z ^= ((y >> i) & 1) * x;
|
||||
}
|
||||
if (z >> 8 != 0)
|
||||
throw "Assertion error";
|
||||
return static_cast<uint8_t>(z);
|
||||
}
|
||||
@ -0,0 +1,317 @@
|
||||
/*
|
||||
* QR Code generator library (C++)
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "QrSegment.hpp"
|
||||
|
||||
|
||||
namespace qrcodegen {
|
||||
|
||||
/*
|
||||
* Represents an immutable square grid of black and white cells for a QR Code symbol, and
|
||||
* provides static functions to create a QR Code from user-supplied textual or binary data.
|
||||
* This class covers the QR Code model 2 specification, supporting all versions (sizes)
|
||||
* from 1 to 40, all 4 error correction levels, and only 3 character encoding modes.
|
||||
*/
|
||||
class QrCode final {
|
||||
|
||||
/*---- Public helper enumeration ----*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Represents the error correction level used in a QR Code symbol.
|
||||
*/
|
||||
class Ecc final {
|
||||
// Constants declared in ascending order of error protection.
|
||||
public:
|
||||
const static Ecc LOW, MEDIUM, QUARTILE, HIGH;
|
||||
|
||||
// Fields.
|
||||
public:
|
||||
const int ordinal; // In the range 0 to 3 (unsigned 2-bit integer).
|
||||
const int formatBits; // In the range 0 to 3 (unsigned 2-bit integer).
|
||||
|
||||
// Constructor.
|
||||
private:
|
||||
Ecc(int ord, int fb);
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*---- Public static factory functions ----*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Returns a QR Code symbol representing the given Unicode text string at the given error correction level.
|
||||
* As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer Unicode
|
||||
* code points (not UTF-16 code units). The smallest possible QR Code version is automatically chosen for the output.
|
||||
*/
|
||||
static QrCode encodeText(const char *text, const Ecc &ecl);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a QR Code segment representing the given Unicode text string.
|
||||
*/
|
||||
static QrSegment encodeTextToSegment(const char *text);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a QR Code symbol representing the given binary data string at the given error correction level.
|
||||
* This function always encodes using the binary segment mode, not any text mode. The maximum number of
|
||||
* bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
|
||||
*/
|
||||
static QrCode encodeBinary(const std::vector<uint8_t> &data, const Ecc &ecl);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a QR Code symbol representing the given data segments at the given error
|
||||
* correction level. The smallest possible QR Code version is automatically chosen for the output.
|
||||
* This function allows the user to create a custom sequence of segments that switches
|
||||
* between modes (such as alphanumeric and binary) to encode text more efficiently. This
|
||||
* function is considered to be lower level than simply encoding text or binary data.
|
||||
*/
|
||||
static QrCode encodeSegments(const std::vector<QrSegment> &segs, const Ecc &ecl);
|
||||
|
||||
|
||||
|
||||
/*---- Instance fields ----*/
|
||||
|
||||
// Public immutable scalar parameters
|
||||
public:
|
||||
|
||||
/* This QR Code symbol's version number, which is always between 1 and 40 (inclusive). */
|
||||
const int version;
|
||||
|
||||
/* The width and height of this QR Code symbol, measured in modules.
|
||||
* Always equal to version × 4 + 17, in the range 21 to 177. */
|
||||
const int size;
|
||||
|
||||
/* The error correction level used in this QR Code symbol. */
|
||||
const Ecc &errorCorrectionLevel;
|
||||
|
||||
/* The mask pattern used in this QR Code symbol, in the range 0 to 7 (i.e. unsigned 3-bit integer).
|
||||
* Note that even if a constructor was called with automatic masking requested
|
||||
* (mask = -1), the resulting object will still have a mask value between 0 and 7. */
|
||||
private:
|
||||
int mask;
|
||||
|
||||
// Private grids of modules/pixels (conceptually immutable)
|
||||
private:
|
||||
std::vector<std::vector<bool>> modules; // The modules of this QR Code symbol (false = white, true = black)
|
||||
std::vector<std::vector<bool>> isFunction; // Indicates function modules that are not subjected to masking
|
||||
|
||||
|
||||
|
||||
/*---- Constructors ----*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Creates a new QR Code symbol with the given version number, error correction level, binary data string, and mask number.
|
||||
* This cumbersome constructor can be invoked directly by the user, but is considered
|
||||
* to be even lower level than encodeSegments().
|
||||
*/
|
||||
QrCode(int ver, const Ecc &ecl, const std::vector<uint8_t> &dataCodewords, int mask);
|
||||
|
||||
|
||||
/*
|
||||
* Creates a new QR Code symbol based on the given existing object, but with a potentially
|
||||
* different mask pattern. The version, error correction level, codewords, etc. of the newly
|
||||
* created object are all identical to the argument object; only the mask may differ.
|
||||
*/
|
||||
QrCode(const QrCode &qr, int mask);
|
||||
|
||||
|
||||
|
||||
/*---- Public instance methods ----*/
|
||||
public:
|
||||
|
||||
int getMask() const;
|
||||
|
||||
|
||||
/*
|
||||
* Returns the color of the module (pixel) at the given coordinates, which is either 0 for white or 1 for black. The top
|
||||
* left corner has the coordinates (x=0, y=0). If the given coordinates are out of bounds, then 0 (white) is returned.
|
||||
*/
|
||||
int getModule(int x, int y) const;
|
||||
|
||||
|
||||
/*
|
||||
* Based on the given number of border modules to add as padding, this returns a
|
||||
* string whose contents represents an SVG XML file that depicts this QR Code symbol.
|
||||
* Note that Unix newlines (\n) are always used, regardless of the platform.
|
||||
*/
|
||||
std::string toSvgString(int border) const;
|
||||
|
||||
|
||||
|
||||
/*---- Private helper methods for constructor: Drawing function modules ----*/
|
||||
private:
|
||||
|
||||
void drawFunctionPatterns();
|
||||
|
||||
|
||||
// Draws two copies of the format bits (with its own error correction code)
|
||||
// based on the given mask and this object's error correction level field.
|
||||
void drawFormatBits(int mask);
|
||||
|
||||
|
||||
// Draws two copies of the version bits (with its own error correction code),
|
||||
// based on this object's version field (which only has an effect for 7 <= version <= 40).
|
||||
void drawVersion();
|
||||
|
||||
|
||||
// Draws a 9*9 finder pattern including the border separator, with the center module at (x, y).
|
||||
void drawFinderPattern(int x, int y);
|
||||
|
||||
|
||||
// Draws a 5*5 alignment pattern, with the center module at (x, y).
|
||||
void drawAlignmentPattern(int x, int y);
|
||||
|
||||
|
||||
// Sets the color of a module and marks it as a function module.
|
||||
// Only used by the constructor. Coordinates must be in range.
|
||||
void setFunctionModule(int x, int y, bool isBlack);
|
||||
|
||||
|
||||
/*---- Private helper methods for constructor: Codewords and masking ----*/
|
||||
private:
|
||||
|
||||
// Returns a new byte string representing the given data with the appropriate error correction
|
||||
// codewords appended to it, based on this object's version and error correction level.
|
||||
std::vector<uint8_t> appendErrorCorrection(const std::vector<uint8_t> &data) const;
|
||||
|
||||
|
||||
// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
|
||||
// data area of this QR Code symbol. Function modules need to be marked off before this is called.
|
||||
void drawCodewords(const std::vector<uint8_t> &data);
|
||||
|
||||
|
||||
// XORs the data modules in this QR Code with the given mask pattern. Due to XOR's mathematical
|
||||
// properties, calling applyMask(m) twice with the same value is equivalent to no change at all.
|
||||
// This means it is possible to apply a mask, undo it, and try another mask. Note that a final
|
||||
// well-formed QR Code symbol needs exactly one mask applied (not zero, not two, etc.).
|
||||
void applyMask(int mask);
|
||||
|
||||
|
||||
// A messy helper function for the constructors. This QR Code must be in an unmasked state when this
|
||||
// method is called. The given argument is the requested mask, which is -1 for auto or 0 to 7 for fixed.
|
||||
// This method applies and returns the actual mask chosen, from 0 to 7.
|
||||
int handleConstructorMasking(int mask);
|
||||
|
||||
|
||||
// Calculates and returns the penalty score based on state of this QR Code's current modules.
|
||||
// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
|
||||
int getPenaltyScore() const;
|
||||
|
||||
|
||||
|
||||
/*---- Static helper functions ----*/
|
||||
private:
|
||||
|
||||
// Returns a set of positions of the alignment patterns in ascending order. These positions are
|
||||
// used on both the x and y axes. Each value in the resulting array is in the range [0, 177).
|
||||
// This stateless pure function could be implemented as table of 40 variable-length lists of unsigned bytes.
|
||||
static std::vector<int> getAlignmentPatternPositions(int ver);
|
||||
|
||||
|
||||
// Returns the number of raw data modules (bits) available at the given version number.
|
||||
// These data modules are used for both user data codewords and error correction codewords.
|
||||
// This stateless pure function could be implemented as a 40-entry lookup table.
|
||||
static int getNumRawDataModules(int ver);
|
||||
|
||||
|
||||
// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
|
||||
// QR Code of the given version number and error correction level, with remainder bits discarded.
|
||||
// This stateless pure function could be implemented as a (40*4)-cell lookup table.
|
||||
static int getNumDataCodewords(int ver, const Ecc &ecl);
|
||||
|
||||
|
||||
/*---- Tables of constants ----*/
|
||||
private:
|
||||
|
||||
// For use in getPenaltyScore(), when evaluating which mask is best.
|
||||
static const int PENALTY_N1;
|
||||
static const int PENALTY_N2;
|
||||
static const int PENALTY_N3;
|
||||
static const int PENALTY_N4;
|
||||
|
||||
static const int16_t NUM_ERROR_CORRECTION_CODEWORDS[4][41];
|
||||
static const int8_t NUM_ERROR_CORRECTION_BLOCKS[4][41];
|
||||
|
||||
|
||||
|
||||
/*---- Private helper class ----*/
|
||||
private:
|
||||
|
||||
/*
|
||||
* Computes the Reed-Solomon error correction codewords for a sequence of data codewords
|
||||
* at a given degree. Objects are immutable, and the state only depends on the degree.
|
||||
* This class exists because the divisor polynomial does not need to be recalculated for every input.
|
||||
*/
|
||||
class ReedSolomonGenerator final {
|
||||
|
||||
/*-- Immutable field --*/
|
||||
private:
|
||||
|
||||
// Coefficients of the divisor polynomial, stored from highest to lowest power, excluding the leading term which
|
||||
// is always 1. For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array {255, 8, 93}.
|
||||
std::vector<uint8_t> coefficients;
|
||||
|
||||
|
||||
/*-- Constructor --*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Creates a Reed-Solomon ECC generator for the given degree. This could be implemented
|
||||
* as a lookup table over all possible parameter values, instead of as an algorithm.
|
||||
*/
|
||||
ReedSolomonGenerator(int degree);
|
||||
|
||||
|
||||
/*-- Method --*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Computes and returns the Reed-Solomon error correction codewords for the given sequence of data codewords.
|
||||
* The returned object is always a new byte array. This method does not alter this object's state (because it is immutable).
|
||||
*/
|
||||
std::vector<uint8_t> getRemainder(const std::vector<uint8_t> &data) const;
|
||||
|
||||
|
||||
/*-- Static function --*/
|
||||
private:
|
||||
|
||||
// Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
|
||||
// are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
|
||||
static uint8_t multiply(uint8_t x, uint8_t y);
|
||||
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
@ -0,0 +1,141 @@
|
||||
/*
|
||||
* QR Code generator demo (C++)
|
||||
*
|
||||
* Run this command-line program with no arguments. The program computes a bunch of demonstration
|
||||
* QR Codes and prints them to the console. Also, the SVG code for one QR Code is printed as a sample.
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include "QrCode.hpp"
|
||||
|
||||
|
||||
// Function prototypes
|
||||
static void doBasicDemo();
|
||||
static void doVarietyDemo();
|
||||
static void doSegmentDemo();
|
||||
static void printQr(const qrcodegen::QrCode &qr);
|
||||
|
||||
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
doBasicDemo();
|
||||
doVarietyDemo();
|
||||
doSegmentDemo();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// Creates a single QR Code, then prints it to the console.
|
||||
static void doBasicDemo() {
|
||||
const char *text = "Hello, world!"; // User-supplied text
|
||||
const qrcodegen::QrCode::Ecc &errCorLvl = qrcodegen::QrCode::Ecc::LOW; // Error correction level
|
||||
|
||||
// Make and print the QR Code symbol
|
||||
const qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(text, errCorLvl);
|
||||
std::cout << qr.toSvgString(4) << std::endl;
|
||||
printQr(qr);
|
||||
}
|
||||
|
||||
|
||||
// Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console.
|
||||
static void doVarietyDemo() {
|
||||
// Project Nayuki URL
|
||||
const qrcodegen::QrCode qr0 = qrcodegen::QrCode::encodeText("https://www.nayuki.io/", qrcodegen::QrCode::Ecc::HIGH);
|
||||
printQr(qrcodegen::QrCode(qr0, 3)); // Change mask, forcing to mask #3
|
||||
|
||||
// Numeric mode encoding (3.33 bits per digit)
|
||||
const qrcodegen::QrCode qr1 = qrcodegen::QrCode::encodeText("314159265358979323846264338327950288419716939937510", qrcodegen::QrCode::Ecc::MEDIUM);
|
||||
printQr(qr1);
|
||||
|
||||
// Alphanumeric mode encoding (5.5 bits per character)
|
||||
const qrcodegen::QrCode qr2 = qrcodegen::QrCode::encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", qrcodegen::QrCode::Ecc::HIGH);
|
||||
printQr(qr2);
|
||||
|
||||
// Unicode text as UTF-8, and different masks
|
||||
const qrcodegen::QrCode qr3 = qrcodegen::QrCode::encodeText("\xE3\x81\x93\xE3\x82\x93\xE3\x81\xAB\xE3\x81\xA1wa\xE3\x80\x81\xE4\xB8\x96\xE7\x95\x8C\xEF\xBC\x81\x20\xCE\xB1\xCE\xB2\xCE\xB3\xCE\xB4", qrcodegen::QrCode::Ecc::QUARTILE);
|
||||
printQr(qrcodegen::QrCode(qr3, 0));
|
||||
printQr(qrcodegen::QrCode(qr3, 1));
|
||||
printQr(qrcodegen::QrCode(qr3, 5));
|
||||
printQr(qrcodegen::QrCode(qr3, 7));
|
||||
|
||||
// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
|
||||
const qrcodegen::QrCode qr4 = qrcodegen::QrCode::encodeText("Alice was beginning to get very tired of sitting by her sister on the bank, "
|
||||
"and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
|
||||
"but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
|
||||
"'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
|
||||
"for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
|
||||
"daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
|
||||
"a White Rabbit with pink eyes ran close by her.",
|
||||
qrcodegen::QrCode::Ecc::HIGH);
|
||||
printQr(qr4);
|
||||
}
|
||||
|
||||
|
||||
// Creates QR Codes with manually specified segments for better compactness.
|
||||
static void doSegmentDemo() {
|
||||
// Illustration "silver"
|
||||
const char *silver0 = "THE SQUARE ROOT OF 2 IS 1.";
|
||||
const char *silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
|
||||
const qrcodegen::QrCode qr0 = qrcodegen::QrCode::encodeText(
|
||||
(std::string(silver0) + silver1).c_str(),
|
||||
qrcodegen::QrCode::Ecc::LOW);
|
||||
printQr(qr0);
|
||||
|
||||
std::vector<qrcodegen::QrSegment> segs;
|
||||
segs.push_back(qrcodegen::QrSegment::makeAlphanumeric(silver0));
|
||||
segs.push_back(qrcodegen::QrSegment::makeNumeric(silver1));
|
||||
const qrcodegen::QrCode qr1 = qrcodegen::QrCode::encodeSegments(segs, qrcodegen::QrCode::Ecc::LOW);
|
||||
printQr(qr1);
|
||||
|
||||
// Illustration "golden"
|
||||
const char *golden0 = "Golden ratio \xCF\x86 = 1.";
|
||||
const char *golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
|
||||
const char *golden2 = "......";
|
||||
const qrcodegen::QrCode qr2 = qrcodegen::QrCode::encodeText(
|
||||
(std::string(golden0) + golden1 + golden2).c_str(),
|
||||
qrcodegen::QrCode::Ecc::LOW);
|
||||
printQr(qr2);
|
||||
|
||||
segs.clear();
|
||||
std::vector<uint8_t> bytes;
|
||||
for (const char *temp = golden0; *temp != '\0'; temp++)
|
||||
bytes.push_back(static_cast<uint8_t>(*temp));
|
||||
segs.push_back(qrcodegen::QrSegment::makeBytes(bytes));
|
||||
segs.push_back(qrcodegen::QrSegment::makeNumeric(golden1));
|
||||
segs.push_back(qrcodegen::QrSegment::makeAlphanumeric(golden2));
|
||||
const qrcodegen::QrCode qr3 = qrcodegen::QrCode::encodeSegments(segs, qrcodegen::QrCode::Ecc::LOW);
|
||||
printQr(qr3);
|
||||
}
|
||||
|
||||
|
||||
// Prints the given QR Code to the console.
|
||||
static void printQr(const qrcodegen::QrCode &qr) {
|
||||
int border = 4;
|
||||
for (int y = -border; y < qr.size + border; y++) {
|
||||
for (int x = -border; x < qr.size + border; x++) {
|
||||
std::cout << (qr.getModule(x, y) == 1 ? "##" : " ");
|
||||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,138 @@
|
||||
/*
|
||||
* QR Code generator library (C++)
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#include "BitBuffer.hpp"
|
||||
#include "QrSegment.hpp"
|
||||
|
||||
|
||||
qrcodegen::QrSegment::Mode::Mode(int mode, int cc0, int cc1, int cc2) :
|
||||
modeBits(mode) {
|
||||
numBitsCharCount[0] = cc0;
|
||||
numBitsCharCount[1] = cc1;
|
||||
numBitsCharCount[2] = cc2;
|
||||
}
|
||||
|
||||
|
||||
int qrcodegen::QrSegment::Mode::numCharCountBits(int ver) const {
|
||||
if ( 1 <= ver && ver <= 9) return numBitsCharCount[0];
|
||||
else if (10 <= ver && ver <= 26) return numBitsCharCount[1];
|
||||
else if (27 <= ver && ver <= 40) return numBitsCharCount[2];
|
||||
else throw "Version number out of range";
|
||||
}
|
||||
|
||||
|
||||
const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::NUMERIC (0x1, 10, 12, 14);
|
||||
const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::ALPHANUMERIC(0x2, 9, 11, 13);
|
||||
const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::BYTE (0x4, 8, 16, 16);
|
||||
const qrcodegen::QrSegment::Mode qrcodegen::QrSegment::Mode::KANJI (0x8, 8, 10, 12);
|
||||
|
||||
|
||||
|
||||
qrcodegen::QrSegment qrcodegen::QrSegment::makeBytes(const std::vector<uint8_t> &data) {
|
||||
return QrSegment(Mode::BYTE, data.size(), data, data.size() * 8);
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrSegment qrcodegen::QrSegment::makeNumeric(const char *digits) {
|
||||
BitBuffer bb;
|
||||
int accumData = 0;
|
||||
int accumCount = 0;
|
||||
int charCount = 0;
|
||||
for (; *digits != '\0'; digits++, charCount++) {
|
||||
char c = *digits;
|
||||
if (c < '0' || c > '9')
|
||||
throw "String contains non-numeric characters";
|
||||
accumData = accumData * 10 + (c - '0');
|
||||
accumCount++;
|
||||
if (accumCount == 3) {
|
||||
bb.appendBits(accumData, 10);
|
||||
accumData = 0;
|
||||
accumCount = 0;
|
||||
}
|
||||
}
|
||||
if (accumCount > 0) // 1 or 2 digits remaining
|
||||
bb.appendBits(accumData, accumCount * 3 + 1);
|
||||
return QrSegment(Mode::NUMERIC, charCount, bb.getBytes(), bb.getBitLength());
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrSegment qrcodegen::QrSegment::makeAlphanumeric(const char *text) {
|
||||
BitBuffer bb;
|
||||
int accumData = 0;
|
||||
int accumCount = 0;
|
||||
int charCount = 0;
|
||||
for (; *text != '\0'; text++, charCount++) {
|
||||
char c = *text;
|
||||
if (c < ' ' || c > 'Z')
|
||||
throw "String contains unencodable characters in alphanumeric mode";
|
||||
accumData = accumData * 45 + ALPHANUMERIC_ENCODING_TABLE[c - ' '];
|
||||
accumCount++;
|
||||
if (accumCount == 2) {
|
||||
bb.appendBits(accumData, 11);
|
||||
accumData = 0;
|
||||
accumCount = 0;
|
||||
}
|
||||
}
|
||||
if (accumCount > 0) // 1 character remaining
|
||||
bb.appendBits(accumData, 6);
|
||||
return QrSegment(Mode::ALPHANUMERIC, charCount, bb.getBytes(), bb.getBitLength());
|
||||
}
|
||||
|
||||
|
||||
qrcodegen::QrSegment::QrSegment(const Mode &md, int numCh, const std::vector<uint8_t> &b, int bitLen) :
|
||||
mode(md),
|
||||
numChars(numCh),
|
||||
data(b),
|
||||
bitLength(bitLen) {
|
||||
if (numCh < 0 || bitLen < 0 || b.size() != static_cast<unsigned int>((bitLen + 7) / 8))
|
||||
throw "Invalid value";
|
||||
}
|
||||
|
||||
|
||||
bool qrcodegen::QrSegment::isAlphanumeric(const char *text) {
|
||||
for (; *text != '\0'; text++) {
|
||||
char c = *text;
|
||||
if (c < ' ' || c > 'Z' || ALPHANUMERIC_ENCODING_TABLE[c - ' '] == -1)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool qrcodegen::QrSegment::isNumeric(const char *text) {
|
||||
for (; *text != '\0'; text++) {
|
||||
char c = *text;
|
||||
if (c < '0' || c > '9')
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
const int8_t qrcodegen::QrSegment::ALPHANUMERIC_ENCODING_TABLE[59] = {
|
||||
// SP, !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, :, ;, <, =, >, ?, @, // ASCII codes 32 to 64
|
||||
36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, -1, // Array indices 0 to 32
|
||||
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, // Array indices 33 to 58
|
||||
// A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, // ASCII codes 65 to 90
|
||||
};
|
||||
@ -0,0 +1,154 @@
|
||||
/*
|
||||
* QR Code generator library (C++)
|
||||
*
|
||||
* Copyright (c) 2016 Project Nayuki
|
||||
* https://www.nayuki.io/page/qr-code-generator-library
|
||||
*
|
||||
* (MIT License)
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
* - The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
* - The Software is provided "as is", without warranty of any kind, express or
|
||||
* implied, including but not limited to the warranties of merchantability,
|
||||
* fitness for a particular purpose and noninfringement. In no event shall the
|
||||
* authors or copyright holders be liable for any claim, damages or other
|
||||
* liability, whether in an action of contract, tort or otherwise, arising from,
|
||||
* out of or in connection with the Software or the use or other dealings in the
|
||||
* Software.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
|
||||
namespace qrcodegen {
|
||||
|
||||
/*
|
||||
* Represents a character string to be encoded in a QR Code symbol. Each segment has
|
||||
* a mode, and a sequence of characters that is already encoded as a sequence of bits.
|
||||
* Instances of this class are immutable.
|
||||
* This segment class imposes no length restrictions, but QR Codes have restrictions.
|
||||
* Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
|
||||
* Any segment longer than this is meaningless for the purpose of generating QR Codes.
|
||||
*/
|
||||
class QrSegment final {
|
||||
|
||||
/*---- Public helper enumeration ----*/
|
||||
|
||||
/*
|
||||
* The mode field of a segment. Immutable. Provides methods to retrieve closely related values.
|
||||
*/
|
||||
public:
|
||||
class Mode final {
|
||||
// Constants.
|
||||
public:
|
||||
static const Mode NUMERIC;
|
||||
static const Mode ALPHANUMERIC;
|
||||
static const Mode BYTE;
|
||||
static const Mode KANJI;
|
||||
|
||||
|
||||
/*-- Fields --*/
|
||||
|
||||
/* An unsigned 4-bit integer value (range 0 to 15) representing the mode indicator bits for this mode object. */
|
||||
public:
|
||||
const int modeBits;
|
||||
|
||||
private:
|
||||
int numBitsCharCount[3];
|
||||
|
||||
|
||||
// Constructor.
|
||||
private:
|
||||
Mode(int mode, int cc0, int cc1, int cc2);
|
||||
|
||||
|
||||
/*-- Method --*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Returns the bit width of the segment character count field for this mode object at the given version number.
|
||||
*/
|
||||
int numCharCountBits(int ver) const;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*---- Static factory functions ----*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Returns a segment representing the given binary data encoded in byte mode.
|
||||
*/
|
||||
static QrSegment makeBytes(const std::vector<uint8_t> &data);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a segment representing the given string of decimal digits encoded in numeric mode.
|
||||
*/
|
||||
static QrSegment makeNumeric(const char *digits);
|
||||
|
||||
|
||||
/*
|
||||
* Returns a segment representing the given text string encoded in alphanumeric mode. The characters allowed are:
|
||||
* 0 to 9, A to Z (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
|
||||
*/
|
||||
static QrSegment makeAlphanumeric(const char *text);
|
||||
|
||||
|
||||
/*---- Static helper functions ----*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Tests whether the given string can be encoded as a segment in alphanumeric mode.
|
||||
*/
|
||||
static bool isAlphanumeric(const char *text);
|
||||
|
||||
|
||||
/*
|
||||
* Tests whether the given string can be encoded as a segment in numeric mode.
|
||||
*/
|
||||
static bool isNumeric(const char *text);
|
||||
|
||||
|
||||
|
||||
/*---- Instance fields ----*/
|
||||
public:
|
||||
|
||||
/* The mode indicator for this segment. */
|
||||
const Mode mode;
|
||||
|
||||
/* The length of this segment's unencoded data, measured in characters. Always zero or positive. */
|
||||
const int numChars;
|
||||
|
||||
/* The bits of this segment packed into a byte array in big endian. */
|
||||
const std::vector<uint8_t> data;
|
||||
|
||||
/* The length of this segment's encoded data, measured in bits. Satisfies ceil(bitLength / 8) = data.size(). */
|
||||
const int bitLength;
|
||||
|
||||
|
||||
/*---- Constructor ----*/
|
||||
public:
|
||||
|
||||
/*
|
||||
* Creates a new QR Code data segment with the given parameters and data.
|
||||
*/
|
||||
QrSegment(const Mode &md, int numCh, const std::vector<uint8_t> &b, int bitLen);
|
||||
|
||||
|
||||
/*---- Constant ----*/
|
||||
private:
|
||||
|
||||
static const int8_t ALPHANUMERIC_ENCODING_TABLE[59];
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
Loading…
Reference in new issue